Python学习【第九篇】内置函数

一、内置函数列表

python3的内置函数有：

		Built-in Functions
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	glogals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

二、常见内置函数用法

由于python内置函数较多，在此总结一下部分常见的内置函数的用法：

• abs(x)
  功能：取数的绝对。

>>> abs(0)
0
>>> abs(-5)
5
>>>

• all(interable)
  功能：判断可迭代对象中的每个元素，如果均为真（非0）则返回true，反之返回false。

>>> all([1,2,3])
True
>>> all([0,1,2,3])
False
>>>

• any(interable)
  功能：也是判断可迭代对象中的每个元素，不同的是只要有一个元素为真就返回true，反之返回false。

>>> any(['a','b','c'])
True
>>> any([])  # 空列表为假
False
>>> any([0])
False
>>> any([0,1])
True
>>>

• bin(x)
  功能：把整数转换成二进制。

>>> bin(100)
'0b1100100'
>>> bin(1)
'0b1'
>>>

• bool(object)
  功能：判断对象，返回布尔值，为空或0则返回false，反之返回true。

>>> bool('x')
True
>>> bool('')
False
>>> bool(0)
False
>>>

• bytearray[source[, encoding[, errors]]]
  功能：把二进制字节转换成可以修改的数组（列表） 。

>>> list1 = bytearray('001',encoding='utf-8')
>>> list1
bytearray(b'001')
>>> list1[0]    # 以列表方式访问元素，返回的是对应的ASCII码
48
>>> list1[0] = 99   # 更新时也必须以ASCII码的形式来更新
>>> list1
bytearray(b'c01')   # 更新后原列表变了
>>>

• bytes([source[, encoding[, errors]]])
  功能：把字符串转换成字节，但不能修改内容。

>>> b = bytes("abcd",encoding="utf-8")
>>> b
b'abcd'
>>> b[1]
98
>>> b[1] = 99
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'bytes' object does not support item assignment

• callable(object)
  功能：判断一个对象是否可以被调用，目前所知道的只有函数或类才可以通过调用符号()去调用。

>>> def func1():
...     pass
...
>>> callable(func1)
True
>>> a='test'
>>> callable(a)
False

• chr(x)
  功能：把ASCII中的数字转换成对应的字符。

>>> chr(98)
'b'

• ord(x)
  功能：获取一个字符对应的ASCII码。

99

• dict(**kwarg)、dict(mapping, **kwarg)、dict(iterable, **kwarg)
  功能：生成一个字典。

>>> dict
<class 'dict'>
>>> dict({('address','Chengdu'),('Num','028')})  # 传入一个set
{'address': 'Chengdu', 'Num': '028'}
>>> dict([('address','Chengdu'),('Num','028')])  # 传入list
{'address': 'Chengdu', 'Num': '028'}
>>> dict([['address','Chengdu'],['Num','028']])
{'address': 'Chengdu', 'Num': '028'}
>>> dict((('address','Chengdu'),('Num','028')))  # 传入元组
{'address': 'Chengdu', 'Num': '028'}
>>>

• dir(object)
  功能：查看一个对象的方法。

>>> a=dict((('address','Chengdu'),('Num','028')))
>>> dir(a)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__'
, '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__',
 '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '
__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__seta
ttr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'co
py', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update
', 'values']

• divmod(a,b)
  功能：地板除，获得一个元组，元组第一个元素是商，第二个元素是余数。

>>> divmod(9,2)
(4, 1)

• enumerate(iterable,start=0)
  功能：遍历一个iterable中，逐个返回索引和相应的元素（一个enumerate对象），start参数可设置索引起始值，默认从0开始。

>>> test='abcd'
>>> for index,item in enumerate(test):
...     print(index,item)
...
0 a
1 b
2 c
3 d
>>> print(list(enumerate(test)))
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> print(list(enumerate(test,start=2)))    #start参数人为设定起始索引值，默认从0开始
[(2, 'a'), (3, 'b'), (4, 'c'), (5, 'd')]
>>> print(dict(enumerate(test)))
{0: 'a', 1: 'b', 2: 'c', 3: 'd'}

• eval(expression, globals=None, locals=None)
  功能：进行简单的数学运算，对于符合其他特征不可计算的字符串，进行类型转换，比如可以把符合特征的字符串转换成int类型，list，tuple，dict等。

>>> eval('100')
100
>>> type(eval('100'))
<class 'int'>
>>> eval("[1,2,3]")
[1, 2, 3]
>>> eval("(1,2,3)")
(1, 2, 3)
>>> eval("{1:'name',2:'male',3:'age'}")
{1: 'name', 2: 'male', 3: 'age'}

• filter(function, iterable)
  功能：根据function定义的过滤条件，筛选出Iterable中符合条件的数据。

>>> a=filter(lambda x:x %2 == 0, [0,1,2,3,4])
>>> print(a)
<filter object at 0x0000000001E9BE48>   # 经filter处理后返回的是一个filter对象
>>> for i in a:
...     print(i)
...
0
2
4

• map(function, iterable)
  功能：接收参数function和可迭代对象iterable，对于每个迭代的元素一一进行函数运算，然后返回相应的结果（简单理解为一对一映射处理）。

>>> def func1(x):
...     return x * 2
...
>>> rs = map(func1,range(5))
>>> for i in rs:
...     print(i)
...
0
2
4
6
8
>>> rs
<map object at 0x00000000021DBE10>

• reduce(function, iterable, initializer)
  功能：将一个带有两个参数的方法累计应用到一个可迭代的对象的元素上（function必须接收两个参数，遍历可迭代对象的元素，把上一次计算的结果作为下一次计算的第一个参数），以便把可迭代对象规约为一个单一的值，即大数据中的reduce规约计算。其中第三个参数初始值是可选的，如果给出了初始值，则把初始值作为第一个计算的第一个参数。

