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

相关推荐
StayInLove1 分钟前
G1垃圾回收器日志详解
java·开发语言
无尽的大道9 分钟前
Java字符串深度解析：String的实现、常量池与性能优化
java·开发语言·性能优化
爱吃生蚝的于勒12 分钟前
深入学习指针（5）！！！！！！！！！！！！！！！
c语言·开发语言·数据结构·学习·计算机网络·算法
binishuaio22 分钟前
Java 第11天 (git版本控制器基础用法)
java·开发语言·git
zz.YE23 分钟前
【Java SE】StringBuffer
java·开发语言
就是有点傻28 分钟前
WPF中的依赖属性
开发语言·wpf
洋24036 分钟前
C语言常用标准库函数
c语言·开发语言
进击的六角龙38 分钟前
Python中处理Excel的基本概念（如工作簿、工作表等）
开发语言·python·excel
wrx繁星点点39 分钟前
状态模式（State Pattern）详解
java·开发语言·ui·设计模式·状态模式
NoneCoder1 小时前
Java企业级开发系列（1）
java·开发语言·spring·团队开发·开发
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play