类和对象 (part 3)
本节主要介绍 类和对象的多态和鸭子类型、私有变量和 __slots__（原视频P64-65)\
多态
多态是面向对象编程的三大特征之一，另外两个是封装和继承。多态是指同一个运算符、函数或对象，在不同场景下具有不同作用效果的情况。
Python 是一门动态语言，多态本来就是 Python的一种特性。
比如：
加号：两边都是数字的时候就是执行算术运算（相加），如果两边都是字符串就是得到字符串的拼接。
python
8+917
python
'aaa'+'bbb''aaabbb'
乘号：也类似，如果是字符串则会得到重复拷贝的效果，如果是数字则算术运算
python
'abc'*3'abcabcabc'
python
3*515
这些是运算符的多态，除了运算符的多态，Python有一些函数也是支持多态的：
比如:
函数 len() 获取对象长度，如果传入字符串则得到字符串这个对象字符的个数；如果传入列表则得到列表中元素的个数；如果传入字典则得到字典中 键(key) 的个数。
python
len('abcdefg')7
python
len(['aa',1,2])3
python
len({'a':1,'b':3})2
以上，展现了多态的好处，尽管我们的接口是不变的，但是它却可以根据不同的对象执行不同的操作。
类继承的多态
Python 允许我们在子类中定义和父类同名的方法进行覆盖（重写），事实上重写就是实现类继承的多态。
python
class Shape():
def __init__(self,name):
self.name=name
def area(self):
pass #这里是父类我们直接pass
class Square(Shape):
def __init__(self,length):
super().__init__('正方形')
self.length=length
def area(self):
return self.length * self.length
class Circle(Shape):
def __init__(self,radius):
super().__init__('圆形')
self.radius = radius
def area(self):
return 3.14 * self.radius * self.radius
class Triangle(Shape):
def __init__(self,base,height):
super().__init__('三角形')
self.base = base
self.height = height
def area(self):
return (self.base * self.height)/2
s1 = Square(5)
c1 = Circle(6)
t1 = Triangle(3,4)
print(s1.name)
print(c1.name)
print(t1.name)
print(s1.area())
print(c1.area())
print(t1.area())正方形
圆形
三角形
25
113.03999999999999
6.0
上面的例子中正方形、圆形、三角形都是继承自 Shape 类，但是他们又重写了构造函数和 area() 方法。这就是多态的体现。
自定义函数实现多态接口
python
class Cat:
def __init__(self,name,age):
self.name=name
self.age=age
def intro(self):
print(f'this is a cat, my name is {self.name}. I am {self.age} years old')
def say(self):
print('miao')
class Dog:
def __init__(self,name,age):
self.name=name
self.age=age
def intro(self):
print(f'this is a dog, my name is {self.name}. I am {self.age} years old')
def say(self):
print('wang')
class Pig:
def __init__(self,name,age):
self.name=name
self.age=age
def intro(self):
print(f'this is a pig, my name is {self.name}. I am {self.age} years old')
def say(self):
print('hong')
c1 = Cat('mao',5)
d1 = Dog('gou',3)
p1 = Pig('zhu',1)此时我们定义一个叫 animal() 的函数，它会接收一个参数 x(是我们之前定义的动物的对象)。这时候，多态的功效就发挥出来了，当我们给函数传递不同的实例对象的时候，输出不同的结果。
即，该函数接收不同对象作为参数，并且不检查其类型的情况下执行它的方法。
python
def animal(x):
x.intro()
x.say()
animal(c1)
animal(d1)
animal(p1)this is a cat, my name is mao. I am 5 years old
miao
this is a dog, my name is gou. I am 3 years old
wang
this is a pig, my name is zhu. I am 1 years old
hong
鸭子类型
在编程中，我们不会关心对象是什么类型，我们关心的是它的行为是否符合要求。
比如之前 animal() 函数，它不关注里面参数 x 是什么，只要 x 里面有 intro()和 say() 两个方法，他就不会报错。
python
class Bicycle:
def intro(self):
print('this is a bicycle')
def say(self):
print("dddddddd")
# 这里 Bicycle 有`intro()`和 `say()` 两个方法就可以被 animal 调用，尽管其不是动物。
b1 = Bicycle()
animal(b1)this is a bicycle
dddddddd
"私有变量"和 __slots__
"私有变量"
私有变量：是指通过某种手段，使得对象中的属性或方法无法被外部所访问的机制，(一种保护机制)。
但是 Python 的哲学是给程序员极大的自由，所以其实在 Python中，那种仅限从一个对象内部才能够访问的 私有变量 并不存在。这里我们给其加上双引号 "私有变量" 来区分。
但是， Python 中有一个 name mangling 的机制，翻译过来就是 名字改编，名称改写，或名称修饰。
语法就是在 名字的前面 加上两个连续的下横线。
python
class C:
def __init__(self,x):
self.__x = x # 设置"私有变量" __x
def set_x(self,x):
self.__x=x
def get_x(self):
print(self.__x)
c1 = C(100)此时我们是无法直接通过变量名来访问到这个变量的。
c1.__x
after run:
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_8456\543364159.py in <module>
----> 1 c1.__x
AttributeError: 'C' object has no attribute '__x'
想要访问变量的值，就需要通过指定的接口，比如这里的 set_x() 和 get_x() 这两个方法。
python
c1.get_x()100
python
c1.set_x(200)
c1.get_x()200
但是，事实上如果我们查看 dic 属性：
python
c1.__dict__{'_C__x': 200}
python
# 虽然 dict 里面没有 __x，但是有 _C__x
# 我们尝试访问一下
c1._C__x200
这其实就是 名字改编，其实就是 下横线加类名加变量的名字。所以在 Python 中所谓的"私有变量"就是把我们想要私有的变量，按照这个规律改了名字。其实方法名也一样：
python
class D:
def __func(self): # 在方法前面加两个连续的下横线，把方法隐藏起来
print('hi')
d1 = D()
# now d1.__func() can not run
# but :
d1._D__func()hi
但是，我们强烈不建议有这种方法去访问。毕竟有意使用双下横线开头就是不希望这个属性或方法被外界所访问到。所以我们应该遵循这个约定俗成的规则。
名字改编是发生在类实例化对象的时候的事情
在对象诞生之后，是不能够通过动态添加属性的方式来添加一个 "私有变量"的
python
c1.__y=111
c1.__dict__{'_C__x': 200, '__y': 111}
其他约定俗成的规则
单个下横线开头的变量(_x): 仅供内部使用的变量。属于约定俗成的命名规则，所以当看到这种名字不要随意访问和修改。
单个下横线结尾的变量(x_): 比如 class 是 python 用于定义类的，你非要用这个名，可以加一个 单下横线 结尾。
python
# 对比
class C:
def __init__(self,x,y,z):
self._x = x
self.__y = y
self.z_ = z
def say_x(self):
print(self._x)
def say_y(self):
print(self.__y)
def say_z(self):
print(self.z_)
c1 = C(1,2,3)
# 对比发现只有，双下横线开头的会被修改
print(c1._x)
print(c1._C__y) #c1.__y 不行
print(c1.z_)
print('_'*30)
print(c1.__dict__)
# 但是其他的也 非常强烈不建议 访问
print('_'*30)
# 我们也可以看到，内部是可以访问的，且都没有改名
c1.say_x()
c1.say_y()
c1.say_z()1
2
3
______________________________
{'_x': 1, '_C__y': 2, 'z_': 3}
______________________________
1
2
3
效率提升之道 以及 __slots__
即舍/得之道：Python 为了对象的灵活性，有时候会牺牲大量的存储空间。比如，动态添加属性很灵活，但其背后实现的原理是字典（即 __dict__ 属性，对象的属性通常都是放在这个 __dict__ 里的）。比如：
python
class C:
def __init__(self,x):
self.x=x
c1 = C(100)
c1.__dict__{'x': 100}
我们甚至可以直接通过给字典添加键值对的方式，来创建对象的属性。
python
c1.__dict__['y']=666
print(c1.y)
c1.__dict__666
{'x': 100, 'y': 666}
但是我们之前讲字典的时候说了，字典的执行效率很高是以牺牲存储空间换来的，以空间换时间（详见之前的课程里，字典和集合高效背后的玄机）。使用字典是比较费内存的。
但是，如果我们明确知道一个类的对象设计出来，就只是需要那么固定的几个属性，并且将来也不会有动态添加属性这种功能的需求。那么利用字典来存放属性这种空间上的牺牲就是纯纯的浪费。
针对这种情况，Python专门设置了一个 __slots__的类属性，避免了利用字典来存放造成空间上的浪费。
__slots__
示例：
python
class C:
__slots__ = ['x','y'] # 注意 slots 别忘了s；赋值一个列表，这个列表就是我们希望这个对象可以使用的属性的名称。
# 这里我么 希望类C实例化的对象 只有 x和y两个属性
def __init__(self,x): # 写构造函数
self.x = x # 给其中一个属性赋值
c1=C(100) # 这样我们就创建了一个属性受限制的对象 c1访问 __slots__ 中列举的属性没有问题：
python
print(c1.x)
c1.y=666
print(c1.y)100
666
但是如果，我们现在想要动态添加一个属性：
c1.z = 666
报错：
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_1228\4272346953.py in <module>
----> 1 c1.z = 666
AttributeError: 'C' object has no attribute 'z'
这种限制不仅体现在动态添加属性上，如果我们在类内部想要创建一个 __slots__ 不包含的属性，也是不被允许的：
class D:
__slots__ = ['x','y']
def __init__(self,x,y,z):
self.x = x
self.y = y
self.z = z
d1 = D(1,2,3)
报错：
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_1228\2058141618.py in <module>
6 self.z = z
7
----> 8 d1 = D(1,2,3)
~\AppData\Local\Temp\ipykernel_1228\2058141618.py in __init__(self, x, y, z)
4 self.x = x
5 self.y = y
----> 6 self.z = z
7
8 d1 = D(1,2,3)
AttributeError: 'D' object has no attribute 'z'
事实上，因为使用了 __slots__ 属性，对象就会划分一个固定大小的空间来存放指定的属性。这时候 __dict__ 属性也就不需要了，空间也就因此被节约了出来。但是这牺牲了灵活性，也有人用 __slots__ 属性防止类属性的滥用。
继承自父类的 __slots__ 属性 是不会在子类中生效的
Python 只会关注各个具体的类中，定义的 __slots__ 属性。
python
class C:
__slots__ = ['x','y']
def __init__(self,x):
self.x=x
class E(C):
pass
e1=E(100)
print(e1.x)
e1.y=200
print(e1.y)
e1.z = 300
print(e1.z) # 可以看到这里不受限制100
200
300
我们看一下 e1.__slots__ 是有的，因为 类E 是继承自 类C 的。虽然 e1 有 __slots__ 属性，但是这是类C的，这是继承下来的。同时 e1 也会有一个 __dict__ 属性。
python
e1.__slots__['x', 'y']
python
e1.__dict__{'z': 300}
但是 类C 实例化的对象是没有 __dict__ 属性的
c1 = C(1)
c1.__dict__
报错：
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_1228\4180053359.py in <module>
1 c1 = C(1)
----> 2 c1.__dict__
AttributeError: 'C' object has no attribute '__dict__'
所以说，继承自父类的 __slots__ 属性 是不会在子类中生效的，Python 只会关注各个具体的类中，定义的 __slots__ 属性。
附言：
题目：Self-study Python Fish-C Note-20 P64-P65
本文为自学B站上鱼C的python课程随手做的笔记。一些概念和例子我个人为更好的理解做了些查询和补充
因本人水平有限，如有任何问题，欢迎大家批评指正！