跟女朋友介绍十个常用的 Python 内置函数，她夸了我一整天

内置函数是什么

了解内置函数之前，先来了解一下什么是函数

将使用频繁的代码段进行封装，并给它起一个名字，当我们使用的时候只需要知道名字就行

函数就是一段封装好的、可以重复使用的代码，函数使得我们的程序更加简洁、模块化，提高了代码的复用性

举个例子

我想实现一个求球表面积功能的程序，当我们知道半径 r 的时候，就可以根据公式来求出表面积

#S为表面积
S = 4 * 3.14 * r * r 

假设我们需要计算三个不同半径的球的表面积

r1 = 12.34
r2 = 9.08
r3 = 73.1
S1 = 4 * 3.14 * 12.34 * 12.34 
S2 = 4 * 3.14 * 9.08 * 9.08
S3 = 4 * 3.14 * 73.1 * 73.1

这样写会发现一个问题，每次都得写 4 * 3.14 * r * r ，而且如果要把 3.14 改成3.1415的话，需要全部替换掉

如何解决呢？既然这段是重复的有规律的代码，我们可以将其封装成函数

def surface_area(r):
    return 4 * 3.14 * r * r 

有了函数，我们就不再需要每次写 S = 4 * 3.14 * r * r ，而是通过函数调用的形式S = surface_area(r)

而且函数S = surface_area(r)本身只需要写一次，当你需要把 3.14 改成3.1415的时候，只需要对这个函数进行修改就行了

def surface_area(r):
    return 4 * 3.1415 * r * r 

在 Python 中，解释器自带的函数称为内置函数，这些函数可以直接调用且不需要导入（import）某个模块

运行 Python 需要一个叫做 Python 解释器的东西，这个 Python 解释器其实是一个程序，它为Python使用者提供了一些常用的功能，并取了独一无二的名字，这就是我们所说的“内置函数"

Python 解释器启动以后，内置函数也生效了，可以直接拿来使用

除了内置函数之外，Python 中还有标准库函数

Python 标准库函数相当于解释器的外部扩展，它不会随着解释器的启动而启动，要想使用这些外部扩展函数，需要提前导入，否则函数是无效的

#导入外部函数 time
import time

总的来说

• 内置函数是解释器的一部分，它随着解释器的启动而生效；标准库函数是解释器的外部扩展，导入模块以后才能生效
• 一般来说，内置函数的执行效率要高于标准库函数

下面给出官方提供的 Python 内置参数使用手册地址

http://docs.python.org/3/library/functions.html

常用内置函数

• abs()

abs(x)

功能：返回一个数的绝对值

print(abs(-100))
print(abs(0))
print(abs(200))

结果

100
0
200

调用函数的时候，如果传入的参数数量不对，会报TypeError的错误，并且Python会明确地告诉你：abs()有且仅有1个参数，但给出了两个

如果传入的参数数量是对的，但参数类型不能被函数所接受，也会报TypeError的错误，并且给出错误信息：str是错误的参数类型

• eval()

eval(expression, globals=None, locals=None)

功能：该函数用来执行一个字符串表达式，解析成 Python 表达式并返回表达式的值

x = 1
print(eval('x+1')) #等同于 eval('print(x+1)')

str = '我是大帅哥'
eval('print(str)')

结果

2
我是大帅哥

• max()

max(iterable, *[, default=obj, key=func])
max(arg1, arg2, *args, *[, key=func])

功能：

• 当传入单个可迭代参数时，返回可迭代参数中最大的元素
• 当传入两个或多个参数时，返回最大的那个参数
• default 用来指定最大值不存在时返回的默认值

传入单个参数，该参数为可迭代对象

l1 = [1, 3, 5, 6, 7]
print(max(l1))

#结果
7

传入参数不是可迭代对象会报错

l1 = 13567
print(max(l1))

#结果
TypeError: 'int' object is not iterable

传入多个参数

print(max(1, 2, 5, 6, 8))

#结果
8

至少传入两个参数，否则报错（是有只传入一个参数的例外，此时参数必须为可迭代对象，返回的是可迭代对象中的最大元素）

print(max(1))

#结果
TypeError: 'int' object is not iterable

print(max("1"))

#结果
1

如果传入可迭代参数为空，必须指定参数 default，用来返回默认值输出，否则报错

print(max((), default=1))

#结果
1

print(max(()))

#结果
ValueError: max() arg is an empty sequence

命名参数 key

值为一个函数，将传入 max() 中的参数传入 key 指定的函数中加工一遍之后再求最大值

def sum(x):
    return -x
    
print(max(1, 3, 5, 6, 7, key=sum))

#结果
1

