一. 面向对象初识

面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。

优点是：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。

缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

面向对象的程序设计

优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现，一刀砍死3个人，这个游戏就失去平衡。

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。

了解一些名词：类、对象、实例、实例化

类：具有相同特征的一类事物(人、狗、老虎)

对象／实例：具体的某一个事物（隔壁阿花、楼下二哈）

实例化：类——>对象的过程

1.1 面向过程编程vs函数式编程

# 面向过程编程，测量对象的元素个数
s1 = 'fjdsklafsjda'
count = 0
for i in s1:count += 1
print(count) # 12
l1 = [1,2,3,4]
count = 0
for i in l1:count+=1
print(count) # 4# 函数式编程
def func(s):count = 0for i in s:count+=1return count
print(func('asldkfhjklajsdh')) # 15
print(func([1,2,3,4,5,6])) # 6

通过对比可知：函数编程较之面向过程编程最明显的两个特点：

1，减少代码的重用性。

2，增强代码的可读性。

1.2 函数式编程vs面向对象编程

# 函数式编程# auth 认证相关
def login():pass
def register():pass
# account 账户相关
def func1():pass
def func2():pass
# 购物车相关
def shopping(username,money):pass
def check_paidgoods(username,money):pass
def check_unpaidgoods(username,money):pass
def save(username,money):pass# 面向对象编程
class LoginHandler:def login(self):passdef register(self):pass
class Acount:def fun1(self):passdef func2(self):pass
class ShoppingCar:def shopping(username, money):passdef check_paidgoods(username, money):passdef check_unpaidgoods(username, money):passdef save(username, money):pass

通过对比可以看出面向对象第一个优点：

面向对象编程：是一类相似功能函数的集合,使你的代码更清晰化，更合理化。

说第二个优点之前，先看看什么是面向对象。

面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。

那什么是类？什么是对象？

类：就是具有相同属性和功能的一类事物。
对象：就是类的具体表现。

具体一些：先解释解释什么是⻋? 有轱辘, 有⽅向盘, 有发动机, 会跑的是⻋。在解释⼀个，什么是⼈：有名字, 年龄, 爱好, 会唱歌跳舞思考的是⼈。那么广义上：车，人就是类，但是具体的我的车，你这个人就是一个对象。

猫，是一类，你们家养的大橘。狗，是一类，隔壁家养的那只二哈就是对象。

⾯向对象思维, 要⾃⼰建立对象. ⾃⼰建立场景. 你是就是⾯向对象世界中的上帝. 你想让⻋⼲嘛就⼲嘛. 你想让⼈⼲嘛⼈就能⼲嘛。

再说第二个优点：面向对象，要拥有上帝的视角看问题，类其实就是一个公共模板（厂房），对象就从具体的模板实例化出来（慢慢体会）。

1.3类的结构

class Human:'''此类主要是构建人类'''mind = '有思想' # 第一部分：静态属性 属性 静态变量 静态字段dic = {}l1 = []def work(self): # 第二部分：方法 函数 动态属性print("人类会开跑车")

class 是关键字与def用法相同，定义一个类。
Human是此类的类名，类名使用驼峰(CamelCase)命名风格，首字母大写，私有类可用一个下划线开头。
类的结构从大方向来说就分为两部分：

静态变量。
动态方法。

二. 从类名的角度研究类

2.1 类名操作静态属性

2.11 第一种，查看类中的所有内容：类名.__dict__方式。

class Human:'''此类主要是构建人类'''mind = '有思想' # 第一部分：静态属性 属性 静态变量 静态字段dic = {}l1 = []def work(self): # 第二部分：方法 函数 动态属性print(self) print("人类会开跑车")
print(Human.__dict__) # {'__module__': '__main__', '__doc__': '\n    此类主要是构建人类\n    ', 'mind': '有思想', 'dic': {}, 'l1': [], 'work': <function Human.work at 0x00000143C424F2F0>, '__dict__': <attribute '__dict__' of 'Human' objects>, '__weakref__': <attribute '__weakref__' of 'Human' objects>}
print(Human.__dict__['mind']) # 有思想
Human.__dict__['mind'] = '无脑'
print(Human.__dict__) # 报错,通过这种方式只能查询，不能增删改.

