《流畅的python 第一章 python数据模型》

2024-05-30 05:32
文章标签 python 数据模型 第一章 流畅

本文主要是介绍《流畅的python 第一章 python数据模型》，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

第一章 python数据模型

摘要：本章主要讲一些特殊方法（前后带双下划线写法的方法，如__len__，__getitem__），为什么有特殊方法，特殊方法的应用。

python是一种面向对象语言，那么为什么会有len(x)这种写法，而不是x.len()呢

Python 解释器遇到len()这种特殊句法时，会使用特殊方法去激活一些基本的对象操作，这些特殊方法的名字以两个下划线开头，以两个下划线结尾。如__len__，__getitem__。比如obj[key]背后就是__getitem__方法，为了能求得obj[key]的值，解释器实际上调用的是obj.__getitem__(key)。

通过合理使用这些方法，能让自己的对象实现和支持以下语言结构，并与之交互：

  • 迭代
  • 集合类
  • 属性访问
  • 运算符重载
  • 函数和方法的调用
  • 对象的创建和销毁
  • 字符串表示形式和格式化
  • 管理上下文（with模块）

魔术方法（magic method）是特殊方法的昵称，又叫双下方法（dunder method）。

一摞python风格的纸牌

用一个非常简单的例子来展示如何实现__getitem__、__len__这两个特殊方法。

import collections
Card=collections.namedtuple('Card',['rank','suit'])
#使用collections.namedtuple创建了一个元组类型的子类，子类类名为Card，子类中有两个key，key值分别为'rank'、'suit'
class FrenchDeck:ranks=[str(n) for n in range(2,11)]+list('JQKA')#ranks=['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']suits='spades diamonds clubs hearts'.split()#suits=['spades', 'diamonds', 'clubs', 'hearts']def __init__(self):self._cards=[Card(rank,suit) for rank in self.ranks for suit in self.suits]def __len__(self):return len(self._cards)def __getitem__(self, item):return self._cards[item]

利用namedtuple，我们可以很轻松地得到一个纸牌对象：

bear_card=Card(rank='7',suit='spades')
print(bear_card)

/Users/zy/PycharmProjects/learnpython/venv/bin/python /Users/zy/PycharmProjects/learnpython/collect.py
Card(rank='7', suit='spades')Process finished with exit code 0

然后，我们来关注FrenchDeck这个类，将它实例化后，我们可以用len()函数来查看这叠纸牌共有多少张。

deck=FrenchDeck()
print(len(deck))

/Users/zy/PycharmProjects/learnpython/venv/bin/python /Users/zy/PycharmProjects/learnpython/collect.py
52Process finished with exit code 0

也可以使用index下标来访问特定的纸牌：

print(deck[5])

/Users/zy/PycharmProjects/learnpython/venv/bin/python /Users/zy/PycharmProjects/learnpython/collect.py
Card(rank='3', suit='diamonds')Process finished with exit code 0

如果在FrenchDeck类中注释掉__len__方法，就无法使用len(deck)，同理，如果在FrenchDeck类中注释掉__getitem__方法，就无法使用deck[key]访问特定元素。

而且我们不需要再写一个方法用来随机抽取一张纸牌，只需要调用python内置的random.choice。

from random import choice
deck=FrenchDeck()
print(choice(deck))

/Users/zy/PycharmProjects/learnpython/venv/bin/python /Users/zy/PycharmProjects/learnpython/collect.py
Card(rank='A', suit='spades')Process finished with exit code 0

从上述试验中，我们发现了通过实现特殊方法来利用python数据模型的两个好处：

  • 用户实例化该类后，不必费心去记标准操作的格式名称，比如说获取元素总数，是size方法还是length方法
  • 可以更加方便的利用python标准库，而不需要重新自己写代码

并且由于__getitem__方法把下标访问[]的操作交给了self._cards列表，deck自动支持了切片操作。

