面向对象

本章主要是为大家讲解Python的面向对象部分，希望大家通过对本章的学习，对面向对象有深入的了解。

1. 面向过程式编程vs面向函数式编程

之前我们讲过面向过程式编程与面向函数式编程的区别，现在我们在回忆一下。

# 面向过程编程 测量对象的元素个个数。
s1 = 'fjdsklafsjda'
count = 0
for i in s1:
    count += 1
l1 = [1,2,3,4]
count = 0
for i in l1:
    count += 1 
#函数式编程实现
def func(s):
    count = 0
    for i in s:
        count += 1
    return count
func('fdsafdsa')
func([1,2,3,4])

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

1. 减少代码的重用性。
2. 增强代码的可读性。

2. 函数式编程vs面向对象编程

# 函数式编程
# auth 认证相关
def login():
    pass
def regisgter():
    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):
        pass
    def regisgter(self):
        pass
class Account:
    def func1(self):
        pass
    def func2(self):
        pass
class ShoppingCar:
    def shopping(username,money):
        pass
    def check_paidgoods(username,money):
        pass
    def check_unpaidgoods(username,money):
        pass
    def save(username,money):
        pass

3. 什么是面向对象编程

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

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

说第二个优点之前,先看看什么是面向对象。面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。那什么是类？什么是对象？

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

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

猫，是一类，你们家养的 大橘。

狗，是一类，隔壁家养的那只二哈就是对象。

⾯向对象思维, 要⾃⼰建立对象. ⾃⼰建立场景. 你是就是⾯向对象世界中的上帝. 你想让⻋⼲嘛就⼲嘛. 你想让⼈⼲嘛⼈就能⼲嘛，再说第二个优点：

1. 面向对象编程：要拥有上帝的视角看问题，类其实就是一个公共模板（厂房），对象就从具体的模板实例化出来。核心思想是运用对象编程，得到了对象就是得到了一切。

第一节：初识面向对象

1. 类的结构

class Human:
    """
    此类主要是构建人类
    """
    mind = '有思想'  # 第一部分：静态属性 属性 静态变量 静态字段
    dic = {}
    l1 = []
    def work(self): # 第二部分：方法 函数 动态属性
        print('人类会工作')
#class 是关键字与def用法相同，定义一个类。
#Human是此类的类名，类名使用驼峰(CamelCase)命名风格，首字母大写，私有类可用一个下划线开头。
#类的结构从大方向来说就分为两部分：
    #静态属性。
    #动态方法。

2. 从类名的角度研究类

类名操作静态属性

• 第一种: 查看类中的所有内容, 类名__dict__方式。

class Human:
    """
    此类主要是构建人类
    """
    mind = '有思想'  # 第一部分：静态属性 属性 静态变量 静态字段
    dic = {}
    l1 = []
    def work(self): # 第二部分：方法 函数 动态属性
        # print(self)
        print('人类会工作')
print(Human.__dict__)
print(Human.__dict__['mind'])
Human.__dict__['mind'] = '无脑'
print(Human.__dict__)  # 错误
#通过这种方式只能查询，不能增删改.
# 第一种方式只用户查询全部内容（一般不用单独属性查询）.

• 第二种：万能的点.

class Human:
    """
    此类主要是构建人类
    """
    mind = '有思想'  # 第一部分：静态属性 属性 静态变量 静态字段
    dic = {}
    l1 = []
    def work(self): # 第二部分：方法 函数 动态属性
        # print(self)
        print('人类会工作')
print(Human.mind)  # 查
Human.mind = '无脑'  # 改
print(Human.mind)
del Human.mind  # 删
Human.walk = '直立行走'
print(Human.walk)
# 通过万能的点 可以增删改查类中的单个属性

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

类名操作动态方法

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

class Human:
    """
    此类主要是构建人类
    """
    mind = '有思想'  # 第一部分：静态属性 属性 静态变量 静态字段
    dic = {}
    l1 = []
    def work(self): # 第二部分：方法 函数 动态属性
        # print(self)
        print('人类会工作')
    def tools(self):
        print('人类会使用工具')
Human.work(111)
Human.tools(111)
#下面可以做，但不用。
Human.__dict__['work'](111)

3. 从对象的角度研究类

什么是对象

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

• 实例化对象发生了三件事

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

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

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

