python的内置函数

Duang！

官方文档：https://docs.python.org/3/library/functions.html#abs

68个内置函数

分类记忆

数学运算 × 7
abs() 、 divmod() 、 max() 、 min() 、pow() 、round() 、sum()
类型转换 × 24
bool() 、 int() 、 float() 、 complex() 、str() 、 ord() 、 chr() 、 bytearray() 、 bytes() 、 memoryview() 、 bin() 、 oct() 、 hex() 、 tuple() 、 list() 、 dict() 、 set() 、 frozenset()、 enumerate() 、 range() 、 iter() 、 slice() 、super() 、object()
序列操作 × 8
all() 、any() 、 filter() 、 map() 、next() 、reversed() 、sorted() 、zip()
对象操作 × 9
help() 、dir() 、 id() 、hash() 、type() 、len() 、ascii() 、format() 、vars()
反射操作 × 8
Import() 、isinstance() 、issubclass() 、hasattr() 、getattr() 、setattr() 、delattr() 、callable()
变量操作 × 2
globals() 、locals()
交互操作 × 2
print()、input()
文件操作 × 1
open()
编译执行 × 4
compile() 、eval() 、exec() 、repr()
装饰器 × 3
property() 、 classmethod() 、staticmethod()

1、 abs() 取绝对值

>>> abs(-5.24)
5.24

2、 all() 用于判断给定的可迭代参数中的所有元素是否都为True。若括号内存在为 0、空（’’）、None、False的元素，返回False。

#注：空元组、空列表返回值为True
>>> all([]) # 空列表
True
>>> all(()) # 空元组
True

>>> all(['a', 'b', 'c', 'd'])  #列表list，元素都不为 0、''、None、False
True
>>> all(['a', 'b', '', 'd'])   #列表list，存在一个为空的元素
False
>>> all([0, 1，2, 3])          #列表list，存在一个为0的元素
False

>>> all(('a', 'b', 'c', 'd'))  #元组tuple，元素都不为 0、''、None、False
True
>>> all(('a', 'b', '', 'd'))   #元组tuple，存在一个为空的元素
False
>>> all((0, 1，2, 3))          #元组tuple，存在一个为0的元素
False

3、 any() 用于判断给定的可迭代参数中是否有为True值的元素。若括号内所有元素都是 0、空（’’）、None、False，返回False。

>>> any([]) # 空列表
False
>>> any(()) # 空元组
False

>>> any(['a', 'b', 'c', 'd'])  #列表list，元素都不为 0、''、None、False
True
>>> any(['a', 'b', '', 'd'])   #列表list，存在一个为空的元素
True
>>> any([0, '', False])        #列表list，元素全为 0、''、None、False
False

>>> any(('a', 'b', 'c', 'd'))  #元组tuple，元素都不为 0、''、None、False
True
>>> any(('a', 'b', '', 'd'))   #元组tuple，存在一个为空的元素
True
>>> any((0, '', False))        #元组tuple，元素全为 0、''、None、False
False

4、 ascii() 返回一个可打印的对象字符串方式表示，若是非ascii字符就会输出\x，\u或\U等字符来表示。（与python2版本里的repr()是等效的函数）

>>> ascii(524)
'524'
>>> ascii('￥')
"'￥'"
>>> ascii('我是沙雕')   #非ascii字符
"'\\u6211\\u662f\\u6c99\\u96d5'"

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

>>>bin(10)
'0b1010'
>>> bin(20)
'0b10100'

6、 bool() 用于将给定参数转换为布尔类型，如果没有参数，返回 False。

>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
>>> issubclass(bool, int)  # bool 是 int 子类
True

7、 bytearray() 返回一个新的字节数组。bytearray类是range 0 ≤ x ≤ 256的一个可变序列。

>>> b = bytearray()
>>> b
bytearray(b'')
>>> len(b)
0
#当source参数为字符串时，encoding参数也必须提供，函数将字符串使用str.encode方法转换成字节数组
>>> bytearray('中文')
Traceback (most recent call last):
 File "<pyshell#48>", line 1, in <module>
   bytearray('中文')