print(deck[:3])
print(deck[12::13])

/Users/zy/PycharmProjects/learnpython/venv/bin/python /Users/zy/PycharmProjects/learnpython/collect.py
[Card(rank='2', suit='spades'), Card(rank='2', suit='diamonds'), Card(rank='2', suit='clubs')]
[Card(rank='5', suit='spades'), Card(rank='8', suit='diamonds'), Card(rank='J', suit='clubs'), Card(rank='A', suit='hearts')]Process finished with exit code 0

另外，仅仅实现了__getitem__方法，deck就变成可迭代的了：

for card in deck:if card.rank=='J':print(card)else:pass

上述代码找到所有’J’的纸牌

/Users/zy/PycharmProjects/learnpython/venv/bin/python /Users/zy/PycharmProjects/learnpython/collect.py
Card(rank='J', suit='spades')
Card(rank='J', suit='diamonds')
Card(rank='J', suit='clubs')
Card(rank='J', suit='hearts')Process finished with exit code 0

反向迭代也可以：

for card in reversed(deck):if card.rank=='J':print(card)else:pass

/Users/zy/PycharmProjects/learnpython/venv/bin/python /Users/zy/PycharmProjects/learnpython/collect.py
Card(rank='J', suit='hearts')
Card(rank='J', suit='clubs')
Card(rank='J', suit='diamonds')
Card(rank='J', suit='spades')Process finished with exit code 0

迭代通常是隐式的，比如说一个集合类型没有实现__contains__方法，那么in运算符就会按顺序做一次迭代搜索，因为它是可迭代的：

print(Card(rank='J', suit='hearts') in deck)
print(Card(rank='O', suit='hearts') in deck)

/Users/zy/PycharmProjects/learnpython/venv/bin/python /Users/zy/PycharmProjects/learnpython/collect.py
True
FalseProcess finished with exit code 0

给纸牌排序：2最小，A最大，黑桃最大，红桃次之，方块再次，梅花最小。

suit_values=dict(spades=3,hearts=2,diamonds=1,clubs=0)#spades:黑桃 hearts:红桃 diamonds:方块 clubs:梅花
# spades A>hearts A>diamonds A>clubs A>
# spades K>hearts K>diamonds K>clubs K>
# spades Q>hearts Q>diamonds Q>clubs Q>
# spades J>hearts J>diamonds J>clubs J>
# spades 10>hearts 10>diamonds 10>clubs 10>
# spades 9>hearts 9>diamonds 9>clubs 9>
# spades 8>hearts 8>diamonds 8>clubs 8>
# spades 7>hearts 7>diamonds 7>clubs 7>
# spades 6>hearts 6>diamonds 6>clubs 6>
# spades 5>hearts 5>diamonds 5>clubs 5>
# spades 4>hearts 4>diamonds 4>clubs 4>
# spades 3>hearts 3>diamonds 3>clubs 3>
#  1*4+3    1*4+2     1*4+1     1*4+0
# spades 2>hearts 2>diamonds 2>clubs 2
#  0*4+3    0*4+2     0*4+1     0*4+0
def spades_high(card):rank_value=FrenchDeck.ranks.index(card.rank)return rank_value*len(suit_values)+suit_values[card.suit]#排序规则的公式for card in sorted(deck,key=spades_high):#先将card传入spades_high()函数进行计算，按最终返回值排序print(card,spades_high(card))

有了spades_high函数，就能对这摞纸牌进行升序排序了。