• 对象操作对象空间属性

对象查询对象中所有属性。 对象__dict__

class Human:
    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        # self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间封装四个属性。
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby
obj = Human('barry','男',18,'运动')
print(obj.__dict__)  # {'n': 'barry', 'h': '运动', 's': '男', 'a': 18}

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

class Human:
    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        # self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间封装四个属性。
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby
obj = Human('barry','男',18,'运动')
obj.job = 'IT'  # 增
del obj.n  # 删
obj.s = '女' # 改
print(obj.s)  # 查
print(obj.__dict__)

• 对象查看类中的属性

class Human:
    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby
obj = Human('barry','男',18,'运动')
print(obj.mind)
print(obj.language)
obj.a = 666
print(obj.a)

• 对象操作类中的方法

class Human:
    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby
    def work(self):
        print(self)
        print('人类会工作')
    def tools(self):
        print('人类会使用工具')
obj = Human('barry','男',18,'运动')
obj.work()
obj.tools()

4. 什么是self

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

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

class Human:
    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby
    def work(self):
        print(self)
        print('人类会工作')
    def tools(self):
        print('人类会使用工具')
obj1= Human('小胖','男',20,'美女')
obj2= Human('相爷','男',18,'肥女')
print(obj1,obj2)
print(obj1.__dict__)
print(obj2.__dict__)

第二节：类的空间问题以及类之间的关系

1. 类的空间问题

