不懂关于Python的知识点有哪些？其实想解决这个问题也不难，下面让小编带着大家一起学习怎么去解决，希望大家阅读完这篇文章后大所收获。

No.1 一切皆对象

众所周知，Java中强调“一切皆对象”，但是Python中的面向对象比Java更加彻底，因为Python中的类(class)也是对象，函数（function）也是对象，而且Python的代码和模块也都是对象。

·Python中函数和类可以赋值给一个变量

·Python中函数和类可以存放到集合对象中

·Python中函数和类可以作为一个函数的参数传递给函数

·Python中函数和类可以作为返回值

Step.1

#首先创建一个函数和一个Python3.x的新式类classDemo(object):def__init__(self):print("DemoClass")#定义一个函数deffunction():print("function")#在Python无论是函数，还是类，都是对象，他们可以赋值给一个变量class_value=Demofunc_value=function#并且可以通过变量调用class_value()#DemoClassfunc_value()#function

Step.2

#将函数和类添加到集合中obj_list=[]obj_list.append(Demo)obj_list.append(function)#遍历列表foriinobj_list:print(i)#<class'__main__.Demo'>#<functionfunctionat0x0000020D681B3E18>

Step.3

#定义一个具体函数deftest_func(class_name,func_name):class_name()func_name()#将类名和函数名传入形参列表test_func(Demo,function)#DemoClass#function

Step.4

#定义函数实现返回类和函数deftest_func2():returnDemodeftest_func3():returnfunction#执行函数test_func2()()#DemoClasstest_func3()()#function

No.2 关键字type、object、class之间的关系

在Python中，object的实例是type，object是顶层类，没有基类；type的实例是type，type的基类是object。Python中的内置类型的基类是object，但是他们都是由type实例化而来，具体的值由内置类型实例化而来。在Python2.x的语法中用户自定义的类没有明确指定基类就默认是没有基类，在Python3.x的语法中，指定基类为object。

#object是谁实例化的？print(type(object))#<class'type'>#object继承自哪个类？print(object.__bases__)#()#type是谁实例化的？print(type(type))#<class'type'>#type继承自哪个类？print(type.__bases__)#(<class'object'>,)#定义一个变量value=100#100由谁实例化？print(type(value))#<class'int'>#int由谁实例化？print(type(int))#<class'type'>#int继承自哪个类？print(int.__bases__)#(<class'object'>,)#Python2.x的旧式类classOldClass():pass#Python3.x的新式类classNewClass(object):pass

No.3 Python的内置类型

在Python中，对象有3个特征属性：

·在内存中的地址，使用id()函数进行查看

·对象的类型

·对象的默认值

Step.1 None类型

在Python解释器启动时，会创建一个None类型的None对象，并且None对象全局只有一个。

Step.2 数值类型

·ini类型

·float类型

·complex类型

·bool类型

Step.3 迭代类型

在Python中，迭代类型可以使用循环来进行遍历。

Step.4 序列类型

·list

·tuple

·str

·array

·range

·bytes, bytearray, memoryvie（二进制序列）

Step.5 映射类型

dict

Step.6 集合类型

·set

·frozenset

Step.7 上下文管理类型

with语句

Step.8 其他类型

·模块

·class

·实例

·函数

·方法

·代码

·object对象

·type对象

·ellipsis（省略号）

·notimplemented

NO.4 魔法函数

Python中的魔法函数使用双下划线开始，以双下划线结尾。关于详细介绍请看我的文章——《全面总结Python中的魔法函数》。

No.5 鸭子类型与白鹅类型

鸭子类型是程序设计中的推断风格，在鸭子类型中关注对象如何使用而不是类型本身。鸭子类型像多态一样工作但是没有继承。鸭子类型的概念来自于：“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”

#定义狗类classDog(object):defeat(self):print("dogiseatting...")#定义猫类classCat(object):defeat(self):print("catiseatting...")#定义鸭子类classDuck(object):defeat(self):print("duckiseatting...")#以上Python中多态的体现#定义动物列表an_li=[]#将动物添加到列表an_li.append(Dog)an_li.append(Cat)an_li.append(Duck)#依次调用每个动物的eat()方法foriinan_li:i().eat()#dogiseatting...#catiseatting...#duckiseatting...

白鹅类型是指只要 cls 是抽象基类，即 cls 的元类是 abc.ABCMeta ，就可以使用 isinstance(obj, cls)。

No.6 协议、 抽象基类、abc模块和序列之间的继承关系

协议：Python中的非正式接口，是允许Python实现多态的方式，协议是非正式的，不具备强制性，由约定和文档定义。

接口：泛指实体把自己提供给外界的一种抽象化物（可以为另一实体），用以由内部操作分离出外部沟通方法，使其能被内部修改而不影响外界其他实体与其交互的方式。

我们可以使用猴子补丁来实现协议，那么什么是猴子补丁呢？

猴子补丁就是在运行时修改模块或类，不去修改源代码，从而实现目标协议接口操作，这就是所谓的打猴子补丁。

Tips：猴子补丁的叫法起源于Zope框架，开发人员在修改Zope的Bug时，经常在程序后面追加更新的部分，这些杂牌军补丁的英文名字叫做guerilla patch，后来写成gorllia，接着就变成了monkey。

猴子补丁的主要作用是：

·在运行时替换方法、属性；

·在不修改源代码的情况下对程序本身添加之前没有的功能；

·在运行时对象中添加补丁，而不是在磁盘中的源代码上。

应用案例：假设写了一个很大的项目，处处使用了json模块来解析json文件，但是后来发现ujson比json性能更高，修改源代码是要修改很多处的，所以只需要在程序入口加入：

importjson#pipinstallujsonimportujsondefmonkey_patch_json():json.__name__='ujson'json.dumps=ujson.dumpsjson.loads=ujson.loadsmonkey_patch_json()

Python 的抽象基类有一个重要实用优势：可以使用 register 类方法在终端用户的代码中把某个类 “声明” 为一个抽象基类的 “虚拟” 子 类（为此，被注册的类必腨满足抽象其类对方法名称和签名的要求，最重要的是要满足底 层语义契约；但是，开发那个类时不用了解抽象基类，更不用继承抽象基类 。有时，为了让抽象类识别子类，甚至不用注册。要抑制住创建抽象基类的冲动。滥用抽象基类会造成灾难性后果，表明语言太注重表面形式 。

·抽象基类不能被实例化(不能创建对象)，通常是作为基类供子类继承，子类中重写虚函数，实现具体的接口。

·判定某个对象的类型

·强制子类必须实现某些方法

抽象基类的定义与使用

importabc#定义缓存类classCache(metaclass=abc.ABCMeta):@abc.abstractmethoddefget(self,key):pass@abc.abstractmethoddefset(self,key,value):pass#定义redis缓存类实现Cache类中的get()和set()方法classRedisCache(Cache):defset(self,key):passdefget(self,key,value):pass

值得注意的是：Python 3.0-Python3.3之间，继承抽象基类的语法是class ClassName(metaclass=adc.ABCMeta)，其他版本是：class ClassName(abc.ABC)。

collections.abc模块中各个抽象基类的UML类图

No.7 isinstence和type的区别

classA(object):passclassB(A):passb=B()print(isinstance(b,B))print(isinstance(b,A))print(type(b)isB)print(type(b)isA)#True#True#True#False

No.8 类变量和实例变量

·实例变量只能通过类的实例进行调用

·修改模板对象创建的对象的属性，模板对象的属性不会改变

·修改模板对象的属性，由模板对象创建的对象的属性会改变

#此处的类也是模板对象，Python中一切皆对象classA(object):#类变量number=12def__init__(self):#实例变量self.number_2=13#实例变量只能通过类的实例进行调用print(A.number)#12print(A().number)#12print(A().number_2)#13#修改模板对象创建的对象的属性，模板对象的属性不会改变a=A()a.number=18print(a.number)#18print(A().number)#12print(A.number)#12#修改模板对象的属性，由模板对象创建的对象的属性会改变A.number=19print(A.number)#19print(A().number)#19

No.9 类和实例属性以及方法的查找顺序

在Python 2.2之前只有经典类，到Python2.7还会兼容经典类，Python3.x以后只使用新式类，Python之前版本也会兼容新式类

Python 2.2 及其之前类没有基类，Python新式类需要显式继承自object，即使不显式继承也会默认继承自object

经典类在类多重继承的时候是采用从左到右深度优先原则匹配方法的.而新式类是采用C3算法

