Self-study Python Fish-C Note20 P64to65

weixin_465304562024-09-06 21:27

类和对象 (part 3)

本节主要介绍 类和对象的多态和鸭子类型、私有变量和 __slots__（原视频P64-65)\

多态

多态是面向对象编程的三大特征之一，另外两个是封装和继承。多态是指同一个运算符、函数或对象，在不同场景下具有不同作用效果的情况。

Python 是一门动态语言，多态本来就是 Python的一种特性。

比如：

加号：两边都是数字的时候就是执行算术运算（相加），如果两边都是字符串就是得到字符串的拼接。

python 复制代码 
8+9
17
python 复制代码 
'aaa'+'bbb'
'aaabbb'

乘号：也类似，如果是字符串则会得到重复拷贝的效果，如果是数字则算术运算

python 复制代码 
'abc'*3
'abcabcabc'
python 复制代码 
3*5
15

这些是运算符的多态，除了运算符的多态，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__x
200

这其实就是 名字改编，其实就是 下横线加类名加变量的名字。所以在 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课程随手做的笔记。一些概念和例子我个人为更好的理解做了些查询和补充

因本人水平有限，如有任何问题，欢迎大家批评指正！

原视频链接：https://www.bilibili.com/video/BV1c4411e77t?p=8

相关推荐
Hello.Reader4 分钟前
全面解析 Golang Gin 框架
开发语言·golang·gin
禁默15 分钟前
深入浅出：AWT的基本组件及其应用
java·开发语言·界面编程
Cachel wood21 分钟前
python round四舍五入和decimal库精确四舍五入
java·linux·前端·数据库·vue.js·python·前端框架
Code哈哈笑24 分钟前
【Java 学习】深度剖析Java多态：从向上转型到向下转型，解锁动态绑定的奥秘，让代码更优雅灵活
java·开发语言·学习
終不似少年遊*27 分钟前
pyecharts
python·信息可视化·数据分析·学习笔记·pyecharts·使用技巧
程序猿进阶27 分钟前
深入解析 Spring WebFlux：原理与应用
java·开发语言·后端·spring·面试·架构·springboot
Python之栈28 分钟前
【无标题】
数据库·python·mysql
qq_4336184430 分钟前
shell 编程(二)
开发语言·bash·shell
charlie11451419144 分钟前
C++ STL CookBook
开发语言·c++·stl·c++20
袁袁袁袁满44 分钟前
100天精通Python（爬虫篇）——第113天：‌爬虫基础模块之urllib详细教程大全
开发语言·爬虫·python·网络爬虫·爬虫实战·urllib·urllib模块教程
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10红米手机使用google play