第一种方式只适用于用户查询全部内容（一般不用单独属性查询）

2.12 第二种：万能的点.

class Human:mind = '有思想'dic = {}l1 = []def work(self):print("人类会开跑车")
print(Human.mind) #  有思想 # 查
Human.mind = '无脑' # 改
print(Human.mind) # 无脑
del Human.mind  # 删
Human.walk = '直立行走' # 增
print(Human.walk) # 直立行走

通过万能的点可以增删改查类中的单个属性

对以上两种做一个总结：如果想查询类中的所有内容，通过第一种__dict__方法，如果只是操作单个属性则用万能的点的方式。

2.2 类名操作动态方法

前提：除了两个特殊方法：静态方法，类方法之外，一般不会通过类名操作一个类中的方法。

class Human:mind = '有思想'dic = {}l1 = []def work(self):print("人类会开跑车")def tools(self):print('人类会使用工具')
Human.work(222) # 人类会开跑车
Human.tools(222) # 人类会使用工具
# 下面可以做，但不用。
Human.__dict__['work'](111) # 人类会开跑车

三. 从对象的角度研究类

3.1 什么是对象

对象是从类中出来的，只要是类名加上（），这就是一个实例化过程，这个就会实例化一个对象。

class Human:mind = '有思想'def __init__(self):print(666) # 666print(self) # <__main__.Human object at 0x000001D8D41D8390>def work(self):print("人类会开跑车")def tools(self):print('人类会使用工具')
obj = Human() # 只要实例化对象，它会自动执行__init__方法,并且obj的地址与self的地址相同
print(obj) # <__main__.Human object at 0x000001D8D41D8390>

其实实例化一个对象总共发生了三件事：

在内存中开辟了一个对象空间。
自动执行类中的__init__方法，并将这个对象空间（内存地址）传给了__init__方法的第一个位置参数self。
在_init_ 方法中通过self给对象空间添加属性。

示例：

class Human:mind = '有思想'language = '使用语言'def __init__(self,name,sex,age,hobby):self.name = nameself.sex = sexself.age = ageself.hobby = hobby
obj = Human('杨把总','男',20,'python爬虫')
print(obj.hobby) # python爬虫

3.2 对象操作对象空间属性

3.21 对象查询对象中所有属性。对象._dict_

class Human:mind = '有思想'language = '使用语言'def __init__(self,name,sex,age,hobby):# self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间封装四个属性。self.name = nameself.sex = sexself.age = ageself.hobby = hobby
obj = Human('杨把总','男',20,'python爬虫')
print(obj.__dict__) # {'name': '杨把总', 'sex': '男', 'age': 20, 'hobby': 'python爬虫'}

3.22 对象操作对象中的单个属性。万能的点 .

class Human:mind = '有思想'language = '使用语言'def __init__(self,name,sex,age,hobby):self.name = nameself.sex = sexself.age = ageself.hobby = hobby
obj = Human('杨把总','男',20,'python爬虫')
obj.job = '云计算运维工程师'  # 增
print(obj.__dict__) # {'name': '杨把总', 'sex': '男', 'age': 20, 'hobby': 'python爬虫', 'job': '云计算运维工程师'}
del obj.job # 删
print(obj.__dict__) # {'name': '杨把总', 'sex': '男', 'age': 20, 'hobby': 'python爬虫'}
obj.age = 18 # 改
print(obj.__dict__) # {'name': '杨把总', 'sex': '男', 'age': 18, 'hobby': 'python爬虫'}
print(obj.name) # 杨把总 # 查

3.3 对象查看类中的属性