经典类没有MRO和instance.mro()调用的

假定存在以下继承关系：

classD(object):defsay_hello(self):passclassE(object):passclassB(D):passclassC(E):passclassA(B,C):pass

采用DFS（深度优先搜索算法）当调用了A的say_hello()方法的时候，系统会去B中查找如果B中也没有找到，那么去D中查找，很显然D中存在这个方法，但是DFS对于以下继承关系就会有缺陷：

classD(object):passclassB(D):passclassC(D):defsay_hello(self):passclassA(B,C):pass

在A的实例对象中调用say_hello方法时，系统会先去B中查找，由于B类中没有该方法的定义，所以会去D中查找，D类中也没有，系统就会认为该方法没有定义，其实该方法在C中定义了。所以考虑使用BFS（广度优先搜索算法），那么问题回到第一个继承关系，假定C和D具备重名方法，在调用A的实例的方法时，应该先在B中查找，理应调用D中的方法，但是使用BFS的时候，C类中的方法会覆盖D类中的方法。在Python 2.3以后的版本中，使用C3算法：

#获取解析顺序的方法类名.mro()类名.__mro__inspect.getmro(类名)

使用C3算法后的第二种继承顺序：

classD(object):passclassB(D):passclassC(D):defsay_hello(self):passclassA(B,C):passprint(A.mro())#[<class'__main__.A'>,<class'__main__.B'>,<class'__main__.C'>,<class'__main__.D'>,<class'object'>]

使用C3算法后的第一种继承顺序：

classD(object):passclassE(object):passclassB(D):passclassC(E):passclassA(B,C):passprint(A.mro())#[<class'__main__.A'>,<class'__main__.B'>,<class'__main__.D'>,<class'__main__.C'>,<class'__main__.E'>,<class'object'>]

在这里仅介绍了算法的作用和演变历史，关于深入详细解析，请看我的其他文章——《从Python继承谈起，到C3算法落笔》。

No.10 类方法、实例方法和静态方法

classDemo(object):#类方法@classmethoddefclass_method(cls,number):pass#静态方法@staticmethoddefstatic_method(number):pass#对象方法/实例方法defobject_method(self,number):pass

实例方法只能通过类的实例来调用；静态方法是一个独立的、无状态的函数，紧紧依托于所在类的命名空间上；类方法在为了获取类中维护的数据，比如：

classHome(object):#房间中人数__number=0@classmethoddefadd_person_number(cls):cls.__number+=1@classmethoddefget_person_number(cls):returncls.__numberdef__new__(self):Home.add_person_number()#重写__new__方法，调用object的__new__returnsuper().__new__(self)classPerson(Home):def__init__(self):#房间人员姓名self.name='name'#创建人员对象时调用Home的__new__()方法tom=Person()print(type(tom))#<class'__main__.Person'>alice=Person()bob=Person()test=Person()print(Home.get_person_number())

No.11 数据封装和私有属性

Python中使用双下划线+属性名称实现类似于静态语言中的private修饰来实现数据封装。

classUser(object):def__init__(self,number):self.__number=numberself.__number_2=0defset_number(self,number):self.__number=numberdefget_number(self):returnself.__numberdefset_number_2(self,number2):self.__number_2=number2#self.__number2=number2defget_number_2(self):returnself.__number_2#returnself.__number2u=User(25)print(u.get_number())#25#真的类似于Java的反射机制吗？print(u._User__number)#25#下面又是啥情况。。。想不明白了T_Tu.set_number_2(18)print(u.get_number_2())#18print(u._User__number_2)#Anaconda3.6.3第一次是：u._User__number_2第二次是：18#Anaconda3.6.5结果都是0#代码我改成了正确答案，感谢我大哥给我指正错误，我保留了错误痕迹#变量名称写错了，算是个写博客突发事故，这问题我找了一天，万分感谢我大哥，我太傻B了，犯了低级错误#留给和我一样的童鞋参考我的错我之处吧！#正确结果：#25251818

No.12 Python的自省机制

自省（introspection）是一种自我检查行为。在计算机编程中，自省是指这种能力：检查某些事物以确定它是什么、它知道什么以及它能做什么。自省向程序员提供了极大的灵活性和控制力。

dir([obj])：返回传递给它的任何对象的属性名称经过排序的列表（会有一些特殊的属性不包含在内）

getattr(obj, attr)：返回任意对象的任何属性 ，调用这个方法将返回obj中名为attr值的属性的值

... ...

No.13 super函数

Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(type[, object-or-type]).xxx 。

super()函数用来调用MRO（类方法解析顺序表）的下一个类的方法。

No.14 Mixin继承

在设计上将Mixin类作为功能混入继承自Mixin的类。使用Mixin类实现多重继承应该注意：

Mixin类必须表示某种功能

职责单一，如果要有多个功能，就要设计多个Mixin类

不依赖子类实现，Mixin类的存在仅仅是增加了子类的功能特性

即使子类没有继承这个Mixin类也可以工作

classCat(object):defeat(self):print("Icaneat.")defdrink(self):print("Icandrink.")classCatFlyMixin(object):deffly(self):print("Icanfly.")classCatJumpMixin(object):defjump(self):print("Icanjump.")classTomCat(Cat,CatFlyMixin):passclassPersianCat(Cat,CatFlyMixin,CatJumpMixin):passif__name__=='__main__':#汤姆猫没有跳跃功能tom=TomCat()tom.fly()tom.eat()tom.drink()#波斯猫混入了跳跃功能persian=PersianCat()persian.drink()persian.eat()persian.fly()persian.jump()

No.15 上下文管理器with语句与contextlib简化

普通的异常捕获机制：

try:passexceptExceptionaserr:passelse:passfinally:pass

with简化了异常捕获写法：

classDemo(object):def__enter__(self):print("enter...")returnselfdef__exit__(self,exc_type,exc_val,exc_tb):print("exit...")defecho_hello(self):print("Hello,Hello...")withDemo()asd:d.echo_hello()#enter...#Hello,Hello...#exit...importcontextlib#使用装饰器@contextlib.contextmanagerdeffile_open(file_name):#此处写__enter___函数中定义的代码print("enterfunctioncode...")yield{}#此处写__exit__函数中定义的代码print("exitfunctioncode...")withfile_open("json.json")asf:pass#enterfunctioncode...#exitfunctioncode...

No.16 序列类型的分类

容器序列：list tuple deque

扁平序列：str bytes bytearray array.array

可变序列：list deque bytearray array

不可变序列：str tuple bytes

No.17 +、+=、extend()之间的区别于应用场景

首先看测试用例：

#创建一个序列类型的对象my_list=[1,2,3]#将现有的序列合并到my_listextend_my_list=my_list+[4,5]print(extend_my_list)#[1,2,3,4,5]#将一个元组合并到这个序列extend_my_list=my_list+(6,7)#抛出异常TypeError:canonlyconcatenatelist(not"tuple")tolistprint(extend_my_list)#使用另一种方式合并extend_my_list+=(6,7)print(extend_my_list)#[1,2,3,4,5,6,7]#使用extend()函数进行合并extend_my_list.extend((7,8))print(extend_my_list)#[1,2,3,4,5,6,7,7,8]

由源代码片段可知：

classMutableSequence(Sequence):__slots__=()"""Alltheoperationsonaread-writesequence.Concretesubclassesmustprovide__new__or__init__,__getitem__,__setitem__,__delitem__,__len__,andinsert()."""#extend()方法内部使用for循环来append()元素，它接收一个可迭代序列defextend(self,values):'S.extend(iterable)--extendsequencebyappendingelementsfromtheiterable'forvinvalues:self.append(v)#调用+=运算的时候就是调用该函数，这个函数内部调用extend()方法def__iadd__(self,values):self.extend(values)returnself

No.18 使用bisect维护一个已排序的序列

importbisectmy_list=[]bisect.insort(my_list,2)bisect.insort(my_list,9)bisect.insort(my_list,5)bisect.insort(my_list,5)bisect.insort(my_list,1)#insort()函数返回接收的元素应该插入到指定序列的索引位置print(my_list)#[1,2,5,5,9]

No.19 deque类详解

deque是Python中一个双端队列，能在队列两端以的效率插入数据，位于collections模块中。

