Python内置函数查询表—

Python3.5版本中的68个内置函数，按顺序逐个进行了自认为详细的解析，现在是时候进行个总结了。为了方便记忆，将这些内置函数进行了如下分类：

数学运算(7个)
类型转换(24个)
序列操作(8个)
对象操作(7个)
反射操作(8个)
变量操作(2个)
交互操作(2个)
文件操作(1个)
编译执行(4个)
装饰器(3个)

数学运算

abs：求数值的绝对值
```
>>> abs(-2)

2
```
♦ divmod：返回两个数值的商和余数abs：求数值的绝对值
```
>>> divmod(5,2)

(2, 1)

>> divmod(5.5,2)

(2.0, 1.5)
```
♦ max：返回可迭代对象中的元素中的最大值或者所有参数的最大值

>>> max(1,2,3) # 传入3个参数 取3个中较大者

3

>>> max('') # 传入1个可迭代对象，取其最大元素值

''

>>> max(-1,0) # 数值默认去数值较大者

0

>>> max(-1,0,key = abs) # 传入了求绝对值函数，则参数都会进行求绝对值后再取较大者

-1

♦ min：返回可迭代对象中的元素中的最小值或者所有参数的最小值

>>> min(1,2,3) # 传入3个参数 取3个中较小者

1

>>> min('') # 传入1个可迭代对象，取其最小元素值

''

>>> min(-1,-2) # 数值默认去数值较小者

-2

>>> min(-1,-2,key = abs)  # 传入了求绝对值函数，则参数都会进行求绝对值后再取较小者

-1

♦ pow：返回两个数值的幂运算值或其与指定整数的模值

>>> pow(2,3)

>>> 2**3

>>> pow(2,3,5)

>>> pow(2,3)%5

♦ round：对浮点数进行四舍五入求值

```
>>> round(1.1314926,1)

1.1

>>> round(1.1314926,5)

1.13149
```
♦ sum：对元素类型是数值的可迭代对象中的每个元素求和

# 传入可迭代对象

>>> sum((1,2,3,4))

10

# 元素类型必须是数值型

>>> sum((1.5,2.5,3.5,4.5))

12.0

>>> sum((1,2,3,4),-10)

0

类型转换

　　♦bool：根据传入的参数的逻辑值创建一个新的布尔值

>>> bool() #未传入参数

False

>>> bool(0) #数值0、空序列等值为False

False

>>> bool(1)

True

　　♦ int：根据传入的参数创建一个新的整数

>>> int() #不传入参数时，得到结果0。

0

>>> int(3)

3

>>> int(3.6)

3

　　♦ float：根据传入的参数创建一个新的浮点数

>>> float() #不提供参数的时候，返回0.0

0.0

>>> float(3)

3.0

>>> float('')

3.0

　　♦ complex：根据传入参数创建一个新的复数

>>> complex() #当两个参数都不提供时，返回复数 0j。

0j

>>> complex('1+2j') #传入字符串创建复数

(1+2j)

>>> complex(1,2) #传入数值创建复数

(1+2j)

　　♦ str：返回一个对象的字符串表现形式(给用户)

>>> str()

''

>>> str(None)

'None'

>>> str('abc')

'abc'

>>> str(123)

''

　　♦ bytearray：根据传入的参数创建一个新的字节数组

>>> bytearray('中文','utf-8')

bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

　　♦ bytes：根据传入的参数创建一个新的不可变字节数组

>>> bytes('中文','utf-8')

b'\xe4\xb8\xad\xe6\x96\x87'

　　♦ memoryview：根据传入的参数创建一个新的内存查看对象

>>> v = memoryview(b'abcefg')

>>> v[1]

98

>>> v[-1]

103

　　♦ ord：返回Unicode字符对应的整数

>>> ord('a')

97

　　♦ chr：返回整数所对应的Unicode字符

>>> chr(97) #参数类型为整数

'a'

　　♦ bin：将整数转换成2进制字符串

>>> bin(3)

'0b11'

　　♦ oct：将整数转化成8进制数字符串

>>> oct(10)

'0o12'

　　♦ hex：将整数转换成16进制字符串

>>> hex(15)

'0xf'

　　♦ tuple：根据传入的参数创建一个新的元组

>>> tuple() #不传入参数，创建空元组

()

>>> tuple('') #传入可迭代对象。使用其元素创建新的元组

('', '', ''

　　♦ list：根据传入的参数创建一个新的列表

>>>list() # 不传入参数，创建空列表

[]

>>> list('abcd') # 传入可迭代对象，使用其元素创建新的列表

['a', 'b', 'c', 'd']

　　♦ 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}

　　♦ set：根据传入的参数创建一个新的集合

>>>set() # 不传入参数，创建空集合

set()

>>> a = set(range(10)) # 传入可迭代对象，创建集合

>>> a

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

　　♦ frozenset：根据传入的参数创建一个新的不可变集合

>>> a = frozenset(range(10))

>>> a

frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

　　♦ 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')]

　　♦ 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])

>>>

　　♦ iter：根据传入的参数创建一个新的可迭代对象

>>> a = iter('abcd') #字符串序列

>>> a

<str_iterator object at 0x03FB4FB0>

>>> next(a)

'a'

>>> next(a)

'b'

>>> next(a)

'c'

>>> next(a)

'd'

>>> next(a)

Traceback (most recent call last):

  File "<pyshell#29>", line 1, in <module>

    next(a)

StopIteration

　　♦ 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)

　　♦ 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__

复制代码

　　♦ 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'

序列操作

未完待续。。。。。。。