python 内置函数

阅读量：4540 次

发布时间：2019-06-08

本文共 13223 字，大约阅读时间需要 44 分钟。

Python内置函数的应用以及介绍

官方文档：https://docs.python.org/3.6/library/functions.html

Built-in Functions
abs()	delattr()	hash()	memoryview()	set()
all()

Python内置函数-abs(x)---返回数值的绝对值

abs(x)

　　Return the absolute value of a number. The argument may be an integer or a floating point number. If the argument is a complex number, its magnitude is returned.

说明：

　　返回值：返回数字的绝对值

　　参数：数字，浮点，复数

示例：
In [1]: abs(3) Out[1]: 3In [2]: abs(-3)Out[2]: 3In [3]: abs(3.5)Out[3]: 3.5In [4]: abs(-3.5)Out[4]: 3.5In [5]: abs(1+1i)File "
      
       ", line 1abs(1+1i)^SyntaxError: invalid syntax正确的写法：　In [6]: cobj = complex(1,2) # 创建一个复数的对象　In [7]: cobj　Out[7]: (1+2j)　In [8]: abs(cobj) # 复数　Out[8]: 2.23606797749979
      

Python内置函数bin(x) 返回一个整数 int 或者长整数 long int 的二进制表示。

说明：

bin(int/long int) 返回一个整数 int 或者长整数 long int 的二进制表示。

　　1.将整形数字转化为二进制的字符串
>>> b = bin(3) >>> b'0b11'>>> type(b) #获取b的类型
      
---

Python内置函数-enumerate(iterable.start=0)

说明：

　　1. 接受一个可迭代对象（序列或者迭代器），返回一个可枚举对象（同时返回索引和值，其中索引可以指定起始值）。
In [44]: seasons = ['Spring', 'Summer', 'Fall', 'Winter']In [45]: enumerate(seasons)Out[45]: 
      
       In [46]: for i in enumerate(seasons):   ....:     print(i)   ....:     (0, 'Spring')(1, 'Summer')(2, 'Fall')(3, 'Winter')In [47]: list(enumerate(seasons))Out[47]: [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]In [48]: list(enumerate(seasons,start=2))Out[48]: [(2, 'Spring'), (3, 'Summer'), (4, 'Fall'), (5, 'Winter')]
      
In [53]: for i in enumerate('python'):
....: print(i)
....:
(0, 'p')
(1, 'y')
(2, 't')
(3, 'h')
(4, 'o')
(5, 'n')
Equivalent to:
In [54]: def enumerate(sequence, start=0):   ....:         n = start   ....:         for elem in sequence:   ....:                 yield n, elem   ....:                 n += 1
-------

Python内置函数-isinstance(object,classinfo)---返回布尔值

说明：

函数功能用于判断对象是否是类型对象的实例，object参数表示需要检查的对象，calssinfo参数表示类型对象。

如果object参数是classinfo类型对象(或者classinfo类对象的直接、间接、虚拟子类)的实例，返回True。
In [4]: demo_str = 'This is a demo'In [5]: isinstance(demo_str,str)Out[5]: TrueIn [6]: demo_list = [1,2,3,4]In [7]: isinstance(demo_list,list)Out[7]: TrueIn [8]: isinstance(demo_list,dict)Out[8]: FalseIn [20]: class A:   ....:     pass   ....: In [21]: class B(A):   ....:     pass   ....: In [22]: class C(B):   ....:     pass   ....: In [23]: a=A()In [24]: b=B()In [25]: c=C()In [26]: isinstance(a,A) Out[26]: TrueIn [27]: isinstance(a,B)Out[27]: FalseIn [28]: isinstance(b,A)# 继承关系Out[28]: TrueIn [29]: isinstance(c,A) # 继承关系Out[29]: True 
　　3.如果object参数传入的是类型对象，则始终返回False。
In [30]: isinstance(list,list)# list为对象Out[30]: FalseIn [31]: isinstance(dict,dict)Out[31]: False
　　4. 如果classinfo类型对象，是多个类型对象组成的元组，如果object对象是元组的任一类型对象中实例，则返回True，否则返回False。
In [32]: num = 2In [33]: isinstance(num,(int,str,dict,list)) # 任一即可 包含就可以Out[33]: TrueIn [34]: isinstance(a,(B,C))Out[34]: FalseIn [35]: isinstance(a,(A,B,C))Out[35]: True
　　5.如果classinfo类型对象，不是一个类型对象或者由多个类型对象组成的元组，则会报错(TypeError)。
In [36]: num = 2In [37]: isinstance(num,[int,str,list,dict])---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)
      
        in 
       
        ()----> 1 isinstance(num,[int,str,list,dict])TypeError: isinstance() arg 2 must be a type or tuple of types
       
      