fromcollectionsimportdeque#定义一个双端队列，长度为3d=deque(maxlen=3)deque类的源码：classdeque(object):"""deque([iterable[,maxlen]])-->dequeobject一个类似列表的序列，用于对其端点附近的数据访问进行优化。"""defappend(self,*args,**kwargs):"""在队列右端添加数据"""passdefappendleft(self,*args,**kwargs):"""在队列左端添加数据"""passdefclear(self,*args,**kwargs):"""清空所有元素"""passdefcopy(self,*args,**kwargs):"""浅拷贝一个双端队列"""passdefcount(self,value):"""统计指定value值的出现次数"""return0defextend(self,*args,**kwargs):"""使用迭代的方式扩展deque的右端"""passdefextendleft(self,*args,**kwargs):"""使用迭代的方式扩展deque的左端"""passdefindex(self,value,start=None,stop=None):__doc__"""返回第一个符合条件的索引的值"""return0definsert(self,index,p_object):"""在指定索引之前插入"""passdefpop(self,*args,**kwargs):#realsignatureunknown"""删除并返回右端的一个元素"""passdefpopleft(self,*args,**kwargs):#realsignatureunknown"""删除并返回左端的一个元素"""passdefremove(self,value):#realsignatureunknown;restoredfrom__doc__"""删除第一个与value相同的值"""passdefreverse(self):#realsignatureunknown;restoredfrom__doc__"""翻转队列"""passdefrotate(self,*args,**kwargs):#realsignatureunknown"""向右旋转dequeN步，如果N是个负数，那么向左旋转N的绝对值步"""passdef__add__(self,*args,**kwargs):#realsignatureunknown"""Returnself+value."""passdef__bool__(self,*args,**kwargs):#realsignatureunknown"""self!=0"""passdef__contains__(self,*args,**kwargs):#realsignatureunknown"""Returnkeyinself."""passdef__copy__(self,*args,**kwargs):#realsignatureunknown"""Returnashallowcopyofadeque."""passdef__delitem__(self,*args,**kwargs):#realsignatureunknown"""Deleteself[key]."""passdef__eq__(self,*args,**kwargs):#realsignatureunknown"""Returnself==value."""passdef__getattribute__(self,*args,**kwargs):#realsignatureunknown"""Returngetattr(self,name)."""passdef__getitem__(self,*args,**kwargs):#realsignatureunknown"""Returnself[key]."""passdef__ge__(self,*args,**kwargs):#realsignatureunknown"""Returnself>=value."""passdef__gt__(self,*args,**kwargs):#realsignatureunknown"""Returnself>value."""passdef__iadd__(self,*args,**kwargs):#realsignatureunknown"""Implementself+=value."""passdef__imul__(self,*args,**kwargs):#realsignatureunknown"""Implementself*=value."""passdef__init__(self,iterable=(),maxlen=None):#knowncaseof_collections.deque.__init__"""deque([iterable[,maxlen]])-->dequeobjectAlist-likesequenceoptimizedfordataaccessesnearitsendpoints.#(copiedfromclassdoc)"""passdef__iter__(self,*args,**kwargs):#realsignatureunknown"""Implementiter(self)."""passdef__len__(self,*args,**kwargs):#realsignatureunknown"""Returnlen(self)."""passdef__le__(self,*args,**kwargs):#realsignatureunknown"""Returnself<=value."""passdef__lt__(self,*args,**kwargs):#realsignatureunknown"""Returnself<value."""passdef__mul__(self,*args,**kwargs):#realsignatureunknown"""Returnself*value.n"""pass@staticmethod#knowncaseof__new__def__new__(*args,**kwargs):#realsignatureunknown"""Createandreturnanewobject.Seehelp(type)foraccuratesignature."""passdef__ne__(self,*args,**kwargs):#realsignatureunknown"""Returnself!=value."""passdef__reduce__(self,*args,**kwargs):#realsignatureunknown"""Returnstateinformationforpickling."""passdef__repr__(self,*args,**kwargs):#realsignatureunknown"""Returnrepr(self)."""passdef__reversed__(self):#realsignatureunknown;restoredfrom__doc__"""D.__reversed__()--returnareverseiteratoroverthedeque"""passdef__rmul__(self,*args,**kwargs):#realsignatureunknown"""Returnself*value."""passdef__setitem__(self,*args,**kwargs):#realsignatureunknown"""Setself[key]tovalue."""passdef__sizeof__(self):#realsignatureunknown;restoredfrom__doc__"""D.__sizeof__()--sizeofDinmemory,inbytes"""passmaxlen=property(lambdaself:object(),lambdaself,v:None,lambdaself:None)#default"""maximumsizeofadequeorNoneifunbounded"""__hash__=None

No.20 列表推导式、生成器表达式、字典推导式

列表推导式

列表生成式要比操作列表效率高很多，但是列表生成式的滥用会导致代码可读性降低，并且列表生成式可以替换map()和reduce()函数。

#构建列表my_list=[xforxinrange(9)]print(my_list)#[0,1,2,3,4,5,6,7,8]#构建0-8中为偶数的列表my_list=[xforxinrange(9)if(x%2==0)]print(my_list)#[0,2,4,6,8]#构建0-8为奇数的列表，并将每个数字做平方运算deffunction(number):returnnumber*numbermy_list=[function(x)forxinrange(9)ifx%2!=0]print(my_list)#[1,9,25,49]

生成器表达式

生成器表达式就是把列表表达式的中括号变成小括号。

#构造一个生成器gen=(iforiinrange(9))#生成器可以被遍历foriingen:print(i)

生成器可以使用list()函数转换为列表：

#将生成器转换为列表li=list(gen)print(li)

字典推导式

d={'tom':18,'alice':16,'bob':20,}dict={key:valueforkey,valueind.items()}print(dict)#{'tom':18,'alice':16,'bob':20}

Set集合推导式

my_set={iforiinrange(9)}print(my_set)#{0,1,2,3,4,5,6,7,8}

No.21 Set与Dict的实现原理

Set和Dict的背后实现都是Hash(哈希)表，有的书本上也较散列表。Hash表原理可以参考我的算法与数学博客栏目，下面给出几点总结：

Set和Dict的效率高于List。

Se和Dict的Key必须是可哈希的元素。

在Python中，不可变对象都是可哈希的，比如：str、fronzenset、tuple，需要实现__hash__()函数。

Dict内存空间占用多，但是速度快，Python中自定义对象或Python内部对象都是Dict包装的。

Dict和Set的元素存储顺序和元素的添加顺序有关，但是添加元素时有可能改变已有的元素顺序。

List会随着元素数量的增加，查找元素的时间也会增大。

Dict和Set不会随着元素数量的增加而查找时间延长。

No.22 Python中的集合类模块collections

defaultdict

defaultdict在dict的基础上添加了default_factroy方法，它的作用是当key不存在的时候自动生成相应类型的value，defalutdict参数可以指定成list、set、int等各种类型。

应用场景：

fromcollectionsimportdefaultdictmy_list=[("Tom",18),("Tom",20),("Alice",15),("Bob",21),]def_dict=defaultdict(list)forkey,valinmy_list:def_dict[key].append(val)print(def_dict.items())#dict_items([('Tom',[18,20]),('Alice',[15]),('Bob',[21])])#如果不考虑重复元素可以使用如下方式def_dict_2=defaultdict(set)forkey,valinmy_list:def_dict_2[key].add(val)print(def_dict_2.items())#dict_items([('Tom',{18,20}),('Alice',{15}),('Bob',{21})])

源码：

classdefaultdict(Dict[_KT,_VT],Generic[_KT,_VT]):default_factory=...#type:Callable[[],_VT]@overloaddef__init__(self,**kwargs:_VT)->None:...@overloaddef__init__(self,default_factory:Optional[Callable[[],_VT]])->None:...@overloaddef__init__(self,default_factory:Optional[Callable[[],_VT]],**kwargs:_VT)->None:...@overloaddef__init__(self,default_factory:Optional[Callable[[],_VT]],map:Mapping[_KT,_VT])->None:...@overloaddef__init__(self,default_factory:Optional[Callable[[],_VT]],map:Mapping[_KT,_VT],**kwargs:_VT)->None:...@overloaddef__init__(self,default_factory:Optional[Callable[[],_VT]],iterable:Iterable[Tuple[_KT,_VT]])->None:...@overloaddef__init__(self,default_factory:Optional[Callable[[],_VT]],iterable:Iterable[Tuple[_KT,_VT]],**kwargs:_VT)->None:...def__missing__(self,key:_KT)->_VT:...#TODO__reversed__defcopy(self:_DefaultDictT)->_DefaultDictT:...

