Python必学函数：常用内置函数详解和举例分析
map函数
是根据第一个参数定义的函数，依次作用在序列上，返回一个迭代器
s = '1,2,3,4,5'
# 将字符串转换成整数列表
list(map(int, s.split(','))) # [1,2,3,4,5]
# 求两个连表中元素的和，放入新列表中
data1 = [1,2,3]
data2 = [4,5,6]
list(map(lambda x,y:x+y, data1, data2)) # [5, 7, 9]
filter函数
是根据第一个参数定义的函数来过滤序列，过滤掉不符合条件的元素，并返回一个迭代器
data = [-1, -2, 0, 1, 0, 2, 3, 4, 5]
def filter_0(x):
return False if x == 0 else True
# 过滤序列中的0
list(filter(filter_0, data)) # [-1, -2, 1, 2, 3, 4, 5]
list(filter(lambda x:x!=0, data))
# 如果第一个参数是None，则过滤掉序列中bool值为False的项
data = [0,1,2,3]
list(filter(None, data)) # [1,2,3]
reduce函数
将两个参数的函数作用在一个序列上，把结果继续和序列的下一个元素作为函数的参数，继续进行累积，使用时需要导入 from functools import reduce
from functools import reduce
data = [1,2,3,4,5]
def _add(a,b):
return a+b
result = reduce(_add, data) # 15
result = reduce(lambda x,y:x+y, data)
sorted函数
用于对可迭代对象进行排序的函数。它不会改变原始可迭代对象的顺序，而是返回一个新的已排序的列表
# 根据其中一个属性排序,reverse 表示降序
student = [('li', 12, 3), ('long', 33, 4), ('fei', 20, 1), ('zhang', 20,3), ('mengd', 20, 0)]
res = sorted(student, key=lambda x: x[1], reverse=True)
print(res)
# 先根据 第2个属性正序排序，再按第三个属性逆序排序
res = sorted(student, key=lambda x: (x[1], -x[2]))
# 字典排序，先根据name, 再根据age
student = [{'name':'li', 'age':20}, {'name':'fe', 'age':18}, {'name':'lo', 'age':15}, {'name':'me', 'age':22}]
sorted(student, key=lambda x: (x['name'], x['age']))
# 列表中的字典，按已知顺序排序
student = [{'name':'zhang'}, {'name':'wang'},{'name':'li'},{'name':'zhao'},{'name':'chen'}]
index = ['li', 'zhang', 'wang', 'zhao']
sorted(student, key=lambda x: index.index(x['name']))
memoryview函数
允许 Python 代码访问一个对象的内部数据，只要该对象支持 缓冲区协议 而无需进行拷贝，该对象必须支持缓冲区协议，比如内置对象 bytes 和 bytearray。比如当访问 bytes 和 bytearray对象，进行切片的时候，需要进行浅拷贝的操作，如果数据非常大的时候，浅拷贝也是非常消耗内存资源的，如果使用memoryview函数访问 bytes 和 bytearray 不会进行拷贝，是直接访问原始数据，但是修改的时候也会修改原始数据。
import time
# 使用正常切片进行访问时耗时 34秒
data = b'x' * 1024 * 1024
start = time.time()
data_copy = data
while data_copy:
data_copy = data_copy[1:]
print(f'{time.time() - start:0.3f}')
# 使用内存视图进行访问耗时只有0.2秒
data = b'x' * 1024 * 1024
start = time.time()
data_memv = memoryview(data)
while data_memv:
data_memv = data_memv[1:]
print(f'memoryview {time.time() - start:0.3f}')
内置模块中使用memoryview
# ssl.py
class SSLSocket:
def sendall(self, data, flags=0):
self._checkClosed()
if self._sslobj is not None:
if flags != 0:
raise ValueError(
"non-zero flags not allowed in calls to sendall() on %s" %
self.__class__)
count = 0
with memoryview(data) as view, view.cast("B") as byte_view:
amount = len(byte_view)
while count < amount:
v = self.send(byte_view[count:])
count += v
else:
return super().sendall(data, flags)
all(iterable)
如果 iterable 的所有元素为真（或迭代器为空），返回 True
all([1,2,3]) # True
all([0, 1, 2]) # False
any(iterable)
如果 iterable 的任一元素为真则返回 True。 如果迭代器为空，返回 False
any([False, 0]) # False
any([0, 0, 0]) # False
any([1,2,3]) # True
any([0, 1, 2]) # True
bin(x)
将一个整数转变为一个前缀为“0b”的二进制字符串。
bin(10) # '0b1010'
bin(1000) # '0b1111101000'
bytes([source[, encoding[, errors]]])
返回一个新的“bytes”对象， 是一个不可变序列，包含范围为 0 <= x < 256 的整数。
bytes('123123'.encode()) # b'123123'
chr(i)
返回 Unicode 码位为整数 i 的字符的字符串格式。
chr(65) # 'A'
chr(98) # 'b'
ord©
对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。
ord('A') # 65
ord('b') # 98
hex(x)
将整数转换为以“0x”为前缀的小写十六进制字符串。
hex(1) # '0x1'
hex(10) # '0xa'
hex(15) # '0xf'
hex(16) # '0x10'
enumerate(iterable, start=0)
返回一个枚举对象。iterable 必须是一个序列，或 iterator，或其他支持迭代的对象。
data = [1, 3, 4, 5, 6]
for index, row in enumerate(data):
print(index, row)
0 1
1 3
2 4
3 5
4 6
# index索引从2开始
for index, row in enumerate(data, 2):
print(index, row)
2 1
3 3
4 4
5 5
6 6
eval(expression[, globals[, locals]])
返回值为表达式_expression_求值的结果
a = 1
b = 2
eval('a+b') # 3
exec(object[, globals[, locals]])
这个函数支持动态执行 Python 代码。object 必须是字符串或者代码对象。如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）。如果是代码对象，它将被直接执行。
funcstr = """
def add(a, b):
return a+b
"""
exec(funcstr) # 将字符串定义的函数，解析为代码并加载到内存中
res = eval("add(1,3)") # 调用函数
print(res) # 4
action = "x*x"
func1 = f"""mul = lambda x:{action}"""
exec(func1)
res = eval("mul(3)")
print(res) # 9
iter(object[, sentinel])
接受一个可迭代的对象作为参数，然后返回该可迭代对象的迭代器。
iter([1,2,3]) # next(iterator[, default])
接受一个迭代器作为参数，用于从可迭代对象或迭代器中获取下一个元素，如果没有更多的元素可供迭代，next() 函数会引发 StopIteration 异常，或者可以指定一个默认值作为参数，以在迭代结束时返回。
data = iter([1,2,3])
next(data)
1
next(data)
2
next(data)
3
next(data)
StopIteration
zip(*iterables)
返回一个元组的迭代器，其中的第 i 个元组包含来自每个参数序列或可迭代对象的第 i 个元素。 当所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代。
d1 = [1, 2, 3]
d2 = ['alic', 'bob', 'liuh']
for no, name in zip(d1, d2):
print(no, name)
1 alic
2 bob
3 liuh
d1 = [1, 2, 3]
d2 = ['alic', 'bob', 'liuh', 'zhange']
# 取最短的
for no, name in zip(d1, d2):
print(no, name)
1 alic
2 bob
3 liuh
d1 = [1, 2, 3]
d2 = ['alic', 'bob', 'liuh', 'zhange']
d3 = [172, 180, 176]
# 多组同时遍历
for no, name, height in zip(d1, d2, d3):
print(no, name, height)
1 alic 172
2 bob 180
3 liuh 176