TypeError: string argument without an encoding
>>> bytearray('中文','utf-8')
bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

#当source参数为整数时，返回这个整数所指定长度的空字节数组
>>> bytearray(2)
bytearray(b'\x00\x00')
>>> bytearray(-2) #整数需大于0，使用来做数组长度的
Traceback (most recent call last):
 File "<pyshell#51>", line 1, in <module>
   bytearray(-2)
   
#当source参数是一个可迭代对象，那么这个迭代对象的元素都必须符合 0 ≤ x ≤ 256，以便可以初始化到数组里
>>> bytearray([1,2,3])
bytearray(b'\x01\x02\x03')
>>> bytearray([256,2,3]) #不在0-255范围内报错
Traceback (most recent call last):
 File "<pyshell#53>", line 1, in <module>
   bytearray([256,2,3])
ValueError: byte must be in range(0, 256)

8、 bytes()　　将一个字符串转换成字节类型复制代码

>>> s = 'python'
>>> x = bytes(s, encoding='utf-8')
>>> x
 b'python'
>>> a = '王'
>>> s = bytes(a, encoding='utf-8')
>>> s
 b'\xe7\x8e\x8b'

9、 callable()　判断对象是否可以被调用，能被调用的对象就是一个callables对象

>>> callable(max)
True
>>> callable([1, 2, 3])
False
>>> callable(None)
False
>>> callable('str')
False

10、 chr()　　用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符

>>>print chr(0x30), chr(0x31), chr(0x61)    # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97)         # 十进制
0 1 a

11、 classmethod()　　用来指定一个方法为类的方法，由类直接调用执行，只有一个cls参数,执行雷的方法时，自动将调用该方法的类赋值给cls.没有此参数指定的类的方法为实例方法。

class Province:
     country = "中国"
     def __init__(self, name):
           self.name = name
       
     @classmethod
     def show(cls):  # 类方法，由类调用，最少要有一个参数cls，调用的时候这个参数不用传值，自动将类名赋值给cls
         print(cls)
       
 # 调用方法
 Province.show()

12、complie()　　将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译
1） compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
2） 将source编译为代码或者AST对象。代码对象能过通过exec语句来执行或者eval()进行求值。
3） 参数source：字符串或者AST（abstract syntax trees）对象。
4） 参数filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
5）参数model：指定编译代码的种类。可以指定’exec’, ‘eval’, ‘single’。
6）参数flag和dont_inherit：这两个参数为可选参数。

>>> s  = "print('helloworld')"
>>> r = compile(s, "<string>", "exec")
>>> r
<code object <module> at 0x000001C648038390, file "<string>", line 1>

13、 complex() 用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。

>>>complex(1, 2)
(1 + 2j)
  
>>> complex(1)    # 数字
(1 + 0j)
  
>>> complex("1")  # 当做字符串处理
(1 + 0j)
  
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)

14、 delattr()　用于删除属性

class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
 
print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z)
 
delattr(Coordinate, 'z')
 
print('--删除 z 属性后--')
print('x = ',point1.x)
print('y = ',point1.y)
 
#触发错误
print('z = ',point1.z)
#输出
('x = ', 10)
('y = ', -5)
('z = ', 0)
--删除 z 属性后--
('x = ', 10)
('y = ', -5)
Traceback (most recent call last):
  File "test.py", line 22, in <module>
    print('z = ',point1.z)
AttributeError: Coordinate instance has no attribute 'z'

15、 dict() 根据传入的参数创建一个新的字典

>>> dict() # 不传入任何参数时，返回空字典
{}
>>> dict(a = 1,b = 2) #  可以传入键值对创建字典
{'b': 2, 'a': 1}
>>> dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典
{'b': 2, 'a': 1}
>>> dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典
{'b': 2, 'a': 1}

16、 dir() 不带参数时返回当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表。