OrderedDict

OrderDict最大的特点就是元素位置有序，它是dict的子类。OrderDict在内部维护一个字典元素的有序列表。

应用场景：

fromcollectionsimportOrderedDictmy_dict={"Bob":20,"Tim":20,"Amy":18,}#通过key来排序order_dict=OrderedDict(sorted(my_dict.items(),key=lambdali:li[1]))print(order_dict)#OrderedDict([('Amy',18),('Bob',20),('Tim',20)])

源码：

classOrderedDict(dict):'Dictionarythatremembersinsertionorder'#Aninheriteddictmapskeystovalues.#Theinheriteddictprovides__getitem__,__len__,__contains__,andget.#Theremainingmethodsareorder-aware.#Big-Orunningtimesforallmethodsarethesameasregulardictionaries.#Theinternalself.__mapdictmapskeystolinksinadoublylinkedlist.#Thecirculardoublylinkedliststartsandendswithasentinelelement.#Thesentinelelementnevergetsdeleted(thissimplifiesthealgorithm).#Thesentinelisinself.__hardrootwithaweakrefproxyinself.__root.#Theprevlinksareweakrefproxies(topreventcircularreferences).#Individuallinksarekeptalivebythehardreferenceinself.__map.#ThosehardreferencesdisappearwhenakeyisdeletedfromanOrderedDict.def__init__(*args,**kwds):'''Initializeanordereddictionary.Thesignatureisthesameasregulardictionaries.Keywordargumentorderispreserved.'''ifnotargs:raiseTypeError("descriptor'__init__'of'OrderedDict'object""needsanargument")self,*args=argsiflen(args)>1:raiseTypeError('expectedatmost1arguments,got%d'%len(args))try:self.__rootexceptAttributeError:self.__hardroot=_Link()self.__root=root=_proxy(self.__hardroot)root.prev=root.next=rootself.__map={}self.__update(*args,**kwds)def__setitem__(self,key,value,dict_setitem=dict.__setitem__,proxy=_proxy,Link=_Link):'od.__setitem__(i,y)<==>od[i]=y'#Settinganewitemcreatesanewlinkattheendofthelinkedlist,#andtheinheriteddictionaryisupdatedwiththenewkey/valuepair.ifkeynotinself:self.__map[key]=link=Link()root=self.__rootlast=root.prevlink.prev,link.next,link.key=last,root,keylast.next=linkroot.prev=proxy(link)dict_setitem(self,key,value)def__delitem__(self,key,dict_delitem=dict.__delitem__):'od.__delitem__(y)<==>delod[y]'#Deletinganexistingitemusesself.__maptofindthelinkwhichgets#removedbyupdatingthelinksinthepredecessorandsuccessornodes.dict_delitem(self,key)link=self.__map.pop(key)link_prev=link.prevlink_next=link.nextlink_prev.next=link_nextlink_next.prev=link_prevlink.prev=Nonelink.next=Nonedef__iter__(self):'od.__iter__()<==>iter(od)'#Traversethelinkedlistinorder.root=self.__rootcurr=root.nextwhilecurrisnotroot:yieldcurr.keycurr=curr.nextdef__reversed__(self):'od.__reversed__()<==>reversed(od)'#Traversethelinkedlistinreverseorder.root=self.__rootcurr=root.prevwhilecurrisnotroot:yieldcurr.keycurr=curr.prevdefclear(self):'od.clear()->None.Removeallitemsfromod.'root=self.__rootroot.prev=root.next=rootself.__map.clear()dict.clear(self)defpopitem(self,last=True):'''Removeandreturna(key,value)pairfromthedictionary.PairsarereturnedinLIFOorderiflastistrueorFIFOorderiffalse.'''ifnotself:raiseKeyError('dictionaryisempty')root=self.__rootiflast:link=root.prevlink_prev=link.prevlink_prev.next=rootroot.prev=link_prevelse:link=root.nextlink_next=link.nextroot.next=link_nextlink_next.prev=rootkey=link.keydelself.__map[key]value=dict.pop(self,key)returnkey,valuedefmove_to_end(self,key,last=True):'''Moveanexistingelementtotheend(orbeginningiflast==False).RaisesKeyErroriftheelementdoesnotexist.Whenlast=True,actslikeafastversionofself[key]=self.pop(key).'''link=self.__map[key]link_prev=link.prevlink_next=link.nextsoft_link=link_next.prevlink_prev.next=link_nextlink_next.prev=link_prevroot=self.__rootiflast:last=root.prevlink.prev=lastlink.next=rootroot.prev=soft_linklast.next=linkelse:first=root.nextlink.prev=rootlink.next=firstfirst.prev=soft_linkroot.next=linkdef__sizeof__(self):sizeof=_sys.getsizeofn=len(self)+1#numberoflinksincludingrootsize=sizeof(self.__dict__)#instancedictionarysize+=sizeof(self.__map)*2#internaldictandinheriteddictsize+=sizeof(self.__hardroot)*n#linkobjectssize+=sizeof(self.__root)*n#proxyobjectsreturnsizeupdate=__update=MutableMapping.updatedefkeys(self):"D.keys()->aset-likeobjectprovidingaviewonD'skeys"return_OrderedDictKeysView(self)defitems(self):"D.items()->aset-likeobjectprovidingaviewonD'sitems"return_OrderedDictItemsView(self)defvalues(self):"D.values()->anobjectprovidingaviewonD'svalues"return_OrderedDictValuesView(self)__ne__=MutableMapping.__ne____marker=object()defpop(self,key,default=__marker):'''od.pop(k[,d])->v,removespecifiedkeyandreturnthecorrespondingvalue.Ifkeyisnotfound,disreturnedifgiven,otherwiseKeyErrorisraised.'''ifkeyinself:result=self[key]delself[key]returnresultifdefaultisself.__marker:raiseKeyError(key)returndefaultdefsetdefault(self,key,default=None):'od.setdefault(k[,d])->od.get(k,d),alsosetod[k]=difknotinod'ifkeyinself:returnself[key]self[key]=defaultreturndefault@_recursive_repr()def__repr__(self):'od.__repr__()<==>repr(od)'ifnotself:return'%s()'%(self.__class__.__name__,)return'%s(%r)'%(self.__class__.__name__,list(self.items()))def__reduce__(self):'Returnstateinformationforpickling'inst_dict=vars(self).copy()forkinvars(OrderedDict()):inst_dict.pop(k,None)returnself.__class__,(),inst_dictorNone,None,iter(self.items())defcopy(self):'od.copy()->ashallowcopyofod'returnself.__class__(self)@classmethoddeffromkeys(cls,iterable,value=None):'''OD.fromkeys(S[,v])->NewordereddictionarywithkeysfromS.Ifnotspecified,thevaluedefaultstoNone.'''self=cls()forkeyiniterable:self[key]=valuereturnselfdef__eq__(self,other):'''od.__eq__(y)<==>od==y.ComparisontoanotherODisorder-sensitivewhilecomparisontoaregularmappingisorder-insensitive.'''ifisinstance(other,OrderedDict):returndict.__eq__(self,other)andall(map(_eq,self,other))returndict.__eq__(self,other)

deque

list存储数据的时候，内部实现是数组，数组的查找速度是很快的，但是插入和删除数据的速度堪忧。deque双端列表内部实现是双端队列。deuque适用队列和栈，并且是线程安全的。

deque提供append()和pop()函数实现在deque尾部添加和弹出数据，提供appendleft()和popleft()函数实现在deque头部添加和弹出元素。这4个函数的时间复杂度都是的，但是list的时间复杂度高达。

创建deque队列

fromcollectionsimportdeque#创建一个队列长度为20的dequedQ=deque(range(10),maxlen=20)print(dQ)#deque([0,1,2,3,4,5,6,7,8,9],maxlen=20)

源码