Python内置函数--super()

说明：

　　super() 函数是用于调用父类(超类)的一个方法。

　　super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

　　MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

【1】最早之前，在子类(B)中调用父类(A)的方法采用的方式如下：

In [7]: class A:   ...:     def __init__(self):   ...:         print('A.__init__')   ...:         In [8]: a = A()A.__init__In [9]: class B(A):   ...:     def __init__(self):   ...:         print('B.__init__')   ...:         A.__init__(self)   ...:         In [10]: b = B()B.__init__A.__init__

实例分析：

class A:    def __init__(self):        self.A = 'AA'        print('A.__init__的实例化方法')class B(A):    def __init__(self):        self.B = 'BB'        A.__init__(self)        print('B.__init__的实例化方法')Bb = B()print(Bb)print(Bb.A) print(Bb.B)-------------------------A.__init__的实例化方法B.__init__的实例化方法<__main__.B object at 0x000001FDEB7571D0>AABB

　　当在初始化传入参数的时候

class A:    def __init__(self,name):        self.name = 'AA'        print('A.__init__的实例化方法')class B(A):    def __init__(self,name,age):        self.age = 18        A.__init__(self,name)        # super(B,self).__init__(name)        print('B.__init__的实例化方法')Bb = B('A','B')print(Bb)print(Bb.name)print(Bb.age)--------------------------------A.__init__的实例化方法B.__init__的实例化方法<__main__.B object at 0x000001FB9C4C1208>AA18

　　假设现在要更改新定义一个类(A1)，并更改继承关系(B->A改成B->A1)，则需要所有类中做如下修改：

#定义新的父类A1>>> class A1(object):    def __init__(self):        print('A1.__init__')#更改继承关系B->A改成B->A1>>> class B(A1):    def __init__(self):        print('B.__init__')        A1.__init__(self)#能正确调用新的父类A1的__init__方法>>> b = B()B.__init__A1.__init__#假设忘了修改A.__init__(self)>>> class B(A1):    def __init__(self):        print('B.__init__')        A.__init__(self)      #则还是调用了A的__init__方法>>> b = B()B.__init__A.__init__

【2】引入super之后，不需要显示指定父类的类名，增强了程序的可维护性，但是这种方式适用于单继承

class A:    def __init__(self,name):        self.name = 'AA'        print('A.__init__的实例化方法')class B(A):    def __init__(self,name,age):        self.age = 18        # A.__init__(self,name)        super().__init__(name) # 不带任何参数的super等效于super(类名,self)，此种情况多用于单继承关系的子类中。        # super(B,self).__init__(name)        print('B.__init__的实例化方法')Bb = B('A','B')print(Bb)print(Bb.name)print(Bb.age)----------------------------A.__init__的实例化方法B.__init__的实例化方法<__main__.B object at 0x000001BB73261240>AA18

【3】如果第2个参数是一个对象，则对象必须是第1个参数指定类型的实例，此种关系多用于多层继承关系的子类中。

#定义父类A>>> class A(object):    def __init__(self):        print('A.__init__')#定义子类B，继承A，__init__中调用父类的__init__方法>>> class B(A):    def __init__(self):        print('B.__init__')        super().__init__()#定义子类C，继承B，__init__中调用父类的__init__方法        >>> class C(B):    def __init__(self):        print('C.__init__')        super().__init__()#实例化C时，执行C的__init__方法，调用直接父类B的__init__方法，又进一步调用间接父类A的__init__方法>>> c = C()C.__init__B.__init__A.__init__#重新定义子类C，继承关系不变，调用父类方法__init__时改用super(B,self)>>> class C(B):    def __init__(self):        print('C.__init__')        super(B,self).__init__()#实例化C时，执行C的__init__方法，super(B,self)代理找到B的父类A，将self转换成B的实例，直接调用了A的__init__方法，跳过了调用B的__init__方法>>> c = C()C.__init__A.__init__

　　当在初始化函数中有参数的时候

class A:    def __init__(self,name):        self.name = 'Kevin'        print('A.__init__的实例化方法')class B(A):    def __init__(self,name,age):        self.age = 18        # A.__init__(self,name)        # super().__init__(name)        super(B,self).__init__(name)        print('B.__init__的实例化方法') #实例化C时，执行C的__init__方法，调用直接父类B的__init__方法，又进一步调用间接父类A的__init__方法class C(B):    def __init__(self,name,age,sex):        self.sex = '男'        print('C.__init__')        super().__init__(name,age)------------------------------------ Cc = C('A','B','C')print(Cc.name)print(Cc.age)print(Cc.sex)# 输出C.__init__A.__init__的实例化方法B.__init__的实例化方法Kevin18男