>>> def f(x,y):
...     return x+y
...
>>> reduce(f,[1,3,5,7,9])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'reduce' is not defined
>>> from functools import reduce   # 注意这里需要先导入后才能使用
>>> reduce(f,[1,3,5,7,9])
25
>>> reduce(f,[1,3,5,7,9],100)      # 给出初始值100
125

计算过程如下：
先计算头两个元素：f(1, 3)，结果为4；
再把结果和第3个元素计算：f(4, 5)，结果为9；
再把结果和第4个元素计算：f(9, 7)，结果为16；
再把结果和第5个元素计算：f(16, 9)，结果为25；
由于没有更多的元素了，计算结束，返回结果25。
典型的应用场景是：凡是要对一个可迭代独享进行操作的，并且要有一个统计结果的，能够用循环或者递归方式解决的问题，一般情况下都可以用reduce方式实现（比如统计一个集合中key重复的次数）。

• float
  功能：把一个数字形式的字符串转换为浮点类型的数据。

>>> float('a')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: could not convert string to float: 'a'   #a不是数字形式，无法转换
>>>
>>> float('1')
1.0
>>> float('1.23')
1.23

• fronzenset(interable)
  功能:把一个可迭代对象转换为一个不可变的集合（双重特性，首先是符合集合的特性，其次是不可变）。

>>> res=frozenset([1,1,2,2,3])
>>> res
frozenset({1, 2, 3})  # 集合中的元素不可重复，符合集合特征
>>> res.add(4)  # 不能针对该集合增加元素，不可变
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
>>> dir(res)  # 没有可变方法
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '_
_eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__ini
t__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__',
'__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__r
or__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__'
, '__subclasshook__', '__xor__', 'copy', 'difference', 'intersection', 'isdisjoi
nt', 'issubset', 'issuperset', 'symmetric_difference', 'union']
>>>

• globals()
  功能：返回程序中所有的变量键值对（key 变量名， value 变量值，全局变量）。

>>> def foo(x):
...     global a
...     a=10
...     b=20
...     print(globals())
...
>>> foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() missing 1 required positional argument: 'x'
>>> foo(1)
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <cl
ass '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {
}, '__builtins__': <module 'builtins' (built-in)>, 'f': <function f at 0x0000000
001D23E18>, 'reduce': <built-in function reduce>, 'res': frozenset({1, 2, 3}), '
test': <function test at 0x00000000023DAEA0>, 'foo': <function foo at 0x00000000
02543840>, 'a': 10}   # 定义的全局变量已经获取打印到

>>> def foo2():
...     global a
...     a=100
...     print(globals().get('a'))  #直接获取全局变量的值
...
>>> foo2()
100

• locals()
  功能：与globals()类似，但返回的是局部变量。

>>> def foo(x):
...     a='hehe'
...     print(locals())
...
>>> foo(1)
{'a': 'hehe', 'x': 1}
>>>

• hash()
  功能：根据一定的算法生成固定的映射结果，相同的输入生成相同的输出。

>>> hash('xy')
6325275833896794579
>>> hash('xy')
6325275833896794579
>>> hash('100')
-93280025000303673
>>> hash(100)
100
>>>

这里需要注意的是它的应用场景hash函数把复杂的key（如中文）转换为固定的值存储，以便后续的复杂处理（查找，更新等），因为处理映射后的value更容易
+ max（iterable）
功能：返回一个可迭代对象的最大值。

>>> max((1,2,3))
3
>>> max({1,2,6})
6

• min（interable）
  功能：返回一个可迭代对象的最小值。

>>> min((1,2,3))
1
>>> min({1,2,6})
1

• input()
  功能：输入字符串。

>>> input(':')
:hehe
'hehe'

• list()
  功能：把其他的序列转换成列表。

>>> list({1,2,3})
[1, 2, 3]

• set()
  功能:把其他的序列（可迭代对象）转换成集合。

>>> set({1:'a',2:'b'})
{1, 2}
>>> set(range(5))
{0, 1, 2, 3, 4}

• hex()
  功能：转换十六进制。

>>> hex(16)
'0x10'
>>>

• oct()
  功能：转换八进制。

>>> oct(8)
'0o10'
>>> oct(7)
'0o7'

• sorted(iterable[, key][, reverse])
  功能：对一个序列进行排序。

>>> a={1:'a',2:'c',3:'b'}
>>> sorted(a)  # 默认只是排序key
[1, 2, 3]
>>> sorted(a.items()) # a.items返回的是包含键值对元组的列表，这里还是按key排序
[(1, 'a'), (2, 'c'), (3, 'b')]
>>> sorted(a.items(), key=lambda x:x[1])  # 指定键值对中的value作为排序的key，因此按value来排序
[(1, 'a'), (3, 'b'), (2, 'c')]
>>> print(a.items())
dict_items([(1, 'a'), (2, 'c'), (3, 'b')])

• zip(*iterables)
  功能：组合两个对象（zip中文拉链的意思），一一对应起来（如果有一个序列的个数更少，则按少的那个来）。

>>> a=[1,2,3]
>>> b={'a','b'}
>>> for i in zip(a,b):
...     print(i)
...
(1, 'a')
(2, 'b')
>>>

• __import__(name, globals=None, locals=None, fromlist=(), level=0)
  功能：当导入的模块是一个字符串时，用__import__()。

>>> import os
>>> __import__('os')
<module 'os' from '****\\lib\\os.py'>

参考：http://www.cnblogs.com/linupython/p/7679771.html