Self-study Python Fish-C Note20 P64to65

2024-09-02 11:20

本文主要是介绍Self-study Python Fish-C Note20 P64to65,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

类和对象 (part 3)

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

多态

多态是面向对象编程的三大特征之一,另外两个是封装和继承。多态是指同一个运算符、函数或对象,在不同场景下具有不同作用效果的情况。
Python 是一门动态语言,多态本来就是 Python的一种特性。
比如:
加号:两边都是数字的时候就是执行算术运算(相加),如果两边都是字符串就是得到字符串的拼接。

8+9
17
'aaa'+'bbb'
'aaabbb'

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

'abc'*3
'abcabcabc'
3*5
15

这些是运算符的多态,除了运算符的多态,Python有一些函数也是支持多态的:
比如:
函数 len() 获取对象长度,如果传入字符串则得到字符串这个对象字符的个数;如果传入列表则得到列表中元素的个数;如果传入字典则得到字典中 键(key) 的个数。

len('abcdefg')
7
len(['aa',1,2])
3
len({'a':1,'b':3})
2

以上,展现了多态的好处,尽管我们的接口是不变的,但是它却可以根据不同的对象执行不同的操作。

类继承的多态

Python 允许我们在子类中定义和父类同名的方法进行覆盖(重写),事实上重写就是实现类继承的多态。

class Shape():def __init__(self,name):self.name=namedef area(self):pass #这里是父类我们直接passclass Square(Shape):def __init__(self,length):super().__init__('正方形')self.length=lengthdef area(self):return self.length * self.lengthclass Circle(Shape):def __init__(self,radius):super().__init__('圆形')self.radius = radiusdef area(self):return 3.14 * self.radius * self.radiusclass Triangle(Shape):def __init__(self,base,height):super().__init__('三角形')self.base = baseself.height = heightdef area(self):return (self.base * self.height)/2s1 = 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() 方法。这就是多态的体现。

自定义函数实现多态接口

class Cat:def __init__(self,name,age):self.name=nameself.age=agedef 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=nameself.age=agedef 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=nameself.age=agedef 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(是我们之前定义的动物的对象)。这时候,多态的功效就发挥出来了,当我们给函数传递不同的实例对象的时候,输出不同的结果。
即,该函数接收不同对象作为参数,并且不检查其类型的情况下执行它的方法。

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() 两个方法,他就不会报错。

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 的机制,翻译过来就是 名字改编,名称改写,或名称修饰。
语法就是在 名字的前面 加上两个连续的下横线。

class C:def __init__(self,x):self.__x = x # 设置"私有变量" __xdef set_x(self,x):self.__x=xdef 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.__xAttributeError: 'C' object has no attribute '__x'

想要访问变量的值,就需要通过指定的接口,比如这里的 set_x()get_x() 这两个方法。

c1.get_x()
100
c1.set_x(200)
c1.get_x()
200

但是,事实上如果我们查看 dic 属性:

c1.__dict__
{'_C__x': 200}
# 虽然 dict 里面没有 __x,但是有 _C__x
# 我们尝试访问一下
c1._C__x
200

这其实就是 名字改编,其实就是 下横线加类名加变量的名字。所以在 Python 中所谓的"私有变量"就是把我们想要私有的变量,按照这个规律改了名字。其实方法名也一样:

class D:def __func(self): # 在方法前面加两个连续的下横线,把方法隐藏起来print('hi')d1 = D()
# now d1.__func() can not run
# but :
d1._D__func()
hi

但是,我们强烈不建议有这种方法去访问。毕竟有意使用双下横线开头就是不希望这个属性或方法被外界所访问到。所以我们应该遵循这个约定俗成的规则。

名字改编是发生在类实例化对象的时候的事情

在对象诞生之后,是不能够通过动态添加属性的方式来添加一个 "私有变量"的

c1.__y=111
c1.__dict__
{'_C__x': 200, '__y': 111}
其他约定俗成的规则

单个下横线开头的变量(_x): 仅供内部使用的变量。属于约定俗成的命名规则,所以当看到这种名字不要随意访问和修改。
单个下横线结尾的变量(x_): 比如 class 是 python 用于定义类的,你非要用这个名,可以加一个 单下横线 结尾。

# 对比
class C:def __init__(self,x,y,z):self._x = xself.__y = yself.z_ = zdef 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__ 里的)。比如:

class C:def __init__(self,x):self.x=xc1 = C(100)
c1.__dict__
{'x': 100}

我们甚至可以直接通过给字典添加键值对的方式,来创建对象的属性。

c1.__dict__['y']=666
print(c1.y)
c1.__dict__
666{'x': 100, 'y': 666}

但是我们之前讲字典的时候说了,字典的执行效率很高是以牺牲存储空间换来的,以空间换时间(详见之前的课程里,字典和集合高效背后的玄机)。使用字典是比较费内存的。
但是,如果我们明确知道一个类的对象设计出来,就只是需要那么固定的几个属性,并且将来也不会有动态添加属性这种功能的需求。那么利用字典来存放属性这种空间上的牺牲就是纯纯的浪费。
针对这种情况,Python专门设置了一个 __slots__的类属性,避免了利用字典来存放造成空间上的浪费。

__slots__

示例:

class C:__slots__ = ['x','y']  # 注意 slots 别忘了s;赋值一个列表,这个列表就是我们希望这个对象可以使用的属性的名称。# 这里我么 希望类C实例化的对象 只有 x和y两个属性def __init__(self,x): # 写构造函数self.x = x # 给其中一个属性赋值c1=C(100) # 这样我们就创建了一个属性受限制的对象 c1

访问 __slots__ 中列举的属性没有问题:

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 = 666AttributeError: 'C' object has no attribute 'z'

这种限制不仅体现在动态添加属性上,如果我们在类内部想要创建一个 __slots__ 不包含的属性,也是不被允许的:

class D:__slots__ = ['x','y']def __init__(self,x,y,z):self.x = x self.y = yself.z = zd1 = D(1,2,3)

报错:

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_1228\2058141618.py in <module>6         self.z = z7 
----> 8 d1 = D(1,2,3)~\AppData\Local\Temp\ipykernel_1228\2058141618.py in __init__(self, x, y, z)4         self.x = x5         self.y = y
----> 6         self.z = z7 8 d1 = D(1,2,3)AttributeError: 'D' object has no attribute 'z'

事实上,因为使用了 __slots__ 属性,对象就会划分一个固定大小的空间来存放指定的属性。这时候 __dict__ 属性也就不需要了,空间也就因此被节约了出来。但是这牺牲了灵活性,也有人用 __slots__ 属性防止类属性的滥用。

继承自父类的 __slots__ 属性 是不会在子类中生效的

Python 只会关注各个具体的类中,定义的 __slots__ 属性。

class C:__slots__ = ['x','y']def __init__(self,x):self.x=xclass E(C):passe1=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__ 属性。

e1.__slots__
['x', 'y']
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

这篇关于Self-study Python Fish-C Note20 P64to65的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1129807

相关文章

如何使用 Python 读取 Excel 数据

《如何使用Python读取Excel数据》:本文主要介绍使用Python读取Excel数据的详细教程,通过pandas和openpyxl,你可以轻松读取Excel文件,并进行各种数据处理操... 目录使用 python 读取 Excel 数据的详细教程1. 安装必要的依赖2. 读取 Excel 文件3. 读

Python的time模块一些常用功能(各种与时间相关的函数)

《Python的time模块一些常用功能(各种与时间相关的函数)》Python的time模块提供了各种与时间相关的函数,包括获取当前时间、处理时间间隔、执行时间测量等,:本文主要介绍Python的... 目录1. 获取当前时间2. 时间格式化3. 延时执行4. 时间戳运算5. 计算代码执行时间6. 转换为指

利用Python调试串口的示例代码

《利用Python调试串口的示例代码》在嵌入式开发、物联网设备调试过程中,串口通信是最基础的调试手段本文将带你用Python+ttkbootstrap打造一款高颜值、多功能的串口调试助手,需要的可以了... 目录概述:为什么需要专业的串口调试工具项目架构设计1.1 技术栈选型1.2 关键类说明1.3 线程模

Python ZIP文件操作技巧详解

《PythonZIP文件操作技巧详解》在数据处理和系统开发中,ZIP文件操作是开发者必须掌握的核心技能,Python标准库提供的zipfile模块以简洁的API和跨平台特性,成为处理ZIP文件的首选... 目录一、ZIP文件操作基础三板斧1.1 创建压缩包1.2 解压操作1.3 文件遍历与信息获取二、进阶技

Python Transformers库(NLP处理库)案例代码讲解

《PythonTransformers库(NLP处理库)案例代码讲解》本文介绍transformers库的全面讲解,包含基础知识、高级用法、案例代码及学习路径,内容经过组织,适合不同阶段的学习者,对... 目录一、基础知识1. Transformers 库简介2. 安装与环境配置3. 快速上手示例二、核心模

Python正则表达式语法及re模块中的常用函数详解

《Python正则表达式语法及re模块中的常用函数详解》这篇文章主要给大家介绍了关于Python正则表达式语法及re模块中常用函数的相关资料,正则表达式是一种强大的字符串处理工具,可以用于匹配、切分、... 目录概念、作用和步骤语法re模块中的常用函数总结 概念、作用和步骤概念: 本身也是一个字符串,其中

Python使用getopt处理命令行参数示例解析(最佳实践)

《Python使用getopt处理命令行参数示例解析(最佳实践)》getopt模块是Python标准库中一个简单但强大的命令行参数处理工具,它特别适合那些需要快速实现基本命令行参数解析的场景,或者需要... 目录为什么需要处理命令行参数?getopt模块基础实际应用示例与其他参数处理方式的比较常见问http

python实现svg图片转换为png和gif

《python实现svg图片转换为png和gif》这篇文章主要为大家详细介绍了python如何实现将svg图片格式转换为png和gif,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录python实现svg图片转换为png和gifpython实现图片格式之间的相互转换延展:基于Py

Python中的getopt模块用法小结

《Python中的getopt模块用法小结》getopt.getopt()函数是Python中用于解析命令行参数的标准库函数,该函数可以从命令行中提取选项和参数,并对它们进行处理,本文详细介绍了Pyt... 目录getopt模块介绍getopt.getopt函数的介绍getopt模块的常用用法getopt模

Python利用ElementTree实现快速解析XML文件

《Python利用ElementTree实现快速解析XML文件》ElementTree是Python标准库的一部分,而且是Python标准库中用于解析和操作XML数据的模块,下面小编就来和大家详细讲讲... 目录一、XML文件解析到底有多重要二、ElementTree快速入门1. 加载XML的两种方式2.