class Human:mind = '有思想'language = '使用语言'def __init__(self,name,sex,age,hobby):self.name = nameself.sex = sexself.age = ageself.hobby = hobby
obj = Human('杨把总','男',20,'python爬虫')
print(obj.mind) # 有思想
print(obj.language) # 使用语言
print(obj.sex) # 男

3.4 对象操作类中的方法

class Human:mind = '有思想'language = '使用语言'def __init__(self,name,sex,age,hobby):self.name = nameself.sex = sexself.age = ageself.hobby = hobbyprint(self) # <__main__.Human object at 0x0000023D466B8710>def work(self):print(self) # <__main__.Human object at 0x0000023D466B8710>print('人类会工作')def tools(self):print('人类会使用工具')
obj = Human('杨把总','男',20,'python爬虫')
obj.work()  # 人类会工作
print(obj)  # <__main__.Human object at 0x0000023D466B8710>,3者内存地址相同
obj.tools() # 人类会使用工具

类中的方法一般都是通过对象执行的（除去类方法，静态方法外），并且对象执行这些方法都会自动将对象空间传给方法中的第一个参数self.

self 是什么？

self其实就是类中方法（函数）的第一个位置参数，只不过解释器会自动将调用这个函数的对象传给self。所以咱们把类中的方法的第一个参数约定俗成设置成self, 代表这个就是对象。

一个类可以实例化多个对象

class Human:mind = '有思想'language = '使用语言'def __init__(self,name,sex,age,hobby):self.name = nameself.sex = sexself.age = ageself.hobby = hobby
obj1 = Human('杨把总','男',20,'python爬虫')
obj2 = Human('山药','女',18,'空姐')
print(obj1.__dict__) # {'name': '杨把总', 'sex': '男', 'age': 20, 'hobby': 'python爬虫'}
print(obj2.__dict__) # {'name': '山药', 'sex': '女', 'age': 18, 'hobby': '空姐'}

3.5 用函数来解释一下这个类，对象

def Person(*args,**kwargs):self = {}def attack(self,dog):dog['life_value'] -= self['aggressivity']def __init__(name,aggressivity,life_value):self['name'] = nameself['aggressivity'] = aggressivityself['life_value'] = life_valueself['attack'] = attack__init__(*args,**kwargs)return selfegg = Person('egon',78,10)
print(egg['name'])

3.6 面向对象小结——定义及调用的固定模式

class 类名:def __init__(self,参数1,参数2):self.对象的属性1 = 参数1self.对象的属性2 = 参数2def 方法名(self):passdef 方法名2(self):pass对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西#类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法#括号里传参数，参数不需要传self，其他与init中的形参一一对应#结果返回一个对象
对象名.对象的属性1  #查看对象的属性，直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

3.7 一个简单的例子:

from math import pi
class Circle:'''定义一个圆形类提供计算面积和周长perimeter的方法'''def __init__(self,radius):self.radius = radiusdef area(self):return pi*self.radius**2def perimeter(self):return 2*pi*self.radius
circle = Circle(10) #实例化一个圆
area = circle.area() #计算圆面积
perimeter = circle.perimeter() #计算圆周长
print(area) # 314.1592653589793 打印圆面积和周长
print(perimeter) # 62.83185307179586

四.类的空间问题

1.1 何处可以添加对象属性

class A:def __init__(self,name):self.name = namedef func(self,sex):self.sex = sex

# 类外面可以,__init__方法可以。
obj = A('杨把总')
obj.age = 18
print(obj.__dict__) # {'name': '杨把总', 'age': 18}
# 类内部也可以,func 方法也可以。
obj.func('男')
print(obj.__dict__) # {'name': '杨把总', 'age': 18, 'sex': '男'}

总结：对象的属性不仅可以在__init__里面添加，还可以在类的其他方法或者类的外面添加。

1.2 何处可以添加类的静态属性