>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'li', 'li1', 'li2', 'li_1']
>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

17、 divmod()　　分别取商和余数

>>> divmod(20,6)
(3, 2)

18、 enumerate() 根据可迭代对象创建枚举对象

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1)) #指定起始值
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

19、 eval() 用来执行一个字符串表达式，并返回表达式的值。将字符串str当成有效的表达式来求值并返回计算结果。
eval(expression[, globals[, locals]])
expression – 表达式。
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85

20、 exec() 动态执行python代码。也就是说exec可以执行复杂的python代码，而不像eval函数那样只能计算一个表达式的值。
eval()函数和exec()函数的区别：
eval()函数只能计算单个表达式的值，而exec()函数可以动态运行代码段。
eval()函数可以有返回值，而exec()函数返回值永远为None。

>>>x = 10
>>>expr = """
>>>z = 30
>>>sum = x + y + z
>>>print(sum)
>>>"""
>>>def func():
>>>    y = 20
>>>    exec(expr)
>>>    exec(expr, {'x': 1, 'y': 2})
>>>    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
>>> func()
60
33
34

21、 filter()　　过滤器，构造一个序列，等价于[ item for item in iterables if function(item)]，在函数中设定过滤条件，逐一循环迭代器中的元素，将返回值为True时的元素留下，形成一个filter类型数据。

filter(function, iterable)
参数function：返回值为True或False的函数，可以为None。
参数iterable：序列或可迭代对象。
>>> def bigerthan5(x):
...     return x > 5
>>> filter(bigerthan5, [3, 4, 5, 6, 7, 8])
[6, 7, 8]

22、 float()　　讲一个字符串或整数转换为浮点数

>>> float()
0.0
>>> float('123')
123.0
>>> float(1)
1.0
>>> float('a')
Traceback (most recent call last):
  File "<pyshell#45>", line 1, in <module>
    float('a')
ValueError: could not convert string to float: 'a'

23、 format()　　格式化输出字符串，format(value, format_spec)实质上是调用了value的__format__(format_spec)方法

>>> "I am {0}, I like {1}!".format("wang", "moon")    
 'I am wang, I like moon!'

24、 frozenset()　　创建一个不可修改的集合

>>> a = frozenset(range(10))
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

25、 getattr()　　获取对象的属性
getattr(object, name [, defalut]) 获取对象object名为name的特性，如果object不包含名为name的特性，将会抛AttributeError异常；如果不包含名为name的特性且提供default参数，将返回default。
object：对象
name：对象的特性名
default：缺省返回值

>>> append = getattr(list, 'append')
>>> append
<method 'append' of 'list' objects>
>>> mylist = [3, 4, 5]
>>> append(mylist, 6)
>>> mylist
[3, 4, 5, 6]
>>> method = getattr(list, 'add')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'list' has no attribute 'add'
>>> method = getattr(list, 'add', 'NoMethod')
>>> method
'NoMethod'

26、 globals()　　返回一个描述当前全局变量的字典

>>> a = 1
>>>> globals()
 {'__loader__': <class '_frozen_importlib.BuiltinImporter'>, 'a': 1, '__builtins__': <module 'builtins' (built-in)>, '__doc__': None, '__name__': '__main__', '__package__': None, '__spec__': None}

27、 hasattr()
hasattr(object，name) 判断对象object是否包含名为name的特性（hasattr是通过调用getattr(object，name)）是否抛出异常来实现的。
参数object：对象
参数name：特性名称

 >>> hasattr(list, 'append')
 True
 >>> hasattr(list, 'add')
 False

28、 hash() 获取对象的哈希值
hash(object) 如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数，在字典查找中，哈希值用于快递比价字典的键。两个数值如果相等，则哈希值也相等。

>>> hash('good good study')
1032709256

29、 help() 返回对象的帮助信息