/Users/zy/PycharmProjects/learnpython/venv/bin/python /Users/zy/PycharmProjects/learnpython/collect.py
Card(rank='2', suit='clubs') 0
Card(rank='2', suit='diamonds') 1
Card(rank='2', suit='hearts') 2
Card(rank='2', suit='spades') 3
Card(rank='3', suit='clubs') 4
Card(rank='3', suit='diamonds') 5
Card(rank='3', suit='hearts') 6
Card(rank='3', suit='spades') 7
Card(rank='4', suit='clubs') 8
Card(rank='4', suit='diamonds') 9
Card(rank='4', suit='hearts') 10
Card(rank='4', suit='spades') 11
Card(rank='5', suit='clubs') 12
Card(rank='5', suit='diamonds') 13
Card(rank='5', suit='hearts') 14
Card(rank='5', suit='spades') 15
Card(rank='6', suit='clubs') 16
Card(rank='6', suit='diamonds') 17
Card(rank='6', suit='hearts') 18
Card(rank='6', suit='spades') 19
Card(rank='7', suit='clubs') 20
Card(rank='7', suit='diamonds') 21
Card(rank='7', suit='hearts') 22
Card(rank='7', suit='spades') 23
Card(rank='8', suit='clubs') 24
Card(rank='8', suit='diamonds') 25
Card(rank='8', suit='hearts') 26
Card(rank='8', suit='spades') 27
Card(rank='9', suit='clubs') 28
Card(rank='9', suit='diamonds') 29
Card(rank='9', suit='hearts') 30
Card(rank='9', suit='spades') 31
Card(rank='10', suit='clubs') 32
Card(rank='10', suit='diamonds') 33
Card(rank='10', suit='hearts') 34
Card(rank='10', suit='spades') 35
Card(rank='J', suit='clubs') 36
Card(rank='J', suit='diamonds') 37
Card(rank='J', suit='hearts') 38
Card(rank='J', suit='spades') 39
Card(rank='Q', suit='clubs') 40
Card(rank='Q', suit='diamonds') 41
Card(rank='Q', suit='hearts') 42
Card(rank='Q', suit='spades') 43
Card(rank='K', suit='clubs') 44
Card(rank='K', suit='diamonds') 45
Card(rank='K', suit='hearts') 46
Card(rank='K', suit='spades') 47
Card(rank='A', suit='clubs') 48
Card(rank='A', suit='diamonds') 49
Card(rank='A', suit='hearts') 50
Card(rank='A', suit='spades') 51Process finished with exit code 0

通过实现__len__和__getitem__这两个特殊方法，FrenchDeck这个类就像python自有的序列数据类型一样，拥有迭代、切片等python核心语言特性。

练习：创建一个书本类

Book=collections.namedtuple('Book',['name','editor','id'])
# a_book=Book(name='救赎',editor='lily',id='20211101')
# print(a_book)
class MyBook:names='abandon baby cloud dead'.split()editors='lili susan yang alice'.split()ids=[x for x in range(2,6)]def __init__(self):self._book=[Book(name,editor,id) for name in self.names for editor in self.editors for id in self.ids] #这种写法对names,editors,ids进行了全排列组合def __len__(self):return len(self._book)def __getitem__(self, item):return self._book[item]b=MyBook()
print(len(b))
print(b[2])

执行结果如下：

/Users/zy/PycharmProjects/learnpython/venv/bin/python /Users/zy/PycharmProjects/learnpython/collect.py
64
Book(name='abandon', editor='lili', id=4)Process finished with exit code 0

如何使用特殊方法

特殊方法的存在是为了被python解释器调用，你自己并不需要去调用它。

deck.__len__()
deck.__getitem__(3)

也就是说，上面这两种写法虽然可执行，但是是不合规的。应该使用下面的写法

len(deck)
deck[1]

如果是一个自定义类，比如FrenchDeck，在执行len(deck)，python会自动去调用FrenchDeck类中由你自己实现的__len__方法。

如果是python内置的类型，比如str，list，执行len(str)，CPython会抄个近路，直接返回PyVarObject里的ob_size属性，直接读取这个值比调用一个方法快很多。

特殊方法的调用是隐式的，比如for i in x:这个语句，背后其实是iter(x)，而这个函数的背后是x.__iter__()（前提是__iter__这个方法在x中被实现了）。