print(max(1,2,'3',key = int))

#结果
3

print(max(1, 2,-3,key = abs))

#结果
-3

• min()

min(iterable, *[, default=obj, key=func])
min(arg1, arg2, *args, *[, key=func]) -> value

功能与 max() 相反，返回最小值，这里不过多介绍

• 数据类型转换函数

比如int()函数可以把其他数据类型转换为整数

print(int('123'))
print(int('0'))

#结果
123
0

float() 函数可以把其他数据类型转换为浮点数

print(float('1.12'))
print(float('0'))

#结果
1.12
0.0

str() 函数可以把其他数据类型转换为字符串

print(str(1.12))
print(str(0))

#结果
1.12
0

• range()

range(start, stop, step=1)

功能：在Python3中，返回特定范围内的可迭代对象，而不是列表类型

print(range(10))
print(list(range(10))

#结果
range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

默认步长为 1，可以指定步长

print(list(range(0, 10, 2)))

#结果
[0, 2, 4, 6, 8]

• reversed()

reversed(seq)

功能：将列表中的元素进行反转排序，返回的是一个可迭代对象，而不是列表类型

l1 = [1,2,3,4,5,6]
print(reversed(l1))
print(list(reversed(l1)))

#结果
<list_reverseiterator object at 0x000002D679666FD0>
[6, 5, 4, 3, 2, 1]

str = '123456'
print(list(reversed(str)))

#结果
['6', '5', '4', '3', '2', '1']

• sorted()

sorted(iterable, /, *, key=None, reverse=False)

功能：返回指定可迭代对象的排序列表

l1 = [2,11,3,4,1,6]
t1 = ("b", "g", "a", "d", "f", "c", "h", "e")
s1 = 'adcj'

print(sorted(l1))
print(sorted(t1))
print(sorted(s1))

结果

[1, 2, 3, 4, 6, 11]
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
['a', 'c', 'd', 'j']

reverse参数默认为 False，表示非反向输出

l1 = [2,11,3,4,1,6]
t1 = ("b", "g", "a", "d", "f", "c", "h", "e")
s1 = 'adcj'
print(sorted(l1, reverse=True))
print(sorted(t1, reverse=True))
print(sorted(s1, reverse=True))

结果

[11, 6, 4, 3, 2, 1]
['h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']
['j', 'd', 'c', 'a']

• map()

map(function, iterable, *iterables)

功能：map 将传入的函数依次作用到序列的每个元素，并把结果作为新的迭代器返回

def f(x):
    return x * x

res  = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(res)

#结果
[1, 4, 9, 16, 25, 36, 49, 64, 81]

map 传入的第一个参数是 f，即函数对象本身，由于结果 res 是一个 迭代器，是惰性序列，因此需要 list() 函数让它把整个序列都计算出来并返回一个列表

print(list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])))
print(list(map(lambda x : x * x, [1, 2, 3, 4, 5, 6, 7])))

#结果
['1', '2', '3', '4', '5', '6', '7', '8', '9']
[1, 4, 9, 16, 25, 36, 49]

• round()

round(number, ndigits=None)

功能：返回小数点后精确舍入到 ndigits 位的数字，ndigits 参数默认为 None，如果为 None，则返回与其输入最接近的整数

#精确到小数点后两位
print(round(1.341, 2))
print(round(1.346, 2))
print(round(1.341))

结果

1.34
1.35
1

而对于 round(2.675, 2) 返回 2.67 而不是 2.68 的结果官方也进行了说明

Note The behavior of round() for floats can be surprising: for example, round(2.675, 2) gives 2.67 instead of the expected 2.68. This is not a bug: it’s a result of the fact that most decimal fractions can’t be represented exactly as a float. See Floating Point Arithmetic: Issues and Limitations for more information

官方说这不是一个 bug，而是因为大多数小数不能精确的表示为浮点数

而 python3 中的 round() 并不是四舍五入，而是会受到计算机精度的影响

这跟浮点数的精度有关。我们知道在机器中浮点数不一定能精确表达，因为换算成一串1和0后可能是无限位数的，机器已经做出了截断处理。

那么在机器中保存的2.675这个数字就比实际数字要小那么一点点。这一点点就导致了它离2.67要更近一点点，所以保留两位小数时就近似到了2.67

如果想要返回 2.68，可以先将数值扩大 n 倍,直到将保留小数位的下一位小数提到小数部分第一位

也就是说保留两位小数就将第三位小数提到第一位，做的操作就是乘以100。依次类推

print(round(2.675,2))
print(round(2.675*100)/100)

结果

2.67
2.68

最后，除非对精确度没什么要求，否则尽量避开用 round() 函数，使用 decimal 模块