classdeque(object):"""deque([iterable[,maxlen]])-->dequeobjectAlist-likesequenceoptimizedfordataaccessesnearitsendpoints."""defappend(self,*args,**kwargs):#realsignatureunknown"""Addanelementtotherightsideofthedeque."""passdefappendleft(self,*args,**kwargs):#realsignatureunknown"""Addanelementtotheleftsideofthedeque."""passdefclear(self,*args,**kwargs):#realsignatureunknown"""Removeallelementsfromthedeque."""passdefcopy(self,*args,**kwargs):#realsignatureunknown"""Returnashallowcopyofadeque."""passdefcount(self,value):#realsignatureunknown;restoredfrom__doc__"""D.count(value)->integer--returnnumberofoccurrencesofvalue"""return0defextend(self,*args,**kwargs):#realsignatureunknown"""Extendtherightsideofthedequewithelementsfromtheiterable"""passdefextendleft(self,*args,**kwargs):#realsignatureunknown"""Extendtheleftsideofthedequewithelementsfromtheiterable"""passdefindex(self,value,start=None,stop=None):#realsignatureunknown;restoredfrom__doc__"""D.index(value,[start,[stop]])->integer--returnfirstindexofvalue.RaisesValueErrorifthevalueisnotpresent."""return0definsert(self,index,p_object):#realsignatureunknown;restoredfrom__doc__"""D.insert(index,object)--insertobjectbeforeindex"""passdefpop(self,*args,**kwargs):#realsignatureunknown"""Removeandreturntherightmostelement."""passdefpopleft(self,*args,**kwargs):#realsignatureunknown"""Removeandreturntheleftmostelement."""passdefremove(self,value):#realsignatureunknown;restoredfrom__doc__"""D.remove(value)--removefirstoccurrenceofvalue."""passdefreverse(self):#realsignatureunknown;restoredfrom__doc__"""D.reverse()--reverse*INPLACE*"""passdefrotate(self,*args,**kwargs):#realsignatureunknown"""Rotatethedequenstepstotheright(defaultn=1).Ifnisnegative,rotatesleft."""passdef__add__(self,*args,**kwargs):#realsignatureunknown"""Returnself+value."""passdef__bool__(self,*args,**kwargs):#realsignatureunknown"""self!=0"""passdef__contains__(self,*args,**kwargs):#realsignatureunknown"""Returnkeyinself."""passdef__copy__(self,*args,**kwargs):#realsignatureunknown"""Returnashallowcopyofadeque."""passdef__delitem__(self,*args,**kwargs):#realsignatureunknown"""Deleteself[key]."""passdef__eq__(self,*args,**kwargs):#realsignatureunknown"""Returnself==value."""passdef__getattribute__(self,*args,**kwargs):#realsignatureunknown"""Returngetattr(self,name)."""passdef__getitem__(self,*args,**kwargs):#realsignatureunknown"""Returnself[key]."""passdef__ge__(self,*args,**kwargs):#realsignatureunknown"""Returnself>=value."""passdef__gt__(self,*args,**kwargs):#realsignatureunknown"""Returnself>value."""passdef__iadd__(self,*args,**kwargs):#realsignatureunknown"""Implementself+=value."""passdef__imul__(self,*args,**kwargs):#realsignatureunknown"""Implementself*=value."""passdef__init__(self,iterable=(),maxlen=None):#knowncaseof_collections.deque.__init__"""deque([iterable[,maxlen]])-->dequeobjectAlist-likesequenceoptimizedfordataaccessesnearitsendpoints.#(copiedfromclassdoc)"""passdef__iter__(self,*args,**kwargs):#realsignatureunknown"""Implementiter(self)."""passdef__len__(self,*args,**kwargs):#realsignatureunknown"""Returnlen(self)."""passdef__le__(self,*args,**kwargs):#realsignatureunknown"""Returnself<=value."""passdef__lt__(self,*args,**kwargs):#realsignatureunknown"""Returnself<value."""passdef__mul__(self,*args,**kwargs):#realsignatureunknown"""Returnself*value.n"""pass@staticmethod#knowncaseof__new__def__new__(*args,**kwargs):#realsignatureunknown"""Createandreturnanewobject.Seehelp(type)foraccuratesignature."""passdef__ne__(self,*args,**kwargs):#realsignatureunknown"""Returnself!=value."""passdef__reduce__(self,*args,**kwargs):#realsignatureunknown"""Returnstateinformationforpickling."""passdef__repr__(self,*args,**kwargs):#realsignatureunknown"""Returnrepr(self)."""passdef__reversed__(self):#realsignatureunknown;restoredfrom__doc__"""D.__reversed__()--returnareverseiteratoroverthedeque"""passdef__rmul__(self,*args,**kwargs):#realsignatureunknown"""Returnself*value."""passdef__setitem__(self,*args,**kwargs):#realsignatureunknown"""Setself[key]tovalue."""passdef__sizeof__(self):#realsignatureunknown;restoredfrom__doc__"""D.__sizeof__()--sizeofDinmemory,inbytes"""passmaxlen=property(lambdaself:object(),lambdaself,v:None,lambdaself:None)#default"""maximumsizeofadequeorNoneifunbounded"""__hash__=None

Counter

用来统计元素出现的次数。

应用场景

源码