一般你的代码无需直接使用特殊方法，除了在你自己的子类的__init__中调用超类的构造器。一般通过内置函数（len、str、iter等）来使用特殊方法是最好的选择。

模拟数值类型

利用特殊方法，可以让自定义对象通过“+”号进行运算。

示例：自定义类，实现二维向量的加减

from math import hypot
class Vector:def __init__(self,x,y):self.x=xself.y=ydef __repr__(self):'''自定义输出实例化对象时的信息:return:'''return 'Vector(%r,%r)' % (self.x,self.y)def __abs__(self):'''自定义向量求模:return:'''return hypot(self.x,self.y)def __add__(self, other):'''自定义向量相加方法:param other::return:'''x=self.x+other.xy=self.y+other.yreturn Vector(x,y)def __mul__(self, scalar):'''自定义向量乘常数:param scalar::return:'''return Vector(self.x*scalar,self.y*scalar)def __bool__(self):'''返回向量是否为0:return:'''return bool(abs(self))vector1=Vector(3,4)
print("调用__repr__方法：%r" % vector1)
vector2=Vector(1,2)
print("调用__add__方法：%r" % (vector1+vector2))
print("调用__mul__方法：%r" % (vector1*3))
vector3=Vector(0,0)
print("调用__abs__方法：%r"% abs(vector1))
print("调用__bool__方法：%r" % bool(vector3))

执行结果：

/Users/zy/PycharmProjects/learnpython/venv/bin/python /Users/zy/PycharmProjects/learnpython/collect.py
调用__repr__方法：Vector(3,4)
调用__add__方法：Vector(4,6)
调用__mul__方法：Vector(9,12)
调用__abs__方法：5.0
调用__bool__方法：FalseProcess finished with exit code 0

补充知识点：

python格式符

格式符类型码
%s字符串（采用str()的显示）
%r字符串（采用repr()的显示）
%c单个字符
%b二进制整数
%d十进制整数
%i十进制整数
%o八进制整数
%s十六进制整数
%e指数（基底写为e）
%E指数（基底写为E）
%f浮点数
%F浮点数（同上）
%g指数（e）或浮点数（根据显示长度）
%G指数（E）或浮点数（根据显示长度）

字符串表示形式

python内置函数repr()，能把一个对象用字符串表示形式表达出来，这就是“字符串表示形式”。repr()函数背后调用的是__repr__。如果没有实现__repr__，我们打印一个对象，可能会是**<main.testrepr object at 0x108e6e9d0>**这种显示。

在格式符中，用%r来代替repr()函数返回的结果。str.format()的新式格式化字符串语法也用到了repr。

在Vector向量的示例中，我们使用**“Vector(%r,%r)” %(self.x,self.y)**来获取对象的字符串表示形式，而不是使用%s来获取对象的字符串值。

__repr__和__str__的区别是，后者会在str()函数和使用print()时被调用，且返回的字符串对终端用户更友好。

如果你只想实现两个特殊方法的其中一个，建议实现__repr__，当调用str()时，如果对象没有实现__str__，解释器会用__repr__替代。见下面的示例：

class testrepr:def __init__(self,x):self.x=xdef __repr__(self):return 'y'def __str__(self):return 'z'tr=testrepr(1)
print(str(tr))

执行上述代码，可以看到str(tr)的返回是z，如果注释掉__str__方法，再次执行，str(tr)的返回是y。

python对象的一个基本要求就是它得有合理的字符串表示形式，我们可以通过__repr__和__str__来满足这个要求，前者方便我们调试和记录日志，后者方便给终端用户看。

算术运算符

在Vector向量运算的示例中，我们通过特殊方法__mul__，__add__重新定义了向量加法，向量乘法的运算规则。

自定义布尔值

任何对象都可以用于需要布尔值的上下文，比如if、while、and、or、not，默认情况下，我们自定义的类的实例总是被认为是True。如下面的示例：