>>> help(str) 
Help on class str in module builtins:
class str(object)
   str(object='') -> str
   str(bytes_or_buffer[, encoding[, errors]]) -> str
   
   Create a new string object from the given object. If encoding or
   errors is specified, then the object must expose a data buffer
   that will be decoded using the given encoding and error handler.
   Otherwise, returns the result of object.__str__() (if defined)
   or repr(object).
   encoding defaults to sys.getdefaultencoding().
   errors defaults to 'strict'.
   
   Methods defined here:
   
  __add__(self, value, /)
      Return self+value.

30、hex() 用于将10进制整数转换成16进制，以字符串形式表示。

>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
>>> hex(12)
'0xc'
>>> type(hex(12))
<class 'str'>      # 字符串

31、 id() 返回对象的唯一标识符

>>> a = 'some text'
>>> id(a)
69228568

32、 input() 获取用户输入内容

 num = input("请输入一个数字：")
 # 用户输入3
 print(num)
 # 输出结果
 3

33、 int()　　将一个字符串或数值转换为一个普通整数
int([x[,radix]]) 如果参数是字符串，那么它可能包含符号和小数点。参数radix表示转换的基数（默认是10进制）。 它可以是[2,36]范围内的值，或者0。如果是0，系统将根据字符串内容来解析。如果提供了参数radix，但参数x并不是一个字符串，将抛出TypeError异常；否则，参数x必须是数值（普通整数，长整数，浮点数）。通过舍去小数点来转换浮点数。如果超出了普通整数的表示范围，一个长整数被返回。如果没有提供参数，函数返回0。

>>>int()
0
>>>int(3.1)
3

34、 isinstance()　　检查对象是否是类的对象，返回True或False

>>> isinstance(1,int)
True
>>> isinstance(1,str)
False
>>> isinstance(1,(int,str))
True

35、 issubclass() 判断类是否是另外一个类或者类型元组中任意类元素的子类

>>> issubclass(bool,int)
True
>>> issubclass(bool,str)
False
>>> issubclass(bool,(str,int))
True

36、 iter() 用来生成迭代器

>>>lst = [1, 2, 3]
>>> for i in iter(lst):
...     print(i)
... 
1
2
3

37、 len() 返回对象的长度

>>> len('abcd') # 字符串
>>> len(bytes('abcd','utf-8')) # 字节数组
>>> len((1,2,3,4)) # 元组
>>> len([1,2,3,4]) # 列表
>>> len(range(1,5)) # range对象
>>> len({'a':1,'b':2,'c':3,'d':4}) # 字典
>>> len({'a','b','c','d'}) # 集合
>>> len(frozenset('abcd')) #不可变集合

38、 list() 根据传入的参数创建一个新的列表

>>>list() # 不传入参数，创建空列表
[] 
>>> list('abcd') # 传入可迭代对象，使用其元素创建新的列表
['a', 'b', 'c', 'd']

39、 locals() 返回当前作用域内的局部变量和其值组成的字典

>>> def f():
    print('before define a ')
    print(locals()) #作用域内无变量
    a = 1
    print('after define a')
    print(locals()) #作用域内有一个a变量，值为1    
>>> f
<function f at 0x03D40588>
>>> f()
before define a 
{} 
after define a
{'a': 1}

40、 map() 使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象

>>> a = map(ord,'abcd')
>>> a
<map object at 0x03994E50>
>>> list(a)
[97, 98, 99, 100]

41、 max() 返回可迭代对象中的元素中的最大值或者所有参数的最大值。

>>> max(1,2,3) # 传入3个参数 取3个中较大者
3
>>> max('1234') # 传入1个可迭代对象，取其最大元素值
'4'
>>> max(-6,3,key = abs) # 求绝对值函数，则比较参数绝对值大小后，再取较大者
-6

42、 memoryview() 根据传入的参数创建一个新的内存查看对象。

>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103

43、 min() 返回可迭代对象中的元素中的最小值或者所有参数的最小值

>>> min(1,2,3)    # 传入3个参数 取3个中较小者
1
>>> min('1234')   # 传入1个可迭代对象，取其最小元素值
'1'
>>> min(-1,-2,key = abs)  # 传入求绝对值函数，比较参数绝对值大小后，取较小者
-1

