1、python 面向对象的主要特性。主要有类、对象。三大特点：封装、继承、多态。本次主要介绍内容：属性、方法、构造函数、析构函数。私有方法、私有属性。
oop 是使用类和对象来实现对真是世界的描述。万事万物皆可为类。基于面向对象的程序使人更加容易理解的你逻辑。提高开发效率
class 类。对具有相同属性的对象的抽象。可以理解为模板。在类中定义了这些对象共同拥有的属性和方法。（上帝创造地球的模板）
object 对象。对象是类的实例化。一个类可以实例化多个对象。每个对象可以具有不同的属性。例如人。人与人既有共同属性。也有不同属性。
封装。在内部调用函数。对外部是透明的（对外部不可见）。
继承。子类可以自动继承父类的属性和方法
多态。一个接口，多重实现。（比喻老板说开始工作，销售部开始销售工作。技术部开始的开发工作）
2、面向对象。类的简单定义。和对象实例化。
class dog:
def __init__(self,name):
self.name = name
def bulk(self):
print("wang !!!!!!! %s"%(self.name))
dog1 =dog("test1")
dog2 = dog("test2")
dog1.bulk()
dog2.bulk()
3、写代码原则。
一、重复代码是非常不好的行为
二、写的代码经常变更
4、类初始化深入理解: 对象创建的过程。每次创建一个对象相当于开辟一块内存空间如r1。每次在调用函数时候。实际相当于将r1作为一个参数传递给类的函数
（记住：是调用类的函数。所有对象公用。并不是每个对象的内存空间都会复制这个函数体，节省内存空间）
class role :
def __init__(self,name,wepon,life_value= 00):
#构造函数
#在实例化时候。做一些初始化工作
self.name = name
self.wepon = wepon
self.life_value = life_value
def get_shot(self):
print("I got shot")
# 在内存中是完全不同的两个对象
#role("xiajinqi","fireball")
#
r1 = role("xiajinqi","fireball")
‘‘‘
r1 = role("xiajinqi","fireball")
1、申请一个内存地址r1.
2、r1传递给类role
3、role.__init__(r1,"xiajinqi","fireball")
备注：创建一个对象。相当于开辟一块内存空间。里面会存储变量等相关值。但是（类函数并没有复制一份，只是在调用时候，
传一个对象的内存地址来做区分不同的对象。好处就是节约内存空间），
如：role.__init__(r1,"xiajinqi","fireball") ，role.__init__(r2,"xiajinqi","fireball")
‘‘‘
内存存储图：
5、类变量和实例变量。 作用范围。
当某个变量在类和实例中都存在时候。优先取实例变量
class role :
n = 12345 #类变量，对象共享
name = "tset"
def __init__(self,name,wepon,life_value= 00):
#构造函数
#在实例化时候。做一些初始化工作
self.name = name #实例变量 。未某个对象所独享
self.wepon = wepon
self.life_value = life_value
def get_shot(self):
print("I got shot")
print(role.n,role.name)
r1=role("ploice1","fireball")
r2=role("ploice2","fireball")
print(r1.n,r1.name) # 当name这个变量在实例和类都存在的。值先从对象开始找。没有时候取类的变量打印值为ploice1
print(r2.n,r2.name)# 当name这个变量在对象和类种都存在的。值先从对象开始找。没有时候取类的变量打印值为ploice2
#
E:\Users\xiajinqi\PycharmProjects\Atm\venv\Scripts\python.exe E:/Users/xiajinqi/PycharmProjects/Atm/bin/test.py
12345 tset
12345 ploice1
12345 ploice2
Process finished with exit code 0
6、实例化以后。变量的修改和删除增加。 特殊说明：对象可以查类变量（实例变量不存在取类变量），但是不能修改和删除类变量。类变量修改只能由自己修改
如：r1.n = 100
.如果n存在，就表示修改。如果n不存在。
class role :
n = 12345 #类变量，对象共享
name = "tset"
def __init__(self,name,wepon,life_value= 00):
#构造函数
#在实例化时候。做一些初始化工作
self.name = name #实例变量 。未某个对象所独享
self.wepon = wepon
self.life_value = life_value
def get_shot(self):
print("I got shot")
print(role.n,role.name)
r1=role("ploice1","fireball")
r2=role("ploice2","fireball")
r1.n=‘11111‘ # 相当于实例r1自己给自己创建了一个变量n,r1.n=n。。因此不会改变类变量
print(r1.n) #
print(r2.n)# # 类变量依旧不能变
print(role.n)
E:\Users\xiajinqi\PycharmProjects\Atm\venv\Scripts\python.exe E:/Users/xiajinqi/PycharmProjects/Atm/bin/test.py
12345 tset
11111
12345
12345
7、类变量修改。类变量修改只能由类自己修改。所有实例都无法直接修改类变量。
并且类变量修改的影响范围为:实例对象中没有改变量，需要调用类变量的实例将受到影响。
class role :
n = 12345 #类变量，对象共享
name = "tset"
def __init__(self,name,wepon,life_value= 00):
#构造函数
#在实例化时候。做一些初始化工作
self.name = name #实例变量 。未某个对象所独享
self.wepon = wepon
self.life_value = life_value
def get_shot(self):
print("I got shot")
print(role.n,role.name)
r1=role("ploice1","fireball")
r2=role("ploice2","fireball")
r1.n=‘11111‘ # 相当于实例r1自己给自己创建了一个变量n,r1.n=n。。因此不会改变类变量
print(r1.n) #
# 修改类变量
role.n = 88888
print(r2.n)
print(role.n)
E:\Users\xiajinqi\PycharmProjects\Atm\venv\Scripts\python.exe E:/Users/xiajinqi/PycharmProjects/Atm/bin/test.py
12345 tset
11111
88888
88888
Process finished with exit code 0
8、类变量的作业。例如：国际字段默认为中国。有少量人国际其他国际。所有未中国国际的人可以共用一个内存空间。从而节省内存。
9、析构函数。在实例销毁、结束时候执行。通常用于关闭数据库连接的打开的临时文件关闭等
class role :
n = 12345 #类变量，对象共享
name = "tset"
def __init__(self,name,wepon,life_value= 00):
#构造函数
#在实例化时候。做一些初始化工作
self.name = name #实例变量 。未某个对象所独享
self.wepon = wepon
self.life_value = life_value
def get_shot(self):
print("I got shot")
def __del__(self):
print("ha game over")
# 程序执行结束后。自动调用
r1=role("ploice1","fireball")
r1.get_shot()
r2=role("ploice1","fireball")
r2.get_shot()
E:\Users\xiajinqi\PycharmProjects\Atm\venv\Scripts\python.exe E:/Users/xiajinqi/PycharmProjects/Atm/bin/test.py
I got shot
I got shot
ha game over
ha game over
python 内存回收机制。当变量销毁时候。会自动回收
class role :
n = 12345 #类变量，对象共享
name = "tset"
def __init__(self,name,wepon,life_value= 00):
#构造函数
#在实例化时候。做一些初始化工作
self.name = name #实例变量 。未某个对象所独享
self.wepon = wepon
self.life_value = life_value
def get_shot(self):
print("I got shot")
def __del__(self):
print("ha game over")
# 程序执行结束后。自动调用
r1=role("ploice1","fireball")
r1.get_shot()
del r1
r2=role("ploice1","fireball")
r2.get_shot()
E:\Users\xiajinqi\PycharmProjects\Atm\venv\Scripts\python.exe E:/Users/xiajinqi/PycharmProjects/Atm/bin/test.py
I got shot
ha game over
I got shot
ha game over
Process finished with exit code 0
10、类的继承。简单实用
class People :
def __init__(self,name,age):
self.name = name
self.age = age
def eat(self):
print("%s eat" %(self.name))
def sleep(self):
print("%s sleep" % (self.name))
class Man(People):
def game(self):
print("%s game" % (self.name))
def sleep(self):
print("%s man is sleep" % (self.name)) # 覆盖
def eat(self):
People.eat(self) # 先调用父类。然后执行自己的函数体
print("%s eat" % (self.name)) # 重构
man1 =Man("xiajinqi","19")
man1.sleep() # 继承父类。
man1.game() # 玩游戏。自己的类
man1.eat() #重构
11、多继承和新式类。继承顺序。从左到右。
# 继承优先级，先执行自己的构造方法，再去调用Relation
#class Poeple： 经典类
class People(object) : #新式类
def __init__(self,name,age):
self.name = name
self.age = age
def eat(self):
print("%s eat" %(self.name))
def sleep(self):
print("%s sleep" % (self.name))
class Relation(object):
def make_friends(self): # obj
print("make %s"%(self.name))
class Man(People,Relation): # 新式类鞋码
def __init__(self, name, age, money):
super(Man, self).__init__(name, age)
self.money = money
def game(self):
print("%s game" % (self.name))
def sleep(self):
print("%s man is sleep" % (self.name)) # 覆盖
def eat(self):
People.eat(self) # 先调用父类。然后执行自己的函数体
print("%s eat" % (self.name)) # 重构
man1 =Man("xiajinqi","19",‘10000‘)
man1.make_friends()
E:\Users\xiajinqi\PycharmProjects\Atm\venv\Scripts\python.exe E:/Users/xiajinqi/PycharmProjects/Atm/bin/test.py
make fir xiajinqi
Process finished with exit code 0
12、类的继承顺序。广度优先
class shoool(object):
def __init__(self,addr,name):
self.addr = addr
self.name = name
self.students = []
self.teacher = []
def en_roll(self,obj_student):
self.students.append(obj_student)
print("注册学员 %s" %(obj_student.name))
def hire(self,obj_teacher):
self.teacher.append(obj_teacher)
print("注册学员 %s" % (obj_teacher.name))
class school_member(object):
def __init__(self,name,age):
self.name = name
self.age = age
def tell(self):
pass
class student(school_member):
def __init__(self,name,age,grade):
super(student,self).__init__(name,age)
self.grade = grade
def tell(self):
print(‘‘‘
name:
age:
garde:
‘‘‘%(self.name,self.age,self.garde))
class teacher(school_member):
def __init__(self, name,age,salary):
super(teacher, self).__init__(name,age)
self.salary = salary
def tell(self):
print(‘‘‘
name:
age:
salary:
‘‘‘ % (self.name, self.age, self.salary))
shoool1 = shoool("北京","老男孩")
student1 = student("test1","22","一班")
student2 = student("test2","22","二班")
teacher1 = teacher("teacher1","33","2000000")
teacher2 = teacher("teacher2","33","2000000")
shoool1.en_roll(student1)
shoool1.en_roll(student2)
shoool1.hire(teacher1)
shoool1.hire(teacher2)
# 打印所有注册老师
for student in shoool1.students :
print(student.name)
for teacher in shoool1.teacher :
print(teacher.name)
13、多态.可以实现。统一接口多种实现。
class am(object):
def __init__(self,name):
print("name %s" %(name))
# 接口
def am(obj):
obj.talk()
class dog(am):
def talk(self):
print("wangwang")
class cat(am):
def talk(self):
print("miaomiao")
dog1 = dog("test1")
cat2 = cat("test1")
am.am(cat2)
14课后练习题目：
角色：学校、学员、课程、讲师
要求：
1、创建北京、上海学校
2、创建linux/python/C++ 3个课程 linxu/python 在北京开。C++在上海开。
3、课程包含。周期、价格。通过学校创建课程。
4、通过学校创建班级。班级关联课程、讲师
5、创建学员时，选择学校。关联班级
6、创建讲师角色时要选择学校
7、提供角色接口
7、1 学员视图，可以注册。交学费。选择班级
7、2 讲师视图。讲师可以管理自己的班级。上课选择班级。查看班级学员列表。修改所管理学员的成绩
7/3 管理视图。创建讲师、创建班级、创建课程
7/4上面所有操作通过pickel序列化保存到文件。
原文地址：https://www.cnblogs.com/xiajq/p/9032943.html
时间： 2024-10-30 10:21:28