class testbool:def __init__(self,x):self.x=xtb=testbool(1)
print(bool(tb))

执行结果为True。

bool(x)的背后是调用x.__bool__()的结果，如果不存在__bool__方法，python解释器会尝试去调用__len__()方法，若返回0，则bool会返回False，否则返回True。示例如下：

x=""
print(bool(x))

执行结果为False。

我们可以自定义__bool__方法，像Vector向量示例中那样，去定义判断规则，返回值。

特殊方法一览

跟运算符无关的特殊方法：

类别方法名
字符串/字节序列表示形式__repr__、__str__、__format__、__bytes__
数值转换__abs__、__bool__、__complex__、__int__、__float__、__hash__、__index__
集合模拟__len__、__getitem__、__setitem__、__delitem__、__contains__
迭代枚举__iter__、__reversed__、__next__
可调用模拟__call__
上下文管理__enter__、__exit__
实例创建和销毁__new__、__init__、__del__
属性管理__getattr__、__getattribute__、__setattr__、__delattr__、__dir__
属性描述符__get__、__set__、__delete__
跟类相关的服务__prepare__、__instancecheck__、__subclasscheck__

跟运算符相关的特殊方法：

类别方法名和对应的运算符
一元运算符__neg__ -、__pos__ +、__abs__ abs()
众多比较运算符__lt__ <、__le__ <=、__eq__ ==、__ne__ !=、__gt__ >、__ge__ >=
算术运算符__add__ +、__sub__ -、__mul__ *、__truediv__ /、__floordiv__ //、__mod__ %、__divmod__ divmode()、__pow__ **或pow()、__round__ round()
反向算数运算符__radd__、__rsub__、__rmul__、__rtruediv__、__rfloordiv__、__rmod__、__rdivmod__、__rpow__
增量赋值算数运算符__iadd__、__isub__、__imul__、__itruediv__、__ifloordiv__、__imod__、__ipow__
位运算符__invert__ ~、__lshift__ <<、__rshift__ >>、__and__ &、__or__ |、__xor__ ^
反向位运算符__rlshift__、__rrshift__、__rand__、__rxor__、__ror__
增量赋值位运算符__ilshift__、__irshift__、__iand__、__ixor__、__ior__

反向运算符：当交换两数的位置时，就会调用反向运算符。（b*a而不是a*b）

增量赋值运算符：增量赋值运算是一种把中缀运算符变成赋值运算的捷径。（如a=a+b变成a+=b）

为什么len不是普通方法

“使用胜于纯粹。”——《python之禅》

如果x是一个内置类型的实例，len(x)执行不需要调用任何方法（CPython会直接从一个C结构体里读取对象的长度），故而len(x)的速度会非常快而高效。len之所以不是一个普通方法，是因为它让python自带的数据结构可以走后门，abs也是同理。

这篇关于《流畅的python 第一章 python数据模型》的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

原文地址:
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.chinasem.cn/article/1015704。

相关文章

Python使用自带的base64库进行base64编码和解码

Python使用自带的base64库进行base64编码和解码

《Python使用自带的base64库进行base64编码和解码》在Python中,处理数据的编码和解码是数据传输和存储中非常普遍的需求,其中,Base64是一种常用的编码方案,本文我将详细介绍如何使... 目录引言使用python的base64库进行编码和解码编码函数解码函数Base64编码的应用场景注意
阅读更多...
Python基于wxPython和FFmpeg开发一个视频标签工具

Python基于wxPython和FFmpeg开发一个视频标签工具

《Python基于wxPython和FFmpeg开发一个视频标签工具》在当今数字媒体时代,视频内容的管理和标记变得越来越重要,无论是研究人员需要对实验视频进行时间点标记,还是个人用户希望对家庭视频进行... 目录引言1. 应用概述2. 技术栈分析2.1 核心库和模块2.2 wxpython作为GUI选择的优
阅读更多...
Python如何使用__slots__实现节省内存和性能优化