class A:def __init__(self,name):self.name = namedef func1(self,sex):self.sex = sexdef func2(self):A.bbb = 'ccc'
A.aaa = '山药'  # 类的外部可以添加
print(A.__dict__)
# {'__module__': '__main__', '__init__': <function A.__init__ at 0x0000023323FDF2F0>, 'func1': <function A.func1 at 0x0000023323FDF378>, 'func2': <function A.func2 at 0x0000023323FDF400>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None, 'aaa': '山药'}
A.func2(2)      # 类的内部也可以添加。
print(A.__dict__)
# {'__module__': '__main__', '__init__': <function A.__init__ at 0x00000251F5E4F2F0>, 'func1': <function A.func1 at 0x00000251F5E4F378>, 'func2': <function A.func2 at 0x00000251F5E4F400>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None, 'aaa': '山药', 'bbb': 'ccc'}

总结：类的属性不仅可以在类内部添加，还可以在类的外部添加。

1.3 对象如何找到类的属性

实例化一个对象，可以通过点的方式找到类中的属性，那么他为什么可以找到类中的属性呢？

图解说明：

对象查找属性的顺序：先从对象空间找 ------> 类空间找 ------> 父类空间找 ------->…
类名查找属性的顺序：先从本类空间找 -------> 父类空间找--------> …
上面的顺序都是单向不可逆，类名不可能找到对象的属性。

五.类与类之间的关系

⼤千世界, 万物之间皆有规则和规律. 我们的类和对象是对⼤千世界中的所有事物进⾏归类. 那事物之间存在着相对应的关系. 类与类之间也同样如此. 在⾯向对象的世界中. 类与类中存在以下关系:

依赖关系
关联关系
组合关系
聚合关系
实现关系
继承关系(类的三大特性之一：继承。)

5.1 依赖关系

⾸先, 我们设计⼀个场景. 要把⼤象装冰箱. 注意. 在这个场景中, 其实是存在了两种事物的. ⼀个是⼤象, ⼤象负责整个事件的掌控者, 还有⼀个是冰箱, 冰箱负责被⼤象操纵.

⾸先, 写出两个类, ⼀个是⼤象类, ⼀个是冰箱类

class Elphant:def __init__(self,name):self.name = namedef open(self):'''开门'''passdef close(self):'''关门'''pass
class Refrigerator:def open_door(self):print('冰箱门被打开了')def close_door(self):print('冰箱门被关上了')

冰箱的功能非常简单, 只要会开⻔, 关⻔就⾏了. 但是⼤象就没那么简单了. 想想. ⼤象开⻔和关⻔的时候是不是要先找个冰箱啊. 然后呢? 打开冰箱⻔. 是不是打开刚才找到的那个冰箱⻔. 然后装⾃⼰. 最后呢? 关冰箱⻔, 注意, 关的是刚才那个冰箱吧. 也就是说. 开⻔和关⻔⽤的是同⼀个冰箱. 并且. ⼤象有更换冰箱的权利, 想进那个冰箱就进那个冰箱. 这时, ⼤象类和冰箱类的关系并没有那么的紧密. 因为⼤象可以指定任何⼀个冰箱. 接下来. 我们把代码完善⼀下.

class Elphant:def __init__(self,name):self.name = namedef open(self,obj1):'''开门'''print('大象要开门了，1,2,3--->开')obj1.open_door()def close(self,obj1):'''关门'''print('大象要关门了，1,2,3--->关')obj1.close_door()class Refrigerator:def open_door(self):print('冰箱门被打开了')def close_door(self):print('冰箱门被关上了')elphant1 = Elphant('大象')
haier = Refrigerator()
elphant1.open(haier)
elphant1.close(haier)
'''
大象要开门了，1,2,3--->开
冰箱门被打开了
大象要关门了，1,2,3--->关
冰箱门被关上了
'''