总结：根据上述的方式主要是注意在我们使用super()传入参数的时候。应该分析在整个类继承的整个过程。

class C(B):    def __init__(self,name,sex):        self.sex = '男'        print('C.__init__')        super(B,self).__init__(name) # 实际上是继承了A的初始化方法----------------------------------------------------C.__init__A.__init__的实例化方法Kevin男

【4】如果第2个参数时一个类型，则类型必须是第1个参数指定类型的子类，此种关系多用于多层继承关系的子类中，适用于类方法。

#定义父类A，并定义有一个类方法sayHello>>> class A(object):    @classmethod    def sayHello(cls):        print('A.sayHello')# 定义子类B，继承A，重写类方法sayHello，在其中调用父类的sayHello方法>>> class B(A):    @classmethod    def sayHello(cls):        print('B.sayHello')        super().sayHello()# 定义子类C，继承B，重写类方法sayHello，在其中调用父类的sayHello方法>>> class C(B):    @classmethod    def sayHello(cls):        print('C.sayHello')        super().sayHello()#调用C的类方法sayHello，其调用C的直接父类B的类方法sayHello，调用时B的sayHello方法又调用B的直接父类A的类方法sayHello>>> C.sayHello()C.sayHelloB.sayHelloA.sayHello#重新定义类C，继承关系不变，使用super(C,C)的方式调用父类方法>>> class C(B):    @classmethod    def sayHello(cls):        print('C.sayHello')        super(C,C).sayHello()#调用C的类方法sayHello，super(C,C)代理对象，找到C的直接父类B，然后调用C的直接父类B的类方法sayHello，调用时B的sayHello方法又调用B的直接父类A的类方法sayHello>>> C.sayHello()C.sayHelloB.sayHelloA.sayHello#重新定义类C，继承关系不变，使用super(B,C)的方式调用父类方法>>> class C(B):    @classmethod    def sayHello(cls):        print('C.sayHello')        super(B,C).sayHello()#调用C的类方法sayHello，super(B,C)代理对象，找到B的直接父类A，然后调用B的直接父类A的类方法sayHello，中间不会调用B的sayHello方法>>> C.sayHello()C.sayHelloA.sayHello#定义一个新类D，和A、B、C无继承关系>>> class D(object):    @classmethod    def sayHello(cls):        print('D.sayHello')#重新定义类C，继承关系不变，使用super(D,C)的方式调用父类方法>>> class C(B):    @classmethod    def sayHello(cls):        print('C.sayHello')        super(D,C).sayHello()#调用C的类方法sayHello，super(D,C)代理对象，找到B的直接父类object，然后将C转换成D类，转换失败调用出错>>> C.sayHello()C.sayHelloTraceback (most recent call last):  File "
      
       ", line 1, in 
       
            C.sayHello()  File "
        
         ", line 5, in sayHello    super(D,C).sayHello()TypeError: super(type, obj): obj must be an instance or subtype of type

Python内置函数--zip()

说明：

　　zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

语法：

zip(iterable1,iterable2, ...)

参数：

iterable -- 一个或多个可迭代对象（字符串、列表、元祖、字典）

返回值：

　　Python2中直接返回一个由元组组成的列表，Python3中返回的是一个对象，如果想要得到列表，可以用 list() 函数进行转换。

实例：

　　函数功能是聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器。

In [5]: l = [1,2,3]In [6]: ll = [4,5,6]In [7]: zip_l = zip(l,ll)In [8]: from collections import IterableIn [9]: isinstance(zip_l,Iterable)Out[9]: TrueIn [10]: for j,k in zip_l:   ....:     print(j,k)   ....:     1 42 53 6In [11]: list(zip_l)Out[11]: []  # 返回的是迭代器。

如果传入的迭代器长度不一致，最短长度的迭代器迭代结束后停止聚合。

In [22]: l_s = [1,2,3] # 长度为3In [23]: l_l = [4,5,6,7] # 长度为4In [24]: list(zip(l_s,l_l))Out[24]: [(1, 4), (2, 5), (3, 6)] # 输出的值是以长度比较短的值进行的。

如果只传入一个迭代器，则返回的单个元素元组的迭代器。

In [25]: list(zip([1,2,3]))Out[25]: [(1,), (2,), (3,)]

如果不传入参数，则返回空的迭代器。

In [26]: list(zip())Out[26]: []

zip(*[iter(s)]*n)等效于调用zip(iter(s),iter(s),...,iter(s))。

In [28]: l = [1,2,3]In [29]: ll = l*3In [30]: llOut[30]: [1, 2, 3, 1, 2, 3, 1, 2, 3]In [31]: lll = [l]*3In [32]: lllOut[32]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]In [33]: list(zip(*[l]*3))Out[33]: [(1, 1, 1), (2, 2, 2), (3, 3, 3)]In [34]: list(zip(l,l,l))Out[34]: [(1, 1, 1), (2, 2, 2), (3, 3, 3)]

