Python常用内置函数总结：
整理过程中参考了runoob网站中python内置函数的相关知识点，特此鸣谢！！
原文地址：http://www.runoob.com/python/python-built-in-functions.html
l all()函数
判断迭代对象中是否有空或为0的对象，如果有则返回False
all(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0 True
all([0, 1，2, 3]) # 列表list，存在一个为0的元素False
all([]) # 空列表True
>>> all(()) # 空元组True
print (all([])) #结果是True
print(all(()))#结果居然也是True
l any()函数
any也用来判断可迭代对象，所不同的是，当可迭代对象中都为0时结果才为False
any(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素 True
any([0, '', False]) # 列表list,元素全为0,'',false
any(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素 True
any((0, '', False)) # 元组tuple，元素全为0,'',false
any([]) # 空列表 False
any(()) # 空元组 False
l bytearray()方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
ü 如果 source 为整数，则返回一个长度为 source 的初始化数组；
ü 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
ü 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数
ü 如果没有输入任何参数，默认就是初始化数组为0个元素。
用print（）嵌套====>输出结果
bytearray()====> bytearray(b'')
bytearray([1,2,3]) ====>bytearray(b'x01x02x03')
print(bytearray('花呀花呀开在那枝丫枝丫头','utf-8'))====>
bytearray(b'xe8x8axb1xe5x91x80xe8x8axb1xe5x91x80xe5xbcx80xe5x9cxa8xe9x82xa3xe6x9ex9dxe4xb8xabxe6x9ex9dxe4xb8xabxe5xa4xb4')
print(bytearray('xuxiaodong', 'utf-8'))==========>bytearray(b'chengjin')
bytearray('xuxiaodong', 'utf-8')====> bytearray(b'chengjin')
l callable()
callable() 函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。
调用函数==========>输出结果
callable(0) ==========>False
callable("xuxiaodong")==========> False
def add(a, b): ... return a + b ... ==========>callable(add)==========>True
l complex() 函数
complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数
real -- int, long, float或字符串；
imag -- int, long, float；
调用函数==========>输出结果
complex(1, 2)==========> (1 + 2j)
complex(1) ==========># 数字 (1 + 0j)
complex("1") ==========># 当做字符串处理 (1 + 0j)
complex("1+2j") ==========>(1 + 2j)# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
l dir() 函数
dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
dir() # 获得当前模块的属性列表 ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([ ]) # 查看列表的方法 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
l divmod()函数
python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
在 python 2.3 版本之前不允许处理复数。
参数说明：
a: 数字
b: 数字
divmod(7, 2) ==========>(3, 1)
divmod(8, 2) ==========>(4, 0)
divmod(1+2j,1+0.5j)==========> ((1+0j), 1.5j)
l enumerate() 函数
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。Python 2.3. 以上版本可用，2.6 添加 start 参数。
参数
sequence -- 一个序列、迭代器或其他支持迭代对象。
start -- 下标起始位置。
返回值
返回 enumerate(枚举) 对象。
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))==========>[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
用法
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
... print i, seq[i] ...
结果：
0 one
1 two
2 three
l eval() 函数
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
参数
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值
返回表达式计算结果。
用法
x = 7 eval( '3 * x' ) ==========>21
eval('pow(2,2)') ==========>4
eval('2 + 2') ==========>4
l file() 函数
file() 函数用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数。参数是以字符串的形式传递的。
更多文件操作可参考：Python 文件I/O。
参数
name -- 文件名
mode -- 打开模式
buffering -- 0 表示不缓冲,如果为 1 表示进行行缓冲，大于 1 为缓冲区大小。
返回值
文件对象。
f = file('test.txt')
f.read()
l filter() 函数
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
语法
以下是 filter() 方法的语法:
filter(function, iterable)
参数
function -- 判断函数。
iterable -- 可迭代对象。
返回值
返回列表。
def is_odd(n):
return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) print(newlist)
l float() 函数
float() 函数用于将整数和字符串转换成浮点数。
参数
x -- 整数或字符串
返回值
返回浮点数。
float(1) ==========>1.0
float(112) ==========>112.0
float(-123.6) -==========>123.6
float('123') # 字符串 ==========>123.0
l frozenset()函数
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
语法
frozenset() 函数语法：
class frozenset([iterable])
参数
iterable -- 可迭代的对象，比如列表、字典、元组等等。
返回值
返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。。
实例
a = frozenset(range(10)) # 生成一个新的不可变集合
a ==========>frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
b = frozenset('chengjin')
b==========> frozenset(['b', 'r', 'u', 'o', 'n']) # 创建不可变集合
l hash() 函数
描述
hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
语法
hash 语法：
hash(object)
参数说明：
object -- 对象；
返回值
返回对象的哈希值。
实例
以下实例展示了 hash 的使用方法：
>>>hash('test') # 字符串 ==========>2314058222102390712
>>> hash(1) # 数字 ==========>1
>>> hash(str([1,2,3])) # 集合 ==========>1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典 ==========>7666464346782421378
l id()函数
描述
id() 函数用于获取对象的内存地址。
语法
id 语法：
id([object])
参数说明：
object -- 对象。
返回值
返回对象的内存地址。
实例
以下实例展示了 id 的使用方法：
>>>a = 'chengjin'
id(a) ==========>4531887632
b = 1
id(b) ==========>140588731085608
l isinstance() 函数
描述
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
语法
以下是 isinstance() 方法的语法:
isinstance(object, classinfo)
参数
object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者有它们组成的元组。
返回值
如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。
实例
以下展示了使用 isinstance 函数的实例：
>>>a = 2
>>> isinstance (a,int) ==========>True
>>> isinstance (a,str)==========> False
>>> isinstance (a,(str,int,list)) # 是元组中的一个返回 True ==========>True
type() 与 isinstance()区别：
class A:
pass
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False
l iter() 函数
描述
iter() 函数用来生成迭代器。
语法
以下是 iter() 方法的语法:
iter(object[, sentinel])
参数
object -- 支持迭代的集合对象。
sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
打开模式
返回值
迭代器对象。
实例
lst = [1, 2, 3]
for i in iter(lst):
... print(i)
结果：
... 1 2 3
l reduce() 函数
描述
reduce() 函数会对参数序列中元素进行累积。
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给reduce中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
语法
reduce() 函数语法：
reduce(function, iterable[, initializer])
参数
function -- 函数，有两个参数
iterable -- 可迭代对象
initializer -- 可选，初始参数
返回值
返回函数计算结果。
实例
以下实例展示了 reduce() 的使用方法：
>>>def add(x, y) : # 两数相加
... return x + y ...
>>> reduce(add, [1,2,3,4,5]) # 计算列表和：1+2+3+4+5 15
>>> reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函数 15
l repr() 函数
描述
repr() 函数将对象转化为供解释器读取的形式。
语法
以下是 repr() 方法的语法:
repr(object)
参数
object -- 对象。
返回值
返回一个对象的 string 格式。
实例
以下展示了使用 repr() 方法的实例：
>>>s = 'chengjin'
>>> repr(s) "'chengjin'"
>>> dict = {'chengjin': 'chengjin.com', 'google': 'google.com'};
>>> repr(dict) "{'google': 'google.com', 'chengjin': 'chengjin.com'}"
l reverse() 函数
描述
reverse() 函数用于反向列表中元素。
语法
reverse()方法语法：
list.reverse()
参数
NA。
返回值
该方法没有返回值，但是会对列表的元素进行反向排序。
实例
以下实例展示了 reverse()函数的使用方法：
#!/usr/bin/python
aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
aList.reverse();
print "List : ", aList;
以上实例输出结果如下：
List : ['xyz', 'abc', 'zara', 'xyz', 123]
l slice() 函数
描述
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
语法
slice 语法：
class slice(stop)class slice(start, stop[, step])
参数说明：
start -- 起始位置
stop -- 结束位置
step -- 间距
返回值
返回一个切片对象。
实例
以下实例展示了 slice 的使用方法：
>>>myslice = slice(5) # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice] # 截取 5 个元素
[0, 1, 2, 3, 4]
l sorted() 函数
描述
sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
语法
sorted 语法：
sorted(iterable[, cmp[, key[, reverse]]])
参数说明：
iterable -- 可迭代对象。
cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
返回值
返回重新排序的列表。
实例
以下实例展示了 sorted 的使用方法：
>>>a = [5,7,6,3,4,1,2] >>>
b = sorted(a) # 保留原列表
>>> a
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1]) # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2]) # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>> sorted(students, key=lambda s: s[2], reverse=True) # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>>
l zip() 函数
描述
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
语法
zip 语法：
zip([iterable, ...])
参数说明：
iterabl -- 一个或多个迭代器;
返回值
返回元组列表。
实例
以下实例展示了 zip 的使用方法：
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped) # 与 zip 相反，可理解为解压，
返回二维矩阵式 [(1, 2, 3), (4, 5, 6)]
l exec 内置语句
描述
exec 执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码。
需要说明的是在 Python2 中exec不是函数，而是一个内置语句(statement)，但是Python 2中有一个 execfile() 函数。可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了。
语法
以下是 exec 的语法:
exec obj
参数
obj -- 要执行的表达式。
返回值
exec 返回值永远为 None。
实例
以下展示了使用 exec 的实例：
实例 1
>>>exec 'print "Hello World"'
Hello World # 单行语句字符串
>>> exec "print 'chengjin.com'"
chengjin.com # 多行语句字符串
>>> exec """for i in range(5):
... print "iter time: %d" % i
... """
结果为：
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4
实例 2
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