动作发起的主体是大象。依赖关系：将一个类的对象或者类名传到另一个类的方法使用。此时, 我们说, ⼤象和冰箱之间就是依赖关系. 我⽤着你. 但是你不属于我. 这种关系是最弱的.比如. 公司和雇员之间. 对于正式员⼯, 肯定要签订劳动合同. 还得⼩⼼伺候着. 但是如果是兼职. 那⽆所谓. 需要了你就来. 不需要你就可以拜拜了. 这⾥的兼职(临时⼯) 就属于依赖关系.我⽤你. 但是你不属于我

5.2 关联,聚合,组合关系

其实这三个在代码上写法是⼀样的. 但是, 从含义上是不⼀样的.

关联关系. 两种事物必须是互相关联的. 但是在某些特殊情况下是可以更改和更换的.
聚合关系. 属于关联关系中的⼀种特例. 侧重点是xxx和xxx聚合成xxx. 各⾃有各⾃的声明周期. 比如电脑. 电脑⾥有CPU, 硬盘, 内存等等. 电脑挂了. CPU还是好的. 还是完整的个体
组合关系. 属于关联关系中的⼀种特例. 写法上差不多. 组合关系比聚合还要紧密. 比如⼈的⼤脑, ⼼脏, 各个器官. 这些器官组合成⼀个⼈. 这时. ⼈如果挂了. 其他的东⻄也跟着挂了

关联关系：

这个最简单. 也是最常⽤的⼀种关系. 比如. ⼤家都有男女朋友. 男⼈关联着女朋友. 女⼈关联着男朋友. 这种关系可以是互相的, 也可以是单⽅⾯的.

class Boy:def __init__(self,name,girlFriend=None):self.name = nameself.girlFriend = girlFrienddef have_a_diner(self):if self.girlFriend:print('%s 和 %s 一起吃晚饭' %(self.name,self.girlFriend))else:print('单身狗,吃啥子饭')
class Girl:def __init__(self,name):self.name = nameb = Boy('日天')
b.have_a_diner() # 单身狗,吃啥子饭
# 突然有一天，日天牛逼了
b.girlFriend = '翠花'
b.have_a_diner() # 日天 和 翠花 一起吃晚饭

class Boy:def __init__(self,name,girlFriend=None):self.name = nameself.girlFriend = girlFrienddef have_a_diner(self):if self.girlFriend:print('%s 和 %s 一起吃晚饭' %(self.name,self.girlFriend.name))else:print('单身狗,吃啥子饭')
class Girl:def __init__(self,name):self.name = name
# taibai 生下来就有女朋友 服不服
gg = Girl('东方不败')
bb = Boy('taibai',gg)
bb.have_a_diner() # taibai 和 东方不败 一起吃晚饭
# 结果嫌他有点娘，不硬，分了
bb.girlFriend = None
bb.have_a_diner() # 单身狗,吃啥子饭

注意. 此时Boy和Girl两个类之间就是关联关系. 两个类的对象紧密练习着. 其中⼀个没有了. 另⼀个就孤单的不得了. 关联关系, 其实就是我需要你. 你也属于我. 这就是关联关系. 像这样的关系有很多很多. 比如. 学校和老师之间的关系.

# 老师属于学校，必须有学校才可以工作
class School:def __init__(self,name,address):self.name = nameself.address = address
class Teacher:def __init__(self,name,school):self.name = nameself.school = school
s1 = School('北京校区','美丽的沙河')
s2 = School('山海校区','上海迪士尼旁边')
s3 = School('深圳校区','南山区')
t1 = Teacher('翠花',s1)
t2 = Teacher('海峰',s2)
t3 = Teacher('日天',s3)
print('教师'+t1.name+' 所在的校区：'+t1.school.name+'\t地址：'+t1.school.address)
print('教师'+t2.name+' 所在的校区：'+t2.school.name+'\t地址：'+t2.school.address)
print('教师'+t3.name+' 所在的校区：'+t3.school.name+'\t地址：'+t3.school.address)
'''
教师翠花 所在的校区：北京校区    地址：美丽的沙河
教师海峰 所在的校区：山海校区    地址：上海迪士尼旁边
教师日天 所在的校区：深圳校区    地址：南山区
'''

