2.3 Python常用内置函数用法
内置函数不需要额外导入任何模块即可直接使用，具有非常快的运行速度，推荐优先使用。使用下面的语句可以查看所有内置函数和内置对象。
> > > dir(__builtins__)
使用help(函数名)可以查看某个函数的用法。常用的内置函数及其功能简要说明如表2-3所示，其中方括号内的参数可以省略。
表2-3 Python常用内置函数
（续）
2.3.1 类型转换与判断
1）内置函数bin()、oct()、hex()用来将整数转换为二进制、八进制和十六进制形式，这3个函数都要求参数必须为整数。
> > > bin(555) #把数字转换为二进制串
'0b1000101011'
> > > oct(555) #转换为八进制串
'0o1053'
> > > hex(555) #转换为十六进制串
'0x22b'
内置函数float()用来将其他类型数据转换为实数，complex()可以用来生成复数。
> > > float(3) #把整数转换为实数
3.0
> > > float('3.5') #把数字字符串转换为实数
3.5
> > > float('inf') #无穷大，其中inf不区分大小写
inf
> > > complex(3) #指定实部
(3+0j)
> > > complex(3, 5) #指定实部和虚部
(3+5j)
> > > complex('inf') #无穷大
(inf+0j)
2）ord()用来返回单个字符的Unicode码，而chr()则用来返回Unicode编码对应的字符，str()则直接将其任意类型参数转换为字符串。
> > > ord('a') #查看指定字符的Unicode编码
97
> > > chr(65) #返回数字65对应的字符
'A'
> > > chr(ord('A')+1) #Python不允许字符串和数字之间的加法操作
'B'
> > > chr(ord(’国’)+1) #支持中文
'图’
> > > str(1234) #直接变成字符串
'1234'
> > > str([1,2,3])
'[1, 2, 3]'
> > > str((1,2,3))
'(1, 2, 3)'
> > > str({1,2,3})
'{1, 2, 3}'
3）list()、tuple()、dict()、set()用来把其他类型的数据转换成为列表、元组、字典和可变集合，或者创建空列表、空元组、空字典和空集合。
> > > list(range(5)) #把range对象转换为列表
[0, 1, 2, 3, 4]
> > > tuple(_) #一个下划线表示上一次正确的输出结果
(0, 1, 2, 3, 4)
> > > dict(zip('1234', 'abcde')) #创建字典
{'4': 'd', '2': 'b', '3': 'c', '1': 'a'}
> > > set('1112234') #创建可变集合，自动去除重复
{'4', '2', '3', '1'}
4）内置函数eval()用来计算字符串的值，在有些场合也可以用来实现类型转换的功能。
> > > eval('3+5')
8
> > > eval(b'3+5') #引号前面加字母b表示字节串
8
> > > eval('9') #把数字字符串转换为数字
9
> > > eval('09') #抛出异常，不允许以0开头的数字
SyntaxError: invalid token
> > > int('09') #这样转换是可以的
9
> > > list(str([1, 2, 3, 4])) #字符串中每个字符都变为列表中的元素
['[', '1', ', ', ' ', '2', ', ', ' ', '3', ', ', ' ', '4', ']']
> > > eval(str([1, 2, 3, 4])) #字符串求值
[1, 2, 3, 4]
5）内置函数type()和isinstance()可以用来判断数据的类型。
> > > type([3]) #查看[3]的类型
<class 'list' >
> > > type({3}) in (list, tuple, dict)
False
> > > isinstance(3, int) #判断3是否为int类型的实例
True
> > > isinstance(3j, (int, float, complex))
True
2.3.2 最值与求和
max()、min()、sum()这3个内置函数分别用于计算列表、元组或其他包含有限个元素的可迭代对象中所有元素最大值、最小值以及所有元素之和。
下面的代码首先使用列表推导式生成包含10个随机数的列表，然后分别计算该列表的最大值、最小值、所有元素之和以及平均值。
> > > from random import randint
> > > a = [randint(1,100) for i in range(10)]
#包含10个[1,100]之间随机数的列表
> > > print(max(a), min(a), sum(a)) #最大值、最小值、所有元素之和
> > > sum(a) / len(a) #平均值
函数max()和min()还支持key参数，用来指定比较大小的依据或规则，可以是函数或lambda表达式。
> > > max(['2', '111']) #不指定排序规则
'2'
> > > max(['2', '111'], key=len) #返回最长的字符串
'111'
> > > from random import randint
> > > lst = [[randint(1, 50) for i in range(5)] for j in range(30)]
#列表推导式，生成包含30个子列表的列表
#每个子列表中包含5个介于[1,50]区间的整数
> > > max(lst, key=sum) #返回元素之和最大的子列表
> > > max(lst, key=lambda x: x[1]) #所有子列表中第2个元素最大的子列表
> > > max(lst, key=lambda x: (x[1], x[3]))
2.3.3 基本输入/输出
input()和print()是Python的基本输入/输出函数，前者用来接收用户的键盘输入，后者用来把数据以指定的格式输出到标准控制台或指定的文件对象。不论用户输入什么内容，input()一律作为字符串对待，必要的时候可以使用内置函数int()、float()或eval()对用户输入的内容进行类型转换。例如：
> > > x = input('Please input: ') #input()函数参数表示提示信息
Please input: 345
> > > x
'345'
> > > type(x) #把用户的输入作为字符串对待
<class 'str' >
> > > int(x) #转换为整数
345
> > > eval(x) #对字符串求值，或类型转换
345
> > > x = input('Please input: ')
Please input: [1, 2, 3]
> > > x #不管用户输入什么，一律返回字符串
'[1, 2, 3]'
> > > type(x)
<class 'str' >
> > > eval(x) #注意，这里不能使用list()进行转换
[1, 2, 3]
内置函数print()用于输出信息到标准控制台或指定文件，语法格式为：
print(value1, value2, ..., sep=' ', end='\n',
file=sys.stdout, flush=False)
其中sep参数之前为需要输出的内容（可以有多个）；sep参数用于指定数据之间的分隔符，默认为空格。例如：
> > > print(1, 3, 5, 7, sep='\t') #修改默认分隔符
1 3 5 7
> > > for i in range(10): #修改end参数，每个输出之后不换行
print(i, end=' ')
0 1 2 3 4 5 6 7 8 9
2.3.4 排序与逆序
sorted()可以对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表，支持使用key参数指定排序规则，其含义和用法与max()、min()函数的key参数相同。
> > > x = list(range(11))
> > > import random
> > > random.shuffle(x) #shuffle()用来随机打乱顺序
> > > x
[2, 4, 0, 6, 10, 7, 8, 3, 9, 1, 5]
> > > sorted(x) #以默认规则排序
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
> > > sorted(x, key=lambda item:len(str(item)), reverse=True)
#以指定规则降序排序
[10, 2, 4, 0, 6, 7, 8, 3, 9, 1, 5]
> > > sorted(x, key=str) #以指定规则排序
[0, 1, 10, 2, 3, 4, 5, 6, 7, 8, 9]
> > > x #不影响原来列表的元素顺序
[2, 4, 0, 6, 10, 7, 8, 3, 9, 1, 5]
> > > x = ['aaaa', 'bc', 'd', 'b', 'ba']
> > > sorted(x, key=lambda item: (len(item), item))
#先按长度排序，长度一样的正常排序
['b', 'd', 'ba', 'bc', 'aaaa']
reversed()可以对可迭代对象（生成器对象和具有惰性求值特性的zip、map、filter、enumerate等类似对象除外）进行翻转（首尾交换）并返回可迭代的reversed对象。
> > > list(reversed(x)) #reversed对象是可迭代的
['ba', 'b', 'd', 'bc', 'aaaa']
2.3.5 枚举与迭代
enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组。在使用时，既可以把enumerate对象转换为列表、元组、集合，也可以使用for循环直接遍历其中的元素。
> > > list(enumerate('abcd')) #枚举字符串中的元素
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
> > > list(enumerate(['Python', 'Greate'])) #枚举列表中的元素
[(0, 'Python'), (1, 'Greate')]
> > > for index, value in enumerate(range(10, 15)):
print((index, value), end=' ')
(0, 10) (1, 11) (2, 12) (3, 13) (4, 14)
2.3.6 map()函数、reduce()函数、filter()函数
1. map()函数
内置函数map()把一个函数func依次映射到序列的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理后的结果，map()函数不对原序列做任何修改。
> > > list(map(str, range(5))) #把列表中的元素转换为字符串
['0', '1', '2', '3', '4']
> > > def add5(v): #单参数函数
return v+5
> > > list(map(add5, range(10))) #把单参数函数映射到一个序列的所有元素
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
> > > def add(x, y): #可以接收两个参数的函数
return x+y
> > > list(map(add, range(5), range(5,10)))
#把双参数函数映射到两个序列上
[5, 7, 9, 11, 13]
> > > list(map(lambda x, y: x+y, range(5), range(5,10)))
#使用lambda表达式实现同样功能
#该lambda表达式相等于一个函数，
#接收x和y作为参数，返回x+y
#lambda表达式的介绍详见5.4节
[5, 7, 9, 11, 13]
> > > import random
> > > x = random.randint(1, 1e30) #生成指定范围内的随机整数
#1e30表示10的30次方
> > > x
839746558215897242220046223150
> > > list(map(int, str(x))) #提取大整数每位上的数字
[8, 3, 9, 7, 4, 6, 5, 5, 8, 2, 1, 5, 8, 9, 7, 2, 4, 2, 2, 2, 0, 0, 4, 6, 2,2, 3, 1, 5, 0]
2．reduce()函数
标准库functools中的函数reduce()可以将一个接收两个参数的函数以迭代累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上，并且允许指定一个初始值。例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])计算过程为((((1+2)+3)+4)+5)，第一次计算时x为1而y为2，第二次计算时x的值为(1+2)而y的值为3，第三次计算时x的值为((1+2)+3)而y的值为4，以此类推，最终完成计算并返回((((1+2)+3)+4)+5)的值。
> > > from functools import reduce
> > > reduce(lambda x, y: x+y, range(1, 10)) #lambda表达式相当于函数
45
上面实现数字累加的代码运行过程如图2-1所示。
图2-1 reduce()函数执行过程示意图
3. filter()函数
内置函数filter()将一个单参数函数作用到一个序列上，返回该序列中使得该函数返回值为True的那些元素组成的filter对象，如果指定函数为None，则返回序列中等价于True的元素。在使用时，可以把filter对象转换为列表、元组、集合，也可以直接使用for循环遍历其中的元素。
> > > seq = ['foo', 'x41', '? ! ', '***']
> > > def func(x):
return x.isalnum() #isalnum()是字符串的方法
#用于测试x是否为字母或数字
> > > filter(func, seq) #返回filter对象
<filter object at 0x000000000305D898 >
> > > list(filter(func, seq)) #把filter对象转换为列表
['foo', 'x41']
> > > seq #不对原列表做任何修改
['foo', 'x41', '? ! ', '***']
2.3.7 range()函数
range()是Python开发中常用的一个内置函数，语法格式为range([start,] stop [, step])，有range(stop)、range(start, stop)和range(start, stop, step)三种用法。该函数返回具有惰性求值特点的range对象，包含左闭右开区间[start, stop)内以step为步长的整数，其中参数start默认为0，step默认为1。
> > > range(5) #start默认为0, step默认为1
range(0, 5)
> > > list(_)
[0, 1, 2, 3, 4]
> > > list(range(1, 10, 2)) #指定起始值和步长
[1, 3, 5, 7, 9]
> > > list(range(9, 0, -2)) #步长为负数时，start应比end大
[9, 7, 5, 3, 1]
> > > for i in range(4): #循环4次
print(3, end=' ')
3 3 3 3
2.3.8 zip()函数
zip()函数用来把多个可迭代对象中对应位置上的元素压缩到一起，返回一个可迭代的zip对象，其中每个元素都是包含原来多个可迭代对象对应位置上元素的元组，最终结果中包含的元素个数取决于所有参数序列或可迭代对象中最短的那个。
> > > list(zip('abcd', [1, 2, 3])) #压缩字符串和列表
[('a', 1), ('b', 2), ('c', 3)]
> > > list(zip('abcd')) #对1个序列也可以压缩
[('a', ), ('b', ), ('c', ), ('d', )]
> > > list(zip('123', 'abc', ', .! ')) #压缩3个序列
[('1', 'a', ', '), ('2', 'b', '.'), ('3', 'c', '! ')]
> > > for item in zip('abcd', range(3)): #zip对象是可迭代的
print(item)
('a', 0)
('b', 1)
('c', 2)
> > > x = zip('abcd', '1234')
> > > list(x)
[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
> > > list(x) #注意，zip对象只能遍历一次
#访问过的元素就不存在了
#enumerate、filter、map对象，
#以及生成器对象也有这个特点
[]