classCounter(dict):'''Dictsubclassforcountinghashableitems.Sometimescalledabagormultiset.Elementsarestoredasdictionarykeysandtheircountsarestoredasdictionaryvalues.>>>c=Counter('abcdeabcdabcaba')#countelementsfromastring>>>c.most_common(3)#threemostcommonelements[('a',5),('b',4),('c',3)]>>>sorted(c)#listalluniqueelements['a','b','c','d','e']>>>''.join(sorted(c.elements()))#listelementswithrepetitions'aaaaabbbbcccdde'>>>sum(c.values())#totalofallcounts15>>>c['a']#countofletter'a'5>>>forelemin'shazam':#updatecountsfromaniterable...c[elem]+=1#byadding1toeachelement'scount>>>c['a']#nowthereareseven'a'7>>>delc['b']#removeall'b'>>>c['b']#nowtherearezero'b'0>>>d=Counter('simsalabim')#makeanothercounter>>>c.update(d)#addinthesecondcounter>>>c['a']#nowtherearenine'a'9>>>c.clear()#emptythecounter>>>cCounter()Note:Ifacountissettozeroorreducedtozero,itwillremaininthecounteruntiltheentryisdeletedorthecounteriscleared:>>>c=Counter('aaabbc')>>>c['b']-=2#reducethecountof'b'bytwo>>>c.most_common()#'b'isstillin,butitscountiszero[('a',3),('c',1),('b',0)]'''#References:#http://en.wikipedia.org/wiki/Multiset#http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html#http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm#http://code.activestate.com/recipes/259174/#Knuth,TAOCPVol.IIsection4.6.3def__init__(*args,**kwds):'''Createanew,emptyCounterobject.Andifgiven,countelementsfromaninputiterable.Or,initializethecountfromanothermappingofelementstotheircounts.>>>c=Counter()#anew,emptycounter>>>c=Counter('gallahad')#anewcounterfromaniterable>>>c=Counter({'a':4,'b':2})#anewcounterfromamapping>>>c=Counter(a=4,b=2)#anewcounterfromkeywordargs'''ifnotargs:raiseTypeError("descriptor'__init__'of'Counter'object""needsanargument")self,*args=argsiflen(args)>1:raiseTypeError('expectedatmost1arguments,got%d'%len(args))super(Counter,self).__init__()self.update(*args,**kwds)def__missing__(self,key):'ThecountofelementsnotintheCounteriszero.'#Neededsothatself[missing_item]doesnotraiseKeyErrorreturn0defmost_common(self,n=None):'''Listthenmostcommonelementsandtheircountsfromthemostcommontotheleast.IfnisNone,thenlistallelementcounts.>>>Counter('abcdeabcdabcaba').most_common(3)[('a',5),('b',4),('c',3)]'''#EmulateBag.sortedByCountfromSmalltalkifnisNone:returnsorted(self.items(),key=_itemgetter(1),reverse=True)return_heapq.nlargest(n,self.items(),key=_itemgetter(1))defelements(self):'''Iteratoroverelementsrepeatingeachasmanytimesasitscount.>>>c=Counter('ABCABC')>>>sorted(c.elements())['A','A','B','B','C','C']#Knuth'sexampleforprimefactorsof1836:2**2*3**3*17**1>>>prime_factors=Counter({2:2,3:3,17:1})>>>product=1>>>forfactorinprime_factors.elements():#loopoverfactors...product*=factor#andmultiplythem>>>product1836Note,ifanelement'scounthasbeensettozeroorisanegativenumber,elements()willignoreit.'''#EmulateBag.dofromSmalltalkandMultiset.beginfromC++.return_chain.from_iterable(_starmap(_repeat,self.items()))#Overridedictmethodswherenecessary@classmethoddeffromkeys(cls,iterable,v=None):#Thereisnoequivalentmethodforcountersbecausesettingv=1#meansthatnoelementcanhaveacountgreaterthanone.raiseNotImplementedError('Counter.fromkeys()isundefined.UseCounter(iterable)instead.')defupdate(*args,**kwds):'''Likedict.update()butaddcountsinsteadofreplacingthem.Sourcecanbeaniterable,adictionary,oranotherCounterinstance.>>>c=Counter('which')>>>c.update('witch')#addelementsfromanotheriterable>>>d=Counter('watch')>>>c.update(d)#addelementsfromanothercounter>>>c['h']#four'h'inwhich,witch,andwatch4'''#Theregulardict.update()operationmakesnosenseherebecausethe#replacebehaviorresultsinthesomeoforiginaluntouchedcounts#beingmixed-inwithalloftheothercountsforamismashthat#doesn'thaveastraight-forwardinterpretationinmostcounting#contexts.Instead,weimplementstraight-addition.Boththeinputs#andoutputsareallowedtocontainzeroandnegativecounts.ifnotargs:raiseTypeError("descriptor'update'of'Counter'object""needsanargument")self,*args=argsiflen(args)>1:raiseTypeError('expectedatmost1arguments,got%d'%len(args))iterable=args[0]ifargselseNoneifiterableisnotNone:ifisinstance(iterable,Mapping):ifself:self_get=self.getforelem,countiniterable.items():self[elem]=count+self_get(elem,0)else:super(Counter,self).update(iterable)#fastpathwhencounterisemptyelse:_count_elements(self,iterable)ifkwds:self.update(kwds)defsubtract(*args,**kwds):'''Likedict.update()butsubtractscountsinsteadofreplacingthem.Countscanbereducedbelowzero.Boththeinputsandoutputsareallowedtocontainzeroandnegativecounts.Sourcecanbeaniterable,adictionary,oranotherCounterinstance.>>>c=Counter('which')>>>c.subtract('witch')#subtractelementsfromanotheriterable>>>c.subtract(Counter('watch'))#subtractelementsfromanothercounter>>>c['h']#2inwhich,minus1inwitch,minus1inwatch0>>>c['w']#1inwhich,minus1inwitch,minus1inwatch-1'''ifnotargs:raiseTypeError("descriptor'subtract'of'Counter'object""needsanargument")self,*args=argsiflen(args)>1:raiseTypeError('expectedatmost1arguments,got%d'%len(args))iterable=args[0]ifargselseNoneifiterableisnotNone:self_get=self.getifisinstance(iterable,Mapping):forelem,countiniterable.items():self[elem]=self_get(elem,0)-countelse:foreleminiterable:self[elem]=self_get(elem,0)-1ifkwds:self.subtract(kwds)defcopy(self):'Returnashallowcopy.'returnself.__class__(self)def__reduce__(self):returnself.__class__,(dict(self),)def__delitem__(self,elem):'Likedict.__delitem__()butdoesnotraiseKeyErrorformissingvalues.'ifeleminself:super().__delitem__(elem)def__repr__(self):ifnotself:return'%s()'%self.__class__.__name__try:items=','.join(map('%r:%r'.__mod__,self.most_common()))return'%s({%s})'%(self.__class__.__name__,items)exceptTypeError:#handlecasewherevaluesarenotorderablereturn'{0}({1!r})'.format(self.__class__.__name__,dict(self))#Multiset-stylemathematicaloperationsdiscussedin:#KnuthTAOCPVolumeIIsection4.6.3exercise19#andathttp://en.wikipedia.org/wiki/Multiset##Outputsguaranteedtoonlyincludepositivecounts.##Tostripnegativeandzerocounts,add-inanemptycounter:#c+=Counter()def__add__(self,other):'''Addcountsfromtwocounters.>>>Counter('abbb')+Counter('bcc')Counter({'b':4,'c':2,'a':1})'''ifnotisinstance(other,Counter):returnNotImplementedresult=Counter()forelem,countinself.items():newcount=count+other[elem]ifnewcount>0:result[elem]=newcountforelem,countinother.items():ifelemnotinselfandcount>0:result[elem]=countreturnresultdef__sub__(self,other):'''Subtractcount,butkeeponlyresultswithpositivecounts.>>>Counter('abbbc')-Counter('bccd')Counter({'b':2,'a':1})'''ifnotisinstance(other,Counter):returnNotImplementedresult=Counter()forelem,countinself.items():newcount=count-other[elem]ifnewcount>0:result[elem]=newcountforelem,countinother.items():ifelemnotinselfandcount<0:result[elem]=0-countreturnresultdef__or__(self,other):'''Unionisthemaximumofvalueineitheroftheinputcounters.>>>Counter('abbb')|Counter('bcc')Counter({'b':3,'c':2,'a':1})'''ifnotisinstance(other,Counter):returnNotImplementedresult=Counter()forelem,countinself.items():other_count=other[elem]newcount=other_countifcount<other_countelsecountifnewcount>0:result[elem]=newcountforelem,countinother.items():ifelemnotinselfandcount>0:result[elem]=countreturnresultdef__and__(self,other):'''Intersectionistheminimumofcorrespondingcounts.>>>Counter('abbb')&Counter('bcc')Counter({'b':1})'''ifnotisinstance(other,Counter):returnNotImplementedresult=Counter()forelem,countinself.items():other_count=other[elem]newcount=countifcount<other_countelseother_countifnewcount>0:result[elem]=newcountreturnresultdef__pos__(self):'Addsanemptycounter,effectivelystrippingnegativeandzerocounts'result=Counter()forelem,countinself.items():ifcount>0:result[elem]=countreturnresultdef__neg__(self):'''Subtractsfromanemptycounter.Stripspositiveandzerocounts,andflipsthesignonnegativecounts.'''result=Counter()forelem,countinself.items():ifcount<0:result[elem]=0-countreturnresultdef_keep_positive(self):'''Internalmethodtostripelementswithanegativeorzerocount'''nonpositive=[elemforelem,countinself.items()ifnotcount>0]foreleminnonpositive:delself[elem]returnselfdef__iadd__(self,other):'''Inplaceaddfromanothercounter,keepingonlypositivecounts.>>>c=Counter('abbb')>>>c+=Counter('bcc')>>>cCounter({'b':4,'c':2,'a':1})'''forelem,countinother.items():self[elem]+=countreturnself._keep_positive()def__isub__(self,other):'''Inplacesubtractcounter,butkeeponlyresultswithpositivecounts.>>>c=Counter('abbbc')>>>c-=Counter('bccd')>>>cCounter({'b':2,'a':1})'''forelem,countinother.items():self[elem]-=countreturnself._keep_positive()def__ior__(self,other):'''Inplaceunionisthemaximumofvaluefromeithercounter.>>>c=Counter('abbb')>>>c|=Counter('bcc')>>>cCounter({'b':3,'c':2,'a':1})'''forelem,other_countinother.items():count=self[elem]ifother_count>count:self[elem]=other_countreturnself._keep_positive()def__iand__(self,other):'''Inplaceintersectionistheminimumofcorrespondingcounts.>>>c=Counter('abbb')>>>c&=Counter('bcc')>>>cCounter({'b':1})'''forelem,countinself.items():other_count=other[elem]ifother_count<count:self[elem]=other_countreturnself._keep_positive()

namedtuple

命名tuple中的元素来使程序更具可读性 。

应用案例