44、 next() 返回可迭代对象中的下一个元素值

>>> a = iter('abcd')
>>> next(a)
'a'
>>> next(a)
'b'
>>> next(a)
'c'
>>> next(a)
'd'
>>> next(a)
Traceback (most recent call last):
  File "<pyshell#18>", line 1, in <module>
    next(a)
StopIteration
#传入default参数后，如果可迭代对象还有元素没有返回，则依次返回其元素值，如果所
有元素已经返回，则返回default指定的默认值而不抛出StopIteration 异常
>>> next(a,'e')
'e'
>>> next(a,'e')
'e'

45、 object() 创建一个新的object对象

>>> a = object()
>>> a.name = 'kim' # 不能设置属性
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    a.name = 'kim'
AttributeError: 'object' object has no attribute 'name'

46、 oct() 将整数转化成8进制数字符串

>>> oct(10)
'0o12'

47、 open() 使用指定的模式和编码打开文件，返回文件读写对象

#t为文本读写，b为二进制读写
>>> a = open('test.txt','rt')
>>> a.read()
'some text'
>>> a.close()
1

48、ord() 返回Unicode字符对应的整数

>>> ord('a')
97

49、pow() 返回两个数值的幂运算值或其与指定整数的模值

>>>pow(2, 3)     #等价于 2 ** 3
8  
>>>pow(2, 3, 5)  #等价于 (2 ** 3) % 5
3

50、print() 向标准输出对象打印输出

>>> print(1,2,3)
1 2 3
>>> print(1,2,3,sep = '+')  
1+2+3
>>> print(1,2,3,sep = '+',end = '=?')
1+2+3=?

51、 property() 标示属性的装饰器

>>> class C:
    def __init__(self):
        self._name = ''
    @property
    def name(self):
        """i'm the 'name' property."""
        return self._name
    @name.setter
    def name(self,value):
        if value is None:
            raise RuntimeError('name can not be None')
        else:
            self._name = value            
>>> c = C()
>>> c.name # 访问属性
>>> c.name = None # 设置属性时进行验证
Traceback (most recent call last):
  File "<pyshell#84>", line 1, in <module>
    c.name = None
  File "<pyshell#81>", line 11, in name
    raise RuntimeError('name can not be None')
RuntimeError: name can not be None

>>> c.name = 'Kim' # 设置属性
>>> c.name # 访问属性
'Kim'

>>> del c.name # 删除属性，不提供deleter则不能删除
Traceback (most recent call last):
  File "<pyshell#87>", line 1, in <module>
    del c.name
AttributeError: can't delete attribute
>>> c.name
'Kim'

52、range() 根据传入的参数创建一个新的range对象

>>> a = range(10)
>>> b = range(1,10)
>>> c = range(1,10,3)
>>> a,b,c # 分别输出a,b,c
(range(0, 10), range(1, 10), range(1, 10, 3))
>>> list(a),list(b),list(c) # 分别输出a,b,c的元素
([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])

53、repr() 返回一个对象的字符串表现形式(给解释器)

>>> a = 'some text'
>>> str(a)
'some text'
>>> repr(a)
"'some text'"

54、 reversed() 反转序列生成新的可迭代对象

>>> a = reversed(range(10)) # 传入range对象
>>> a # 类型变成迭代器
<range_iterator object at 0x035634E8>
>>> list(a)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

55、 round(x,k) 对浮点数x进行四舍五入求值,参数k表示保留几位小数

>>> round(3.1415926) #若没有参数，则默认保留0位小数
3
>>> round(3.14159,2) # k=2代表保留2位小数
3.14
>>> round(1689,-2) # k为-2，表示小数点左边第2位四舍五入：8>6,所以进位为1700
1700 

56、 set() 根据传入的参数创建一个新的集合

>>>set() # 不传入参数，创建空集合
set()
>>> a = set(range(10)) # 传入可迭代对象，创建集合
>>> a
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

