python 内置函数

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]: 3

In [2]: abs(-3)
Out[2]: 3

In [3]: abs(3.5)
Out[3]: 3.5

In [4]: abs(-3.5)
Out[4]: 3.5

In [5]: abs(1+1i)
File "<ipython-input-5-b4b3aaaa8901>", line 1
abs(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的类型
<class 'str'>

---

 

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

---

说明：

　　1. 接受一个可迭代对象（序列或者迭代器），返回一个可枚举对象（同时返回索引和值，其中索引可以指定起始值）。 

In [44]: seasons = ['Spring', 'Summer', 'Fall', 'Winter']

In [45]: enumerate(seasons)
Out[45]: <enumerate at 0x7f1de3a9ba20>

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)---返回布尔值

---

说明：

1. 函数功能用于判断对象是否是类型对象的实例，object参数表示需要检查的对象，calssinfo参数表示类型对象。
2. 如果object参数是classinfo类型对象(或者classinfo类对象的直接、间接、虚拟子类)的实例，返回True。

In [4]: demo_str = 'This is a demo'

In [5]: isinstance(demo_str,str)
Out[5]: True

In [6]: demo_list = [1,2,3,4]

In [7]: isinstance(demo_list,list)
Out[7]: True

In [8]: isinstance(demo_list,dict)
Out[8]: False

In [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]: True

In [27]: isinstance(a,B)
Out[27]: False

In [28]: isinstance(b,A)# 继承关系
Out[28]: True

In [29]: isinstance(c,A) # 继承关系
Out[29]: True 

　　3.如果object参数传入的是类型对象，则始终返回False。

In [30]: isinstance(list,list)# list为对象
Out[30]: False

In [31]: isinstance(dict,dict)
Out[31]: False

　　4. 如果classinfo类型对象，是多个类型对象组成的元组，如果object对象是元组的任一类型对象中实例，则返回True，否则返回False。

In [32]: num = 2

In [33]: isinstance(num,(int,str,dict,list)) # 任一即可 包含就可以
Out[33]: True

In [34]: isinstance(a,(B,C))
Out[34]: False

In [35]: isinstance(a,(A,B,C))
Out[35]: True

　　5.如果classinfo类型对象，不是一个类型对象或者由多个类型对象组成的元组，则会报错(TypeError)。

In [36]: num = 2

In [37]: isinstance(num,[int,str,list,dict])
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-37-506c051d46b7> in <module>()
----> 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>
AA
BB

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

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>
AA
18

　　假设现在要更改新定义一个类(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>
AA
18

【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__的实例化方法
Kevin
18
男

总结：根据上述的方式主要是注意在我们使用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.sayHello
B.sayHello
A.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.sayHello
B.sayHello
A.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.sayHello
A.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.sayHello
Traceback (most recent call last):
  File "<pyshell#81>", line 1, in <module>
    C.sayHello()
  File "<pyshell#80>", 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 Iterable

In [9]: isinstance(zip_l,Iterable)
Out[9]: True

In [10]: for j,k in zip_l:
   ....:     print(j,k)
   ....:     
1 4
2 5
3 6

In [11]: list(zip_l)
Out[11]: []  # 返回的是迭代器。

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

In [22]: l_s = [1,2,3] # 长度为3

In [23]: l_l = [4,5,6,7] # 长度为4

In [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*3

In [30]: ll
Out[30]: [1, 2, 3, 1, 2, 3, 1, 2, 3]

In [31]: lll = [l]*3

In [32]: lll
Out[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]: <zip at 0x7fa3da1b6748>

In [38]: list(zip(l,ll))
Out[38]: [(1, 4), (2, 5), (3, 6)]

In [39]: zip(*zip(l,ll))
Out[39]: <zip at 0x7fa3da1b69c8>

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]: a
Out[42]: (1, 2, 3)

In [43]: b
Out[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]: <zip at 0x7f12da19b308>

In [24]: list(zip(*ll))
Out[24]: [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

In [25]: map(list,zip(*ll))
Out[25]: <map at 0x7f12da1a3390>

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]: <zip at 0x7f12da404388>

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]: <zip at 0x7f12da188188>

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]: <zip at 0x7f12da188dc8>

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]: <zip at 0x7f12da235408>

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]: <zip at 0x7f12da234108>

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]: mi
Out[96]: {1: 'a', 2: 'b', 3: 'c', 4: 'd'}