• 何处添加对象属性
  ``` 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 方法也可以。

**总结：对象的属性不仅可以在__init__里面添加，还可以在类的其他方法或者类的外面添加。**
-  何处可以添加类的静态属性 <br />**总结：类的属性不仅可以在类内部添加，还可以在类的外部添加。**

class A: def init(self,name): self.name = name

def func(self,sex):
    self.sex = sex
def func1(self):
    A.bbb = 'ccc'

类的外部可以添加

A.aaa = ‘taibai’ print(A.dict)

类的内部也可以添加。

A.func1(111) print(A.dict)

-  对象如何找到类的属性<br />之前咱们都学习过，实例化一个对象，可以通过点的方式找到类中的属性，那么他为什么可以找到类中的属性呢？<br />通过图解说明：<br />![](https://s2.ax1x.com/2019/12/08/QdYmeU.png#crop=0&crop=0&crop=1&crop=1&id=Vu1bS&originHeight=910&originWidth=1143&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
-  对象以及类查询"名字"的顺序<br />对象查找属性的顺序：先从对象空间找 ------> 类空间找 ------> 父类空间找 ------->…<br />类名查找属性的顺序：先从本类空间找 -------> 父类空间找--------> …<br />上面的顺序都是单向不可逆，类名不可能找到对象的属性。 
<a name="7ce78ff8"></a>
### 2.类与类之间的关系
⼤千世界, 万物之间皆有规则和规律. 我们的类和对象是对⼤千世界中的所有事物进⾏归类. 那事物之间存在着相对应的关系. 类与类之间也同样如此. 在⾯向对象的世界中. 类与类中存在以下关系:
1. 依赖关系
1. 关联关系
1. 组合关系
1. 聚合关系
1. 实现关系
1. 继承关系(类的三大特性之一：继承。)
上面是Java语言中对类进行划分，而python中对面向对象没有这么明确的定义，我们是借助Java语言对Python中的类进行科学的划分。
1. 依赖(关联)关系
1. 组合(聚合)关系
1. 继承(实现)关系
<a name="bb16ced4"></a>
#### 依赖(关联)关系
⾸先, 我们设计⼀个场景. 还是最初的那个例⼦. 要把⼤象装冰箱. 注意. 在这个场景中, 其实是存在了两种事物的. ⼀个是⼤象, ⼤象负责整个事件的掌控者, 还有⼀个是冰箱, 冰箱负责被⼤象操纵.
⾸先, 写出两个类, ⼀个是⼤象类, ⼀个是冰箱类

class Elphant: def init(self, name): self.name = name

def open(self):
    '''
    开⻔
    '''
    pass
def close(self):
    '''
    关⻔
    '''
    pass

class Refrigerator:

def open_door(self):
    print("冰箱⻔被打开了")
def close_door(self):
    print("冰箱⻔被关上了")

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

class Elphant: def init(self, name): self.name = name

def open(self,obj1):
    '''
    开⻔
    '''
    print('大象要开门了，默念三声，开')
    obj1.open_door()
def close(self):
    '''
    关⻔
    '''
    print('大象要关门了，默念三声，关')

class Refrigerator:

def open_door(self):
    print("冰箱⻔被打开了")
def close_door(self):
    print("冰箱⻔被关上了")

elphant1 = Elphant(‘大象’) haier = Refrigerator() elphant1.open(haier)

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

class Boy: def init(self,name,girlFriend=None): self.name = name self.girlFriend = girlFriend

def 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

b = Boy(‘日天’) b.have_a_diner() # 此时是单身狗

突然有一天，日天牛逼了

b.girlFriend = ‘如花’ b.have_a_diner() #共进晚餐

wusir 生下来就有女朋友 服不服

gg = Girl(‘小花’) bb = Boy(‘wusir’, gg) bb.have_a_diner()

结果嫌他有点娘，不硬，分了

bb.girlFriend = None bb.have_a_diner()

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

老师属于学校，必须有学校才可以工作

class School:

def __init__(self,name,address):
    self.name = name
    self.address = address

class Teacher:

def __init__(self,name,school):
    self.name = name
    self.school = school

s1 = School(‘北京校区’,’朝阳区’) s2 = School(‘上海校区’,’上海迪士尼旁边’) s3 = School(‘深圳校区’,’南山区’)

t1 = Teacher(‘郭德纲’,s1) t2 = Teacher(‘啵啵’,s2) t3 = Teacher(‘太白’,s3)

print(t1.school.name) print(t2.school.name) print(t3.school.name)

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

class School:

def __init__(self,name,address):
    self.name = name
    self.address = address
    self.teacher_list = []
def append_teacher(self,teacher):
    self.teacher_list.append(teacher)

class Teacher:

def __init__(self,name,school):
    self.name = name
    self.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)

for teacher in s1.teacher_list:

print(teacher.name)

好了. 这就是关联关系. 当我们在逻辑上出现了. 我需要你. 你还得属于我. 这种逻辑 就是关联关系. 那注意. 这种关系的紧密程度比上⾯的依赖关系要紧密的多. 为什么呢? 想想吧
例三：游戏人物示例。
**组合：将一个类的对象封装到另一个类的对象的属性中，就叫组合。**
咱们设计一个游戏人物类，让实例化几个对象让这几个游戏人物实现互殴的效果。

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(‘%s攻击%s,%s掉了%s血,还剩%s血’%(self.name,p1.name,p1.name,self.ad,p1.hp)) gailun = Gamerole(‘盖伦’,10,200) yasuo= Gamerole(‘亚索’,50,80)

盖伦攻击亚索

gailun.attack(yasuo)

亚索攻击盖伦

yasuo.attack(盖伦)

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

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(‘%s攻击%s,%s掉了%s血,还剩%s血’%(self.name,p1.name,p1.name,self.ad,p1.hp))

class Weapon: def init(self,name,ad): self.name = name self.ad = ad def weapon_attack(self,p1,p2): p2.hp = p2.hp - self.ad - p1.ad print(‘%s 利用 %s 攻击了%s,%s还剩%s血’ %(p1.name,self.name,p2.name,p2.name,p2.hp))

接下来借助武器攻击对方：

pillow = Weapon(‘绣花枕头’,2) pillow.weapon_attack(barry,panky)

但是上面这么做不好，利用武器攻击也是人类是动作的发起者，所以不能是pillow武器对象，而是人类利用武器攻击对方

所以，对代码进行修改。

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(‘%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 = name self.ad = ad def weapon_attack(self,p1,p2): p2.hp = p2.hp - self.ad - p1.ad print(‘%s 利用 %s 攻击了%s,%s还剩%s血’ %(p1.name,self.name,p2.name,p2.name,p2.hp))

实例化三个人物对象：

barry = Gamerole(‘太白’,10,200) panky = Gamerole(‘金莲’,20,50) pillow = Weapon(‘绣花枕头’,2)

给人物装备武器对象。

barry.equip_weapon(pillow)

开始攻击

barry.wea.weapon_attack(barry,panky) ```

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

在python中类的实现关系和类的继承是一个意思，这个下一节我们再讲。