与 zip 相反，*zip 可理解为解压，返回二维矩阵式

In [35]: l = [1,2,3]In [36]: ll = [4,5,6]In [37]: zip(l,ll)Out[37]: 
      
       In [38]: list(zip(l,ll))Out[38]: [(1, 4), (2, 5), (3, 6)]In [39]: zip(*zip(l,ll))Out[39]: 
       
        In [40]: list(zip(*zip(l,ll)))Out[40]: [(1, 2, 3), (4, 5, 6)]In [41]: a,b = list(zip(*zip(l,ll)))In [42]: aOut[42]: (1, 2, 3)In [43]: bOut[43]: (4, 5, 6)In [44]: list(a)Out[44]: [1, 2, 3]In [45]: list(b)Out[45]: [4, 5, 6]

zip的高级应用

转换二维数组

In [20]: ll = [[1,2,3],[4,5,6],[7,8,9]]In [21]: [ [row[col] for row in ll] for col in range(len(ll[0]))]Out[21]: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

使用zip(*)进行转换

In [22]: ll = [[1,2,3],[4,5,6],[7,8,9]]In [23]: zip(*ll)Out[23]: 
      
       In [24]: list(zip(*ll))Out[24]: [(1, 4, 7), (2, 5, 8), (3, 6, 9)]In [25]: map(list,zip(*ll))Out[25]: 
       In [26]: list(map(list,zip(*ll)))Out[26]: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

　　使用zip合并相邻的列表项

In [42]: a = [1, 2, 3, 4, 5, 6]In [43]: zip(*([iter(a)] * 2))Out[43]: 
      
       In [44]: list(zip(*([iter(a)] * 2)))Out[44]: [(1, 2), (3, 4), (5, 6)]

　　合并列表式的一个推导式

In [71]: group_adjacent = lambda a, k: zip(*([iter(a)] * k))In [72]: group_adjacent(a, 3)Out[72]: 
      
       In [73]: list(group_adjacent(a, 3))Out[73]: [(1, 2, 3), (4, 5, 6)]In [74]: list(group_adjacent(a, 2))Out[74]: [(1, 2), (3, 4), (5, 6)]In [75]: list(group_adjacent(a, 1))Out[75]: [(1,), (2,), (3,), (4,), (5,), (6,)]

　　--------

In [76]: zip(a[::2], a[1::2])Out[76]: 
      
       In [77]: list(zip(a[::2], a[1::2]))Out[77]: [(1, 2), (3, 4), (5, 6)]In [78]: zip(a[::3], a[1::3], a[2::3])Out[78]: 
       
        In [79]: list(zip(a[::3], a[1::3], a[2::3]))Out[79]: [(1, 2, 3), (4, 5, 6)]

-------

In [80]: group_adjacent = lambda a, k: zip(*(a[i::k] for i in range(k)))In [81]: list(group_adjacent(a, 3))Out[81]: [(1, 2, 3), (4, 5, 6)]In [82]: list(group_adjacent(a, 2))Out[82]: [(1, 2), (3, 4), (5, 6)]In [83]: list(group_adjacent(a, 1))Out[83]: [(1,), (2,), (3,), (4,), (5,), (6,)]

使用zip和iterators生成滑动窗口 (n -grams)

In [85]: def n_grams(a, n):   ....:      z = (islice(a, i, None) for i in range(n))   ....:      return zip(*z)   ....: In [86]: a = [1, 2, 3, 4, 5, 6]In [87]: list(n_grams(a, 3))Out[87]: [(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6)]In [88]: list(n_grams(a, 2))Out[88]: [(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]In [89]: list(n_grams(a, 1))Out[89]: [(1,), (2,), (3,), (4,), (5,), (6,)]In [90]: list(n_grams(a, 4))Out[90]: [(1, 2, 3, 4), (2, 3, 4, 5), (3, 4, 5, 6)]

使用zip反转字典

In [91]: m = {
    'a': 1, 'b': 2, 'c': 3, 'd': 4}In [92]: m.items()Out[92]: dict_items([('d', 4), ('c', 3), ('b', 2), ('a', 1)])In [93]: zip(m.values(), m.keys())Out[93]: 
      
       In [94]: list(zip(m.values(), m.keys())In [94]: list(zip(m.values(), m.keys()))Out[94]: [(4, 'd'), (3, 'c'), (2, 'b'), (1, 'a')]In [95]: mi = dict(zip(m.values(), m.keys()))In [96]: miOut[96]: {1: 'a', 2: 'b', 3: 'c', 4: 'd'}