但是学校也是依赖于老师的，所以老师学校应该互相依赖。

class School:def __init__(self,name,address):self.name = nameself.address = addressself.teacher_list = []def append_teacher(self,teacher):self.teacher_list.append(teacher)class Teacher:def __init__(self,name,school):self.name = nameself.school = school
s1 = School('北京校区','美丽的沙河')
s2 = School('山海校区','上海迪士尼旁边')
s3 = School('深圳校区','南山区')
t1 = Teacher('翠花',s1)
t2 = Teacher('海峰',s2)
t3 = Teacher('日天',s3)
s1.append_teacher(t1)
s1.append_teacher(t2)
s1.append_teacher(t3)
print(s1.teacher_list) # [<__main__.Teacher object at 0x000001854B54F5C0>, <__main__.Teacher object at 0x000001854B53C198>, <__main__.Teacher object at 0x000001854B53C1D0>]
for teacher in s1.teacher_list:print(teacher.name)
'''
翠花
海峰
日天
'''

这就是关联关系. 当我们在逻辑上出现了. 我需要你. 你还得属于我. 这种逻辑就是关联关系. 那注意. 这种关系的紧密程度比上⾯的依赖关系要紧密的多.

至于组合关系和聚合关系，其实代码上差别不大，咱们就以组合举例：

组合：将一个类的对象封装到另一个类的对象的属性中，就叫组合。

咱们设计一个游戏人物类，让实例化几个对象让这几个游戏人物实现互殴的效果。

class Gamerole:def __init__(self,name,ad,hp):self.name = nameself.ad = adself.hp = hpdef attack(self,p1):p1.hp -= self.adprint('%s攻击%s,%s掉了%s点血,还剩下%s点血' %(self.name,p1.name,p1.name,self.ad,p1.hp))
gailun = Gamerole('盖伦',50,500)
yasuo = Gamerole('亚索',100,350)
# 亚索攻击盖伦
yasuo.attack(gailun) # 亚索攻击盖伦,盖伦掉了100点血,还剩下400点血
# 盖伦攻击亚索
gailun.attack(yasuo) # 盖伦攻击亚索,亚索掉了50点血,还剩下300点血

但是这样互相攻击没有意思，一般游戏类的的对战方式要借助武器，武器是一个类，武器类包含的对象很多：刀枪棍剑斧钺钩叉等等，所以咱们要写一个武器类。

class Gamerole:def __init__(self,name,ad,hp):self.name = nameself.ad = adself.hp = hpdef attack(self,p1):p1.hp -= self.adprint('%s攻击%s,%s掉了%s点血,还剩下%s点血' %(self.name,p1.name,p1.name,self.ad,p1.hp))
class Weapon:def __init__(self,name,ad):self.name = nameself.ad = addef weapon_attack(self,p1,p2):p2.hp = p2.hp-self.ad-p1.adprint('%s利用%s攻击了%s,%s还剩下%s点血' %(p1.name,self.name,p2.name,p2.name,p2.hp))
pillow = Weapon('斧头',20)
barry = Gamerole('barry',50,500)
panky = Gamerole('panky',40,400)
# 接下来借助武器攻击对方：
pillow.weapon_attack(barry,panky) # barry利用斧头攻击了panky,panky还剩下330点血
# 但是上面这么做不好，利用武器攻击也是人类是动作的发起者，所以不能是pillow武器对象，而是人类利用武器攻击对方

所以，对代码进行修改。

class Gamerole:def __init__(self,name,ad,hp):self.name = nameself.ad = adself.hp = hpdef attack(self,p1):p1.hp -= self.adprint('%s攻击%s,%s掉了%s点血,还剩下%s点血' %(self.name,p1.name,p1.name,self.ad,p1.hp))def equip_weapon(self,wea):self.wea = wea
class Weapon:def __init__(self,name,ad):self.name = nameself.ad = addef weapon_attack(self,p1,p2):p2.hp = p2.hp-self.ad-p1.adprint('%s利用%s攻击了%s,%s还剩下%s点血' %(p1.name,self.name,p2.name,p2.name,p2.hp))
# 实例化三个人物对象：
pillow = Weapon('斧头',20)
barry = Gamerole('barry',50,500)
panky = Gamerole('panky',40,400)
# 给人物装备武器对象。
barry.equip_weapon(pillow)
# 开始攻击
barry.wea.weapon_attack(barry,panky)

