面向过程式编程：提高了代码的可读性，减少了代码的重复性 面向过程式编程：
优点：出色的完成你之前布置的所有的需求
坏处：但凡更改或者增加一条需求，可能整个项目都随之改变
面向对象编程（优点）：是一类相似功能函数的集合体，使你的代码更加清晰化合理化
类：就是具有相似功能和特性的一类事物
对象：类的具体体现
类的第二个优点：你要站在上帝的角度上去考虑，类一个公共模板，对象是从这个公共的模板产出的
面向对象，要拥有上帝的视角看问题，类其实就是一个公共模板（厂房），对象就从具体的模板实例化出来
class是关键字与def用法相同，定义一个类 类名具有描述性，类名首字母大写，类名不易用__
类的结构从大方向来说就分为两个部分： 静态变量 动态方法
面向对象的结构： 结构上分析：
class Student: daily=‘学习‘ # 变量（之前的方法）叫：静态属性，属性 或 静态字段 examination=‘考试‘ ? def work(self): # 函数（之前） 叫：方法，动态方法， 或 动态属性 print(‘每天要上课‘) ? def homework(self): print(‘家庭作业‘)
查看类中所有内容：类名.__ dict__方法。只用于获取类中的全部
class Student: daily=‘学习‘ # 变量（之前的叫法）叫：静态属性，属性 或 静态字段 examination=‘考试‘ ? def work(self): # 函数（之前的叫法）叫：方法，动态方法， 或 动态属性 print(‘每天要上课‘) ? def homework(self): print(‘家庭作业‘) ? # 2.万能的点。 print(Student.daily) # 查 Student.cloth=‘校服‘ # 增 print(Student.__dict__) Student.examination=‘不考试‘ # 改 print(Student.examination) del Student.daily # 删 print(Student.__dict__) ? # 如果想查询类中的所有内容，通过__dict__方法，如果只是操作单个属性值这用万能的点
前提：一般不会通过类名操作一个类中的方法。除了两个特殊方法：静态方法，类方法之外，
class Student: """ 此类是构建学生类 """ daily = ‘学习‘ examination = ‘考试‘ ? def work(self): print(‘每天要上课‘) def homework(self): print(‘家庭作业‘) Student.work(123) # 通过类名调用类中的动态方法，必须要传一个参数否则会报错 Student.homework(456) Student.__dict__[‘work‘](111) # Human.__dict__[‘work‘]指向函数的内存地址
实例化过程：类名加上（），这就是一个实例化过程，实例化一个对象的过程
实例化一个对象总共发生三件事：
1.在内存中开辟一个对象空间
2.自动执行__ init__ 方法，并将这个对象空间（的内存地址）传给了__ init__ 的第一个参数self。
3.执行__ init__ 方法里面的代码，给对象空间封装属性。
对象操作对象中的属性：
对象查询对象中所有属性：对象.__ dict__
对象操作对象空间属性：
万能的点：对象.属性=值 如果属性没有就添加，有且值不相同就修改
del 对象.属性 删除某个属性 ? print（对象.属性 ） 查看某个值
class Student: #创建一个Student空间 类中的方法和属性依次加载进去 daily=‘学习‘ examination=‘考试‘ ? def __init__(self): self.name=‘小黑‘ self.sex=‘随便‘ ? ? def work(self): print(‘每天要上课‘) ? def homework(self): print(‘家庭作业‘) ? obj=Student() # 创建一个obj空间，执行__init__ # print(obj) ? # 对象可以操作对象空间的属性 通过万能的点 ? obj.age=18 # 增 del obj.name # 删 obj.sex=‘女‘ # 改 print(obj.name) # 查 ? print(obj.__dict__) # 查看对象中的所有内容
对象查看类中的属性
只能查看不能修改
class Student: ? daily = ‘学习‘ examination = ‘考试‘ ? def __init__(self,n,a,h): self.name = n self.age = a self.hobby = h ? def work(self,c): # self.color = ‘绿色‘ self.color = c print(f‘{self.name}每天要上课‘) ? def homework(self): # 利用self 对象空间,为所欲为 print(‘家庭作业‘) ? # 对象查看类中的属性 sq=Student(‘骚强‘,18,‘跳唱‘) print(sq.daily) sq.daily=‘骚麦‘ # 这里相当于给sq这个对象添加了一个属性 print(sq.daily) print(sq.__dict__) # 修改的是对象中的属性，并没有对类种的daily进行操作 print(Student.daily) # 类中的daily并没有发生改变
对象操作类中的方法
对象.方法名()
class Student: daily=‘学习‘ examination=‘考试‘ ? def __init__(self,n,a,h): self.name=n self.age=a self.habby=h ? ? def work(self,c): self.color=c print(‘每天要上课‘) ? def homework(self): print(‘家庭作业‘) ? ly=Student(‘小黑‘,21,‘学习‘) ly.work(‘黑色‘) print(ly.__dict__) ?
self 就是类中方法的第一个位置参数，
如果通过对象执行此方法，解释器就会自动的将此对象空间当做实参传给self
约定俗称：类中的方法第一个参数一般都设置成self
对象的属性不仅可以再__ init__里面添加，还可以在类的其他方法或l类的外面添加
class A: def __init__(self,name): self.name=name ? def func(self,sex): self.sex=sex ? # 类的外面： obj=A(‘barry‘) obj.age=18 ? print(obj.__dict__) #{‘name‘: ‘barry‘, ‘age‘: 18} ? # 类的内部 obj=A(‘barry‘) # init可以添加 obj.func(‘男‘) # func方法也可以 print(obj.__dict__) #{‘name‘: ‘barry‘, ‘sex‘: ‘男‘}
何处添加类的对象属性：
类的属性不仅可以在外部添加也可以在内部添加
class A: def __init__(self,name): self.name=name ? def func(self,sex): self.sex=sex ? def func1(self): A.bbb=‘ccc‘ ? # 类的外部可以添加,通过类名.属性名=值的形式 A.ccc=‘taibai‘ ? print(A.__dict__) ? # 类的内部可以添加，通过动态方法添加 A.func1(111) # 通过类名调用动态方法需要传值 print(print(A.__dict__))
对象如何找到类的属性：
具体过程：
1.实例化一个对象，产生一个对象空间，此时这个对象空间不是空的而是有一个类对象指针(相当于指示牌)
2.自动执行__ init方法，将对象空间传给self
3.执行__ init__中的代码，给对象空间封装属性 对象之所以可以找到类，是因为对象空间中有类指针这个东西
执行流程：
以下顺序都是单向不可逆的：
对象查找属性的顺序：先从对象空间中找--------->类空间--------->父类空间中找--------->……
类名查找属性的顺序：先从本类空间中找--------->父类空间中找--------->……
对象与对象之间原则上是互相独立（除去组合这种特殊的关系之外）
类与类之间的关系：
1.依赖关系
2.组合关系
3.继承关系(类的三大特性之一：继承。)
将一个对象或者类名传递到另一个类的方法中
class Elephant: def __init__(self,name): self.name=name ? def open(self,ref): print(f‘{self.name}大象默念三声：芝麻开门‘) ref.open_door() ? def close(self,ref): print(f‘{self.name}大象默念三声：芝麻关门‘) ref.close_door() ? class Refrigerator: def __init__(self,name): self.name=name ? def open_door(self): print(f‘{self.name}冰箱门被打开了‘) ? def close_door(self): print(f‘{self.name}冰箱门被关上了‘) ? ele=Elephant(‘琪琪‘) # 实例化一个大象 ref=Refrigerator(‘美菱‘) # 实例化一个冰箱 ele.open(ref) ele.close(ref)
1.关联关系. 两种事物必须是互相关联的. 但是在某些特殊情况下是可以更改和更换的.
2.聚合关系. 属于关联关系中的?种特例. 侧重点是xxx和xxx聚合成xxx. 各?有各?的声明周期. 比如电脑. 电脑?有CPU, 硬盘, 内存等等. 电脑挂了. CPU还是好的. 还是完整的个体
3.组合关系. 属于关联关系中的?种特例. 写法上差不多. 组合关系比聚合还要紧密. 比如?的?脑, ?脏, 各个器官. 这些器官组合成?个?. 这时. ?如果挂了. 其他的东?也跟着挂了
class Boy: def __init__(self,name,): self.name=name ? def meet(self,girl_friend=None): self.girl_friend=girl_friend # 相当于给wu这个对象空间添加一个属性，这个属性值 # 是flower这个对象空间因此我们可以通过self.gril_friend对 # flower这个对象空间里面的属性进行操作 ? ? def have_diner(self): # self==wu这个对象空间 if self.girl_friend: print(f‘{self.name}和{self.girl_friend.name}一起吃六快钱的麻辣烫‘) self.girl_friend.shopping(self) # self相当于wu这个对象空间 else: print(‘单身狗，吃什么饭‘) class Girl: def __init__(self,name,age): self.name=name self.age=age ? def shopping(self,boy): print(f‘{boy.name}和{self.name}一起去购物‘) ? wu=Boy(‘吴超‘) # wu.have_diner() flower=Girl(‘如花‘,32) wu.meet(flower) # 把flower这个对象封装给wu这个对象空间 wu.have_diner()
组合：将一个类的对象封装到另一个类的对象的属性中，就叫做组合
一个类的方法只能由此类的方法去调用
一个类的方法的第一个self只接受此类的对象
class class Gamerole: def __init__(self,name,ad,hp): self.name=name self.ad=ad self.hp=hp ? def attack(self,p1): p1.hp -= self.ad print(f‘{self.name}攻击了{p1.name},掉了{self.ad}血,还剩{p1.hp}血‘) ? def equip_weapon(self,wea): self.wea=wea # 把武器对象封装给Gamerole这个类，通过类可以对者个属性进行操作，可以调用里面的动态方法和静态属性 ? ? ? class Weapon: def __init__(self,name,ad): self.name=name self.ad=ad ? def weapon_attack(self,p1,p2): p2.hp -= p1.ad+self.ad print(f‘{p1.name}利用{self.name}攻击了{p2.name},{p2.name}掉了{self.ad+p1.ad}血，还剩{p2.hp}血‘) ? barry = Gamerole(‘太白‘,10,200) panky = Gamerole(‘金莲‘,20,50) pillow=Weapon(‘绣花枕头‘,2) barry.equip_weapon(pillow) # 把武器装备给对象 barry.wea.weapon_attack(barry,panky) ? class Gamerole: def __init__(self,name,ad,hp): self.name=name self.ad=ad self.hp=hp ? def attack(self,role1): role1.hp -= self.ad print(f‘{self.name}攻击了{role1.name},{role1.name}掉了{self.ad}血，还剩{role1.hp}血‘) ? def equip_weapon(self,weap): self.weapon=weap # 组合：相当于把great_seord这个对象封装到gailun这个对象中， # 作为gailun的一个属性 ? ? class Weapon: def __init__(self,name,ad): self.name=name self.ad=ad ? def weapon_attack(self,p1,p2): p2.hp -= self.ad+p1.ad print(f‘{p1.name}使用{self.name}攻击了{p2.name},{p2.name}掉了{self.ad+p1.ad}血，还剩{p2.hp}血‘) ? ? gailun=Gamerole(‘盖伦‘,10,100) zhaoxin=Gamerole(‘赵信‘,20,90) great_sword=Weapon(‘大保健‘,30) # gailun.attack(zhaoxin) gailun.equip_weapon(great_sword) gailun.weapon.weapon_attack(gailun,zhaoxin) # gailun.weapon==grrat_sword
原文：https://www.cnblogs.com/guzhaowen/p/11215950.html
