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]

1
2
3
4
5
6
7
8
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]

1
2
3
4
5
6
7
8
9
10
11
12
13

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)

1
2
3
4
5
6
7
8
9

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']))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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}')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

内置模块中使用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)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

all(iterable)

如果 iterable 的所有元素为真（或迭代器为空），返回 True

all([1,2,3]) # True

all([0, 1, 2]) # False
1
2
3

any(iterable)

如果 iterable 的任一元素为真则返回 True。 如果迭代器为空，返回 False

any([False, 0]) # False
any([0, 0, 0]) # False

any([1,2,3]) # True
any([0, 1, 2]) # True
1
2
3
4
5

bin(x)

将一个整数转变为一个前缀为“0b”的二进制字符串。

bin(10) # '0b1010'
bin(1000)  # '0b1111101000'
1
2

bytes([source[, encoding[, errors]]])

返回一个新的“bytes”对象， 是一个不可变序列，包含范围为 0 <= x < 256 的整数。

bytes('123123'.encode()) # b'123123'
1

chr(i)

返回 Unicode 码位为整数 i 的字符的字符串格式。

chr(65) # 'A'
chr(98) # 'b'
1
2

ord©

对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。

ord('A') # 65
ord('b') # 98
1
2

hex(x)

将整数转换为以“0x”为前缀的小写十六进制字符串。

hex(1) # '0x1'
hex(10) # '0xa'
hex(15) # '0xf'
hex(16) # '0x10'
1
2
3
4

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

eval(expression[, globals[, locals]])

返回值为表达式_expression_求值的结果

a = 1
b = 2
eval('a+b') # 3
1
2
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14

iter(object[, sentinel])

接受一个可迭代的对象作为参数，然后返回该可迭代对象的迭代器。

iter([1,2,3]) # 
iter((1,2,3)) # 

for i in iter([1,2,3]):
    print(i)
1
2
3
1
2
3
4
5
6
7
8

next(iterator[, default])

接受一个迭代器作为参数，用于从可迭代对象或迭代器中获取下一个元素，如果没有更多的元素可供迭代，next() 函数会引发 StopIteration 异常，或者可以指定一个默认值作为参数，以在迭代结束时返回。

data = iter([1,2,3])

next(data)
1

next(data)
2

next(data)
3

next(data)
StopIteration
1
2
3
4
5
6
7
8
9
10
11
12
13

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33