Python（13）——Python面向对象编程的三大特性

---

前言（类和对象介绍）

• 类（Class）是现实或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。

• 对象(Object)是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概
  念

• 类（Class）是是创建实例的模板；对象(Object)是一个一个具体的实例

• 实例化是指在面向对象的编程中，把用类创建对象的过程称为实例化。是将一个抽象的概念类，具体到该类实物的过程。实例化过程中一般由类名 对象名 = 类名（参数1，参数2…参数n）
  构成

class Cat():
    ## 属性 名词
    name = 'CCC'
    kind = '布偶'

    ## 方法  动词
    def eat(self):
        print('cat like eat fish')

## 对象：类的实例化
neni = Cat()
print(Cat)  ## 类 <class '__main__.Cat'>
print(neni)  ## 类的对象<__main__.Cat object at 0x000001749CBB22E0>

1、封装特性

1.1 封装介绍

封装是将内容封装到某个地方，以后再去调用被封装在某处的内容。在使用面向对象的封装特性时，需要：

• 将内容封装到某处

• 从某处调用被封装的内容

  • 通过对象直接调用被封装的内容： 对象.属性名
  • 通过self间接调用被封装的内容： self.属性名
  • 通过self间接调用被封装的内容: self.方法名()

1.2 构造方法

构造方法__init__与其他普通方法不同的地方在于，当一个对象被创建后，会立即调用构造方法。自动执行构造方法里面的内容

1.3 面向对象的封装

对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。

class Cat():
    def __init__(self,name,kind):
        ##  1. 构造方法，实例化对象时自动执行的方法
        ##  2. self是什么? self实质上是实例化的对象
        ##  3. 类方法中, python解释器会自动把对象作为参数传给self
        
        print("正在执行__init__构造方法")
        print('self',self) ## self <__main__.Cat object at 0x00000193F3C3AA60>
        # 封装: self.name将对象和name属性封装/绑定
        self.name=name
        self.kind=kind

    ## 方法  动词
    def eat(self):
        print(self) ## <__main__.Cat object at 0x00000193F3C3AA60>

        print('cat %s like eat fish' %(self.name))


## 对象：类的实例化
neni = Cat('neni','布偶')

print(neni.name)  ## 类 <class '__main__.Cat'>
print(neni.kind)  ## 类的对象<__main__.Cat object at 0x000001749CBB22E0>
neni.eat()  ## 调用封装的内容

## 输出
正在执行__init__构造方法
self <__main__.Cat object at 0x00000193F3C3AA60>
neni
布偶
<__main__.Cat object at 0x00000193F3C3AA60>
cat neni like eat fish

1.4 练习

创建一个类People,拥有的属性为姓名， 性别和年龄， 拥有的方法为购物，学习；实例化对象执行相应的方法，输出如下的内容

小明,18岁，女去购物
小华,23岁，女去购物
小红,13岁,女学习

class People():
    def __init__(self,name,age,gender):
        self.name=name
        self.age=age
        self.gender=gender
    def Shopping(self):
        print(f'{self.name},{self.age}岁，{self.gender}去购物')
    def Learning(self):
        print(f'{self.name},{self.age}岁,{self.gender}学习')

p1=People("小明",18,'女')
p2=People("小华",23,'女')
p3=People("小红",13,'女')
p1.Shopping()
p2.Shopping()
p3.Learning()
输出：
小明,18岁，女去购物
小华,23岁，女去购物
小红,13岁,女学习

2、继承特性

2.1 继承

• 继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、Superclass)。

• 子类在继承的时候，在定义类时，小括号()中为父类的名字

（1）继承的工作机制

• 父类的属性、方法,会被继承给子类。 举例如下: 如果子类没有定义__init__方法,父类有,那么在子类继承父类的时候这个方法就被继承了,所以只要创建对象,就默认执行了那个继承过来的__init__方法。

class Cat(): ## 父类
    def __init__(self):
        print("正在运行Cat的__init__方法")