上面就是组合，只要是人物.equip_weapon这个方法，那么人物就封装了一个武器对象，再利用武器对象调用其类中的weapon_attack方法。

练习：

圆环是由两个圆组成的，圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。
这个时候，我们就首先实现一个圆形类，计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用

from math import pi
class Circle:'''定义一个圆形类提供计算面积和周长perimeter的方法'''def __init__(self,radius):self.radius = radiusdef area(self):return pi*self.radius**2def perimeter(self):return 2*pi*self.radius
circle = Circle(10)
area = circle.area()
perimeter = circle.perimeter()class Ring:'''定义一个圆环类提供圆环的计算面积和周长perimeter的方法'''def __init__(self,radius_outside,radius_inside):self.outside_circle = Circle(radius_outside)self.inside_circle = Circle(radius_inside)def area(self):return self.outside_circle.area()-self.inside_circle.area()def perimeter(self):return self.outside_circle.perimeter()+self.inside_circle.perimeter()
ring = Ring(10,5)  #实例化一个环形
print(ring.area()) # 235.61944901923448 计算环形的面积
print(ring.perimeter()) # 94.24777960769379 计算环形的周长

当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好

Python3 面向对象基础1相关推荐

python菜鸟基础教程-Python3 面向对象
Python3 面向对象 Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象是很容易的.本章节我们将详细介绍Python的面向对象编程. 如果你以前没有接触 ...
Python基础入门_5面向对象基础
Python 基础入门前四篇: Python 基础入门–简介和环境配置 Python基础入门_2基础语法和变量类型 Python基础入门_3条件语句和迭代循环 Python基础入门_4函数第五篇主要 ...
python和对象复习_python 面向对象基础和高级复习
面向对象基础面向对象编程面向过程编程:类似于工厂的流水线优点:逻辑清晰缺点:扩展性差面向对象编程:核心是对象二字,对象属性和方法的集合体,面向对象编程就是一堆对象交互优点:扩展性强缺点: ...
python3面向对象_Python3面向对象编程
Python3面向对象编程编辑锁定讨论上传视频 <Python3面向对象编程>是2015年6月电子工业出版社出版的图书,作者是肖鹏,常贺,石琳. 书名 Python3面向对 ...
Python3 面向对象编程
好记性不如烂笔头,对之前阅读书籍进行梳理与总结,此文为<Python3面向对象编程>阅读笔记. 文章目录第一章面向对象设计第二章 Python对象第三章对象相似时第四章异常捕 ...
第三模块面向对象网络并发编程 | day17 面向对象基础
第三模块面向对象&网络&并发编程从今天开始,我们将进入系列课程第3个模块的的学习,此模块包含如下三大部分知识: 面向对象,Python中支持两种编程方式来写代码,分别是:函数式编程 ...
大话python3入门基础语法
大话python3入门基础语法语法目录大话python3入门基础语法总纲 1.基础类型 2.列表类型变量 3.字典类型 4.函数类型 5.类类型 6.总结总纲 python是一门涉及面很广的语 ...
17. 面向对象基础
第三模块面向对象&网络编程&并发编程从今天开始,我们将进入系列课程第3个模块的的学习,此模块包含如下三大部分知识: 面向对象,Python中支持两种编程方式来写代码,分别是:函数式 ...
day6-常用模块与面向对象基础
第1章常用模块 1.1 random模块 1.1.1 random模块介绍 import random ####取随机数模块print(random.random())#(0,1)----float ...

Python3 面向对象基础1