fromcollectionsimportnamedtupleCity=namedtuple('City','nametitlepopucoor')tokyo=City('Tokyo','下辈子让我做系守的姑娘吧！下辈子让我做东京的帅哥吧！',36.933,(35.689722,139.691667))print(tokyo)#City(name='Tokyo',title='下辈子让我做系守的姑娘吧！下辈子让我做东京的帅哥吧！',popu=36.933,coor=(35.689722,139.691667))defnamedtuple(typename,field_names,*,verbose=False,rename=False,module=None):"""Returnsanewsubclassoftuplewithnamedfields.>>>Point=namedtuple('Point',['x','y'])>>>Point.__doc__#docstringforthenewclass'Point(x,y)'>>>p=Point(11,y=22)#instantiatewithpositionalargsorkeywords>>>p[0]+p[1]#indexablelikeaplaintuple33>>>x,y=p#unpacklikearegulartuple>>>x,y(11,22)>>>p.x+p.y#fieldsalsoaccessiblebyname33>>>d=p._asdict()#converttoadictionary>>>d['x']11>>>Point(**d)#convertfromadictionaryPoint(x=11,y=22)>>>p._replace(x=100)#_replace()islikestr.replace()buttargetsnamedfieldsPoint(x=100,y=22)"""#Validatethefieldnames.Attheuser'soption,eithergenerateanerror#messageorautomaticallyreplacethefieldnamewithavalidname.ifisinstance(field_names,str):field_names=field_names.replace(',','').split()field_names=list(map(str,field_names))typename=str(typename)ifrename:seen=set()forindex,nameinenumerate(field_names):if(notname.isidentifier()or_iskeyword(name)orname.startswith('_')ornameinseen):field_names[index]='_%d'%indexseen.add(name)fornamein[typename]+field_names:iftype(name)isnotstr:raiseTypeError('Typenamesandfieldnamesmustbestrings')ifnotname.isidentifier():raiseValueError('Typenamesandfieldnamesmustbevalid''identifiers:%r'%name)if_iskeyword(name):raiseValueError('Typenamesandfieldnamescannotbea''keyword:%r'%name)seen=set()fornameinfield_names:ifname.startswith('_')andnotrename:raiseValueError('Fieldnamescannotstartwithanunderscore:''%r'%name)ifnameinseen:raiseValueError('Encounteredduplicatefieldname:%r'%name)seen.add(name)#Fill-intheclasstemplateclass_definition=_class_template.format(typename=typename,field_names=tuple(field_names),num_fields=len(field_names),arg_list=repr(tuple(field_names)).replace("'","")[1:-1],repr_fmt=','.join(_repr_template.format(name=name)fornameinfield_names),field_defs='\n'.join(_field_template.format(index=index,name=name)forindex,nameinenumerate(field_names)))#Executethetemplatestringinatemporarynamespaceandsupport#tracingutilitiesbysettingavalueforframe.f_globals['__name__']namespace=dict(__name__='namedtuple_%s'%typename)exec(class_definition,namespace)result=namespace[typename]result._source=class_definitionifverbose:print(result._source)#Forpicklingtowork,the__module__variableneedstobesettotheframe#wherethenamedtupleiscreated.Bypassthisstepinenvironmentswhere#sys._getframeisnotdefined(Jythonforexample)orsys._getframeisnot#definedforargumentsgreaterthan0(IronPython),orwheretheuserhas#specifiedaparticularmodule.ifmoduleisNone:try:module=_sys._getframe(1).f_globals.get('__name__','__main__')except(AttributeError,ValueError):passifmoduleisnotNone:result.__module__=modulereturnresult

ChainMap

用来合并多个字典。

应用案例

fromcollectionsimportChainMapcm=ChainMap({"Apple":18},{"Orange":20},{"Mango":22},{"pineapple":24},)print(cm)#ChainMap({'Apple':18},{'Orange':20},{'Mango':22},{'pineapple':24})

源码

classChainMap(MutableMapping):'''AChainMapgroupsmultipledicts(orothermappings)togethertocreateasingle,updateableview.Theunderlyingmappingsarestoredinalist.Thatlistispublicandcanbeaccessedorupdatedusingthe*maps*attribute.Thereisnootherstate.Lookupssearchtheunderlyingmappingssuccessivelyuntilakeyisfound.Incontrast,writes,updates,anddeletionsonlyoperateonthefirstmapping.'''def__init__(self,*maps):'''InitializeaChainMapbysetting*maps*tothegivenmappings.Ifnomappingsareprovided,asingleemptydictionaryisused.'''self.maps=list(maps)or[{}]#alwaysatleastonemapdef__missing__(self,key):raiseKeyError(key)def__getitem__(self,key):formappinginself.maps:try:returnmapping[key]#can'tuse'keyinmapping'withdefaultdictexceptKeyError:passreturnself.__missing__(key)#supportsubclassesthatdefine__missing__defget(self,key,default=None):returnself[key]ifkeyinselfelsedefaultdef__len__(self):returnlen(set().union(*self.maps))#reusesstoredhashvaluesifpossibledef__iter__(self):returniter(set().union(*self.maps))def__contains__(self,key):returnany(keyinmforminself.maps)def__bool__(self):returnany(self.maps)@_recursive_repr()def__repr__(self):return'{0.__class__.__name__}({1})'.format(self,','.join(map(repr,self.maps)))@classmethoddeffromkeys(cls,iterable,*args):'CreateaChainMapwithasingledictcreatedfromtheiterable.'returncls(dict.fromkeys(iterable,*args))defcopy(self):'NewChainMaporsubclasswithanewcopyofmaps[0]andrefstomaps[1:]'returnself.__class__(self.maps[0].copy(),*self.maps[1:])__copy__=copydefnew_child(self,m=None):#likeDjango'sContext.push()'''NewChainMapwithanewmapfollowedbyallpreviousmaps.Ifnomapisprovided,anemptydictisused.'''ifmisNone:m={}returnself.__class__(m,*self.maps)@propertydefparents(self):#likeDjango'sContext.pop()'NewChainMapfrommaps[1:].'returnself.__class__(*self.maps[1:])def__setitem__(self,key,value):self.maps[0][key]=valuedef__delitem__(self,key):try:delself.maps[0][key]exceptKeyError:raiseKeyError('Keynotfoundinthefirstmapping:{!r}'.format(key))defpopitem(self):'Removeandreturnanitempairfrommaps[0].RaiseKeyErrorismaps[0]isempty.'try:returnself.maps[0].popitem()exceptKeyError:raiseKeyError('Nokeysfoundinthefirstmapping.')defpop(self,key,*args):'Remove*key*frommaps[0]andreturnitsvalue.RaiseKeyErrorif*key*notinmaps[0].'try:returnself.maps[0].pop(key,*args)exceptKeyError:raiseKeyError('Keynotfoundinthefirstmapping:{!r}'.format(key))defclear(self):'Clearmaps[0],leavingmaps[1:]intact.'self.maps[0].clear()

UserDict

UserDict是MutableMapping和Mapping的子类，它继承了MutableMapping.update和Mapping.get两个重要的方法 。

应用案例

fromcollectionsimportUserDictclassDictKeyToStr(UserDict):def__missing__(self,key):ifisinstance(key,str):raiseKeyError(key)returnself[str(key)]def__contains__(self,key):returnstr(key)inself.datadef__setitem__(self,key,item):self.data[str(key)]=item#该函数可以不实现'''defget(self,key,default=None):try:returnself[key]exceptKeyError:returndefault'''

源码

classUserDict(MutableMapping):#Startbyfilling-outtheabstractmethodsdef__init__(*args,**kwargs):ifnotargs:raiseTypeError("descriptor'__init__'of'UserDict'object""needsanargument")self,*args=argsiflen(args)>1:raiseTypeError('expectedatmost1arguments,got%d'%len(args))ifargs:dict=args[0]elif'dict'inkwargs:dict=kwargs.pop('dict')importwarningswarnings.warn("Passing'dict'askeywordargumentisdeprecated",DeprecationWarning,stacklevel=2)else:dict=Noneself.data={}ifdictisnotNone:self.update(dict)iflen(kwargs):self.update(kwargs)def__len__(self):returnlen(self.data)def__getitem__(self,key):ifkeyinself.data:returnself.data[key]ifhasattr(self.__class__,"__missing__"):returnself.__class__.__missing__(self,key)raiseKeyError(key)def__setitem__(self,key,item):self.data[key]=itemdef__delitem__(self,key):delself.data[key]def__iter__(self):returniter(self.data)#Modify__contains__toworkcorrectlywhen__missing__ispresentdef__contains__(self,key):returnkeyinself.data#Now,addthemethodsindictsbutnotinMutableMappingdef__repr__(self):returnrepr(self.data)defcopy(self):ifself.__class__isUserDict:returnUserDict(self.data.copy())importcopydata=self.datatry:self.data={}c=copy.copy(self)finally:self.data=datac.update(self)returnc@classmethoddeffromkeys(cls,iterable,value=None):d=cls()forkeyiniterable:d[key]=valuereturnd

No.23 Python中的变量与垃圾回收机制

Python与Java的变量本质上不一样，Python的变量本事是个指针。当Python解释器执行number=1的时候，实际上先在内存中创建一个int对象，然后将number指向这个int对象的内存地址，也就是将number“贴”在int对象上，测试用例如下：

number=[1,2,3]demo=numberdemo.append(4)print(number)#[1,2,3,4]