57、 setattr() 设置对象的属性值

>>> class Student:
    def __init__(self,name):
        self.name = name

>>> a = Student('Kim')
>>> a.name
'Kim'
>>> setattr(a,'name','Bob')
>>> a.name
'Bob'

58、 slice（）：根据传入的参数创建一个新的切片对象

>>> c1 = slice(5) # 定义c1
>>> c1
slice(None, 5, None)
>>> c2 = slice(2,5) # 定义c2
>>> c2
slice(2, 5, None)
>>> c3 = slice(1,10,3) # 定义c3
>>> c3
slice(1, 10, 3)

59、 sorted() 对可迭代对象进行排序，返回一个新的列表

>>> a = ['a','b','d','c','B','A']
>>> a
['a', 'b', 'd', 'c', 'B', 'A']

>>> sorted(a) # 默认按字符ascii码排序
['A', 'B', 'a', 'b', 'c', 'd']

>>> sorted(a,key = str.lower) # 转换成小写后再排序，'a'和'A'值一样，
'b'和'B'值一样
['a', 'A', 'b', 'B', 'c', 'd']

60、 staticmethod() 标示方法为静态方法的装饰器

#使用装饰器定义静态方法
>>> class Student(object):
    def __init__(self,name):
        self.name = name
    @staticmethod
    def sayHello(lang):
        print(lang)
        if lang == 'en':
            print('Welcome!')
        else:
            print('你好！')

            
>>> Student.sayHello('en') #类调用,'en'传给了lang参数
en
Welcome!

>>> b = Student('Kim')
>>> b.sayHello('zh')  #类实例对象调用,'zh'传给了lang参数
zh
你好

61、str() 返回一个对象的字符串表现形式

>>> str()
''
>>> str(None)
'None'
>>> str('abc')
'abc'
>>> str(123)
'123'

62、 sum() 对元素类型是数值的可迭代对象中的每个元素求和

>>> sum((1,2,3,4))  
10
>>>sum((1,2),3)
>6
>>> sum((1.5,2.5,3.5,4.5))
12.0
>>> sum((1,2,3,4),-10)

63、 super() 根据传入的参数创建一个新的子类和父类关系的代理对象

#定义父类A
>>> class A(object):
    def __init__(self):
        print('A.__init__')

#定义子类B，继承A
>>> class B(A):
    def __init__(self):
        print('B.__init__')
        super().__init__()

#super调用父类方法
>>> b = B()
B.__init__
A.__init__

64、 tuple() 根据传入的参数创建一个新的元组

>>> tuple() #不传入参数，创建空元组
()
>>> tuple('121') #传入可迭代对象。使用其元素创建新的元组
('1', '2', '1')

65、 type()：返回对象的类型，或者根据传入的参数创建一个新的类型

>>> type(1) # 返回对象的类型
<class 'int'>

#使用type函数创建类型D，含有属性InfoD
>>> D = type('D',(A,B),dict(InfoD='some thing defined in D'))
>>> d = D()
>>> d.InfoD
 'some thing defined in D'

66、 vars() 返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表

>>> class A(object):
    pass

>>> a.__dict__
{}
>>> vars(a)
{}
>>> a.name = 'Kim'
>>> a.__dict__
{'name': 'Kim'}
>>> vars(a)
{'name': 'Kim'}

67、 zip() 聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器

>>> x = [1,2,3] #长度3
>>> y = [4,5,6,7,8] #长度5
>>> list(zip(x,y)) # 取最小长度3
[(1, 4), (2, 5), (3, 6)]

68、 --import–() 动态导入模块

index = __import__('index')
index.sayHello()
————————————————
原文链接：https://blog.csdn.net/anti_ice_point/article/details/88621821

其他参考：https://www.cnblogs.com/xnnx/p/11295195.html（重点参考）

https://www.cnblogs.com/ChinacloudTech/p/9954988.html

python中zip()函数用法举例：https://www.cnblogs.com/xuchunlin/p/6045273.html