Python如何使用__slots__实现节省内存和性能优化

《Python如何使用__slots__实现节省内存和性能优化》你有想过,一个小小的__slots__能让你的Python类内存消耗直接减半吗,没错,今天咱们要聊的就是这个让人眼前一亮的技巧,感兴趣的... 目录背景：内存吃得满满的类__slots__：你的内存管理小助手举个大概的例子：看看效果如何？1.
阅读更多...
Python+PyQt5实现多屏幕协同播放功能

Python+PyQt5实现多屏幕协同播放功能

《Python+PyQt5实现多屏幕协同播放功能》在现代会议展示、数字广告、展览展示等场景中,多屏幕协同播放已成为刚需,下面我们就来看看如何利用Python和PyQt5开发一套功能强大的跨屏播控系统吧... 目录一、项目概述：突破传统播放限制二、核心技术解析2.1 多屏管理机制2.2 播放引擎设计2.3 专
阅读更多...
Python中随机休眠技术原理与应用详解

Python中随机休眠技术原理与应用详解

《Python中随机休眠技术原理与应用详解》在编程中,让程序暂停执行特定时间是常见需求,当需要引入不确定性时,随机休眠就成为关键技巧,下面我们就来看看Python中随机休眠技术的具体实现与应用吧... 目录引言一、实现原理与基础方法1.1 核心函数解析1.2 基础实现模板1.3 整数版实现二、典型应用场景2
阅读更多...
Python实现无痛修改第三方库源码的方法详解

Python实现无痛修改第三方库源码的方法详解

《Python实现无痛修改第三方库源码的方法详解》很多时候,我们下载的第三方库是不会有需求不满足的情况,但也有极少的情况,第三方库没有兼顾到需求,本文将介绍几个修改源码的操作,大家可以根据需求进行选择... 目录需求不符合模拟示例 1. 修改源文件2. 继承修改3. 猴子补丁4. 追踪局部变量需求不符合很
阅读更多...
python+opencv处理颜色之将目标颜色转换实例代码

python+opencv处理颜色之将目标颜色转换实例代码

《python+opencv处理颜色之将目标颜色转换实例代码》OpenCV是一个的跨平台计算机视觉库,可以运行在Linux、Windows和MacOS操作系统上,：本文主要介绍python+ope... 目录下面是代码+ 效果 + 解释转HSV： 关于颜色总是要转HSV的掩膜再标注总结 目标：将红色的部分滤
阅读更多...
Python 中的异步与同步深度解析(实践记录)

Python 中的异步与同步深度解析(实践记录)

《Python中的异步与同步深度解析(实践记录)》在Python编程世界里,异步和同步的概念是理解程序执行流程和性能优化的关键,这篇文章将带你深入了解它们的差异,以及阻塞和非阻塞的特性,同时通过实际... 目录python中的异步与同步：深度解析与实践异步与同步的定义异步同步阻塞与非阻塞的概念阻塞非阻塞同步
阅读更多...
Python Dash框架在数据可视化仪表板中的应用与实践记录

Python Dash框架在数据可视化仪表板中的应用与实践记录

《PythonDash框架在数据可视化仪表板中的应用与实践记录》Python的PlotlyDash库提供了一种简便且强大的方式来构建和展示互动式数据仪表板,本篇文章将深入探讨如何使用Dash设计一... 目录python Dash框架在数据可视化仪表板中的应用与实践1. 什么是Plotly Dash？1.1
阅读更多...
在C#中调用Python代码的两种实现方式

在C#中调用Python代码的两种实现方式

《在C#中调用Python代码的两种实现方式》：本文主要介绍在C#中调用Python代码的两种实现方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录C#调用python代码的方式1. 使用 Python.NET2. 使用外部进程调用 Python 脚本总结C#调
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2