==和is的区别就是前者判断的值是否相等，后者判断的是对象id值是否相等。

classPerson(object):passp_0=Person()p_1=Person()print(p_0isp_1)#Falseprint(p_0==p_1)#Falseprint(id(p_0))#2972754016464print(id(p_1))#2972754016408li_a=[1,2,3,4]li_b=[1,2,3,4]print(li_aisli_b)#Falseprint(li_a==li_b)#Trueprint(id(li_a))#2972770077064print(id(li_b))#2972769996680a=1b=1print(aisb)#Trueprint(a==b)#Trueprint(id(a))#1842179136print(id(b))#1842179136

Python有一个优化机制叫intern，像这种经常使用的小整数、小字符串，在运行时就会创建，并且全局唯一。

Python中的del语句并不等同于C++中的delete，Python中的del是将这个对象的指向删除，当这个对象没有任何指向的时候，Python虚拟机才会删除这个对象。

No.24 Python元类编程

property动态属性

classHome(object):def__init__(self,age):self.__age=age@propertydefage(self):returnself.__ageif__name__=='__main__':home=Home(21)print(home.age)#21

在Python中，为函数添加@property装饰器可以使得函数像变量一样访问。

getattr和getattribute函数的使用

getattr在查找属性的时候，找不到该属性就会调用这个函数。

classDemo(object):def__init__(self,user,passwd):self.user=userself.password=passwddef__getattr__(self,item):return'NotfindAttr.'if__name__=='__main__':d=Demo('Bob','123456')print(d.User)

getattribute在调用属性之前会调用该方法。

classDemo(object):def__init__(self,user,passwd):self.user=userself.password=passwddef__getattr__(self,item):return'NotfindAttr.'def__getattribute__(self,item):print('Hello.')if__name__=='__main__':d=Demo('Bob','123456')print(d.User)#Hello.#None

属性描述符

在一个类中实现__get__()、__set__()和__delete__()都是属性描述符。

数据属性描述符

importnumbersclassIntField(object):def__init__(self):self.v=0def__get__(self,instance,owner):returnself.vdef__set__(self,instance,value):if(notisinstance(value,numbers.Integral)):raiseValueError("Intvalueneed.")self.v=valuedef__delete__(self,instance):pass

非数据属性描述符

在Python的新式类中，对象属性的访问都会调用__getattribute__()方法，它允许我们在访问对象时自定义访问行为，值得注意的是小心无限递归的发生。__getattriubte__()是所有方法和属性查找的入口，当调用该方法之后会根据一定规则在__dict__中查找相应的属性值或者是对象，如果没有找到就会调用__getattr__()方法，与之对应的__setattr__()和__delattr__()方法分别用来自定义某个属性的赋值行为和用于处理删除属性的行为。描述符的概念在Python 2.2中引进，__get__()、__set__()、__delete__()分别定义取出、设置、删除描述符的值的行为。

值得注意的是，只要实现这三种方法中的任何一个都是描述符。

仅实现__get__（）方法的叫做非数据描述符，只有在初始化之后才能被读取。

同时实现__get__()和__set__()方法的叫做数据描述符，属性是可读写的。

属性访问的优先规则

对象的属性一般是在__dict__中存储，在Python中，__getattribute__()实现了属性访问的相关规则。

假定存在实例obj，属性number在obj中的查找过程是这样的：

搜索基类列表type(b).__mro__，直到找到该属性，并赋值给descr。

判断descr的类型，如果是数据描述符则调用descr.__get__(b, type(b))，并将结果返回。

如果是其他的（非数据描述符、普通属性、没找到的类型）则查找实例obj的实例属性，也就是obj.__dict__。

如果在obj.__dict__没有找到相关属性，就会重新回到descr的判断上。

如果再次判断descr类型为非数据描述符，就会调用descr.__get__(b, type(b))，并将结果返回，结束执行。

如果descr是普通属性，直接就返回结果。

如果第二次没有找到，为空，就会触发AttributeError异常，并且结束查找。

用流程图表示：

__new__()和__init__()的区别

__new__()函数用来控制对象的生成过程，在对象上生成之前调用。

__init__()函数用来对对象进行完善，在对象生成之后调用。

如果__new__()函数不返回对象，就不会调用__init__()函数。

自定义元类

在Python中一切皆对象，类用来描述如何生成对象，在Python中类也是对象，原因是它具备创建对象的能力。当Python解释器执行到class语句的时候，就会创建这个所谓类的对象。既然类是个对象，那么就可以动态的创建类。这里我们用到type()函数，下面是此函数的构造函数源码：

def__init__(cls,what,bases=None,dict=None):#knownspecialcaseoftype.__init__"""type(object_or_name,bases,dict)type(object)->theobject'stypetype(name,bases,dict)->anewtype#(copiedfromclassdoc)"""pass

由此可知，type()接收一个类的额描述返回一个类。

defbar():print("Hello...")user=type('User',(object,),{'name':'Bob','age':20,'bar':bar,})user.bar()#Hello...print(user.name,user.age)#Bob20

元类用来创建类，因为累也是对象。type()之所以可以创建类是由于tyep()就是个元类，Python中所有的类都由它创建。在Python中，我们可以通过一个对象的__class__属性来确定这个对象由哪个类产生，当Python创建一个类的对象的时候，Python将在这个类中查找其__metaclass__属性。如果找到了，就用它创建对象，如果没有找到，就去父类中查找，如果还是没有，就去模块中查找，一路下来还没有找到的话，就用type()创建。创建元类可以使用下面的写法：

classMetaClass(type):def__new__(cls,*args,**kwargs):returnsuper().__new__(cls,*args,**kwargs)classUser(metaclass=MetaClass):pass

使用元类创建API

元类的主要用途就是创建API，比如Python中的ORM框架。

Python领袖 Tim Peters ：

“元类就是深度的魔法，99%的用户应该根本不必为此操心。如果你想搞清楚究竟是否需要用到元类，那么你就不需要它。那些实际用到元类的人都非常清楚地知道他们需要做什么，而且根本不需要解释为什么要用元类。”

No.25 迭代器和生成器

当容器中的元素很多的时候，不可能全部读取到内存，那么就需要一种算法来推算下一个元素，这样就不必创建很大的容器，生成器就是这个作用。

Python中的生成器使用yield返回值，每次调用yield会暂停，因此生成器不会一下子全部执行完成，是当需要结果时才进行计算，当函数执行到yield的时候，会返回值并且保存当前的执行状态，也就是函数被挂起了。我们可以使用next()函数和send()函数恢复生成器，将列表推导式的[]换成()就会变成一个生成器：

my_iter=(xforxinrange(10))foriinmy_iter:print(i)

值得注意的是，我们一般不会使用next()方法来获取元素，而是使用for循环。当使用while循环时，需要捕获StopIteration异常的产生。

Python虚拟机中有一个栈帧的调用栈，栈帧保存了指定的代码的信息和上下文，每一个栈帧都有自己的数据栈和块栈，由于这些栈帧保存在堆内存中，使得解释器有中断和恢复栈帧的能力：

importinspectframe=Nonedeffoo():globalframeframe=inspect.currentframe()defbar():foo()bar()print(frame.f_code.co_name)#fooprint(frame.f_back.f_code.co_name)#bar

这也是生成器存在的基础。只要我们在任何地方获取生成器对象，都可以开始或暂停生成器，因为栈帧是独立于调用者而存在的，这也是协程的理论基础。

迭代器是一种不同于for循环的访问集合内元素的一种方式，一般用来遍历数据，迭代器提供了一种惰性访问数据的方式。

可以使用for循环的有以下几种类型：

·集合数据类型

·生成器，包括生成器和带有yield的生成器函数

这些可以直接被for循环调用的对象叫做可迭代对象，可以使用isinstance()判断一个对象是否为可Iterable对象。集合数据类型如list、dict、str等是Iterable但不是Iterator，可以通过iter()函数获得一个Iterator对象。send()和next()的区别就在于send()可传递参数给yield()表达式，这时候传递的参数就会作为yield表达式的值，而yield的参数是返回给调用者的值，也就是说send可以强行修改上一个yield表达式值。

感谢你能够认真阅读完这篇文章，希望小编分享关于Python的知识点有哪些内容对大家有帮助，同时也希望大家多多支持亿速云，关注亿速云行业资讯频道，遇到问题就找亿速云，详细的解决方法等着你来学习!