class BlueCat(Cat):  ## 子类，BlueCat是Cat的字类
    pass
tom=BlueCat()

输出：
正在运行Cat的__init__方法

（2）重写父类方法: 就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法。

class Cat():
    def eat(self):
        print('Cat like eat fish')
class BlueCat(Cat):
    def eat(self): ## 当子类和父类方法同名时，父类的方法会被子类覆盖
        print('BlueCat  dislike  eat Vegetables')
tom=BlueCat()
tom.eat()

输出：
BlueCat  dislike  eat Vegetables

（3）调用父类的方法:

需求： 先执行父类的eat()方法， 再个性化执行自己的方法

• 父类名.父类的方法名()

• super(): py2.2+的功能

class Cat():
    def eat(self):
        print('Cat like eat fish')
    def sleep(self):
        print('Cat like sleep')
class BlueCat(Cat):
    def eat(self):
#        Cat.eat(self) 解决方法1: 直接执行父类的方法，但不建议
        super(BlueCat,self).eat()  ## 通过super找到父类，再执行方法
        print('BlueCat  dislike  eat Vegetables')
tom=BlueCat()
tom.eat()

输出：
Cat like eat fish
BlueCat  dislike  eat Vegetables

2.2 多继承: 新式类与经典类

• 在Python 2及以前的版本中，由任意内置类型派生出的类，都属于“新式
  类”，都会获得所有“新式类”的特性；反之，即不由任意内置类型派生出的类，则称之为“经典类

  • 新式类: 广度优先算法
  • 经典类： 深度优先算法(py2中的部分类属于经典类)

在Python 3之后的版本，因为所有的类都派生自内置类型object(即使没有显示的继承object类型)，即所有的类都是“新式类”。新式类的继承算法是广度优先算法

经典类和新式类最明显的区别在于继承搜索的顺序不同，即：

• 经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找，然后再返回，开始查找右侧。
• 新式类多继承搜索顺序(广度优先算法):先在水平方向查找，然后再向上查找

2.3 私有属性与私有方法

（1）python中的私有属性和私有方法介绍

• 实例的变量名如果以 _ _ 开头,就变成了一个私有变量/属性(private)
• 实例的函数名如果以 _ _开头,就变成了一个私有函数/方法(private)
• 只有内部可以访问,外部不能访问

确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护, 代码更加健壮。默认情况下,属性在 Python 中都是“public“

（2）私有属性的使用

class Student:
    """父类Student"""
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        # 私有属性，以双下划线开头。
        # 工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。
        self.__score = score

s1=Student('tom',12,80)
print(s1.score) ## AttributeError: 'Student' object has no attribute 'score'

class Student:
    """父类Student"""
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        # 私有属性，以双下划线开头。
        # 工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。
        self.__score = score

    def get_score(self): ## 私有属性只能在类内部访问
        return  self.__score
s1=Student('tom',12,80)
score=s1.get_score()
print(score)

（3）私有方法的使用

    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        # 私有属性，以双下划线开头。
        # 工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。
        self.__score = score

    def get_score(self):
        self.__modify_score() ## 私有方法只能在类内部调用
        return  self.__score

    def __modify_score(self):
        self.__score += 20
        
s1=Student('tom',12,80)
#score=s1.get_score() 报错AttributeError: 'Student' object has no attribute '__modify_score'
score=s1.get_score()
print(score)

输出：
100

3、多态特性

• 多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口
  的多种不同的实现方式即为多态。
• 通俗来说： 同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

多态的使用

class Student:
    """父类Student"""
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        # 私有属性，以双下划线开头。
        # 工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。
        self.score = score

    def info(self):
        print(f'{self.name}年龄{self.age}分数{self.score}')

s1=Student('tom',12,80)
s1.info()
s1=Student('jarry',19,90)
s1.info()
s1=Student('lily',16,70)
s1.info()

输出：
tom年龄12分数80
jarry年龄19分数90
lily年龄16分数70