python内置函数 M

python内置函数 M

Python 解释器内置了很多函数和类型，任何时候都能使用。

M

名称	描述
map	返回一个迭代器，其中包含函数应用于每个元素的结果。
max	返回给定可迭代对象（如列表、元组、字符串等）中的最大元素。
memoryview	返回由给定实参创建的“内存视图”对象。
min	返回给定可迭代对象（如列表、元组、字符串等）中的最小元素。

map(function, iterable, *iterables)

map()是一个内置函数，用于将一个函数应用于一个或多个序列（如列表、元组等）中的每一个元素，并返回一个迭代器，其中包含函数应用于每个元素的结果。

• function：是要应用的函数。
• iterable：是一个或多个可迭代对象（如列表、元组等），函数将应用于这些可迭代对象的每一个元素。

返回一个将 function 应用于 iterable 的每一项，并产生其结果的迭代器。 如果传入了额外的 iterables 参数，则 function 必须接受相同个数的参数并被用于到从所有可迭代对象中并行获取的项。 当有多个可迭代对象时，当最短的可迭代对象耗尽则整个迭代将会停止。 对于函数的输入已经是参数元组的情况，请参阅 itertools.starmap()。

# 定义一个函数，用于将输入乘以2  
def multiply_by_two(x):
    return x * 2

# 创建一个数字列表
numbers = [1, 2, 3, 4, 5]

# 使用map()函数将multiply_by_two函数应用于numbers列表中的每个元素  
doubled_numbers = map(multiply_by_two, numbers)

# 将迭代器转换为列表  
doubled_numbers_list = list(doubled_numbers)

# 输出结果  
print(doubled_numbers_list)  # 输出: [2, 4, 6, 8, 10]

map()函数返回的是一个迭代器，因此如果你多次遍历这个迭代器，它不会重新计算函数应用于每个元素的结果。如果你需要多次使用这些结果，应该先将迭代器转换为列表或其他数据结构。

max(iterable, ***, key=None)

max(iterable, ***, key=None)

max(iterable, ***, default, key=None)

max(arg1, arg2, *args, key=None)

返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。

如果只提供了一个位置参数，它必须是非空 iterable，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。

有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。

如果有多个最大元素，则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 保持一致。

在 3.4 版本发生变更: 增加了 default 仅限关键字形参。

在 3.8 版本发生变更: key 可以为 None。

# 返回列表中的最大值
numbers = [1, 3, 9, 7, 5]
max_number = max(numbers)
print(max_number)  # 输出: 9

# 返回字符串中的最大字符（基于ASCII值）
characters = 'abcd'
max_char = max(characters)
print(max_char)  # 输出: 'd'

# 在字典中使用max()基于键或值
dictionary = {'a': 1, 'b': 20, 'c': 3, 'd': 15}

# 基于键找到最大元素
max_key = max(dictionary.keys())
print(max_key)  # 输出: 'd'

# 基于值找到最大元素
max_value = max(dictionary.values())
print(max_value)  # 输出: 20

# 找到与最大值对应的键
max_key_for_value = max(dictionary, key=dictionary.get)
print(max_key_for_value)  # 输出: 'b'

当比较的对象不是数字时（例如字符串），max()函数将基于对象的自然顺序来确定哪个是最大的。对于自定义对象，你可以通过实现特殊的__gt__（大于）方法来定义它们的比较行为（或者__lt__小于）。

memoryview(object)

class memoryview(object)

返回由给定实参创建的“内存视图”对象。有关详细信息，请参阅 内存视图。

“内存视图”对象提供了一种读取和修改原始数据（如列表或字节串）的方式，而不必制作数据的完整副本。它尤其对于处理大型数据集或需要高效内存管理的场景非常有用。

memoryview() 通常与 bytes 和 bytearray 对象一起使用，但也可以用于其他支持缓冲区协议的对象。

# 与 bytes 和 bytearray 一起使用
# 创建一个 bytes 对象
b = b'Hello World'

# 创建一个 memoryview 对象
m = memoryview(b)

# 访问 memoryview 中的元素
print(m[0])  # 输出: 72，这是 'H' 的 ASCII 值

# 修改 memoryview 中的元素（如果原始对象是 bytearray）
# 注意：bytes 对象是不可变的，所以下面的代码会抛出异常
# b[0] = 65  # 这会抛出 TypeError

# 使用 bytearray 来允许修改
ba = bytearray(b'Hello World')
ma = memoryview(ba)
ma[0] = 65  # 修改第一个字节为 'A' 的 ASCII 值
print(ba)  # 输出: b'Aello World'


# 切片操作，允许你访问原始数据的子集。
ba = bytearray(b'Hello World')
ma = memoryview(ba)

# 创建一个新的 memoryview 对象，它是原始数据的一个切片
ma_slice = ma[1:5]  # 包含 'e', 'l', 'l', 'o'
print(ma_slice.tobytes())  # 输出: b'ello'

# 修改切片中的数据会反映到原始数据上
ma_slice[0] = 69  # 修改为 'E' 的 ASCII 值
print(ba)  # 输出: b'HEllo World'


# 以不同的方式解释相同的数据。
ba = bytearray(b'\x01\x02\x03\x04')
ma = memoryview(ba)

# 使用 'i' 格式（表示有符号整数）来解释数据
ma_int = ma.cast('i')
print(ma_int[0])  # 输出: 67305985，这是将四个字节解释为一个 32 位有符号整数的结果

# 使用 'B' 格式（表示无符号字节）来解释数据（这是默认值）
ma_bytes = ma.cast('B')
print(ma_bytes[0])  # 输出: 1，这是第一个字节的值

在改变格式时，你必须确保新的格式与数据的实际内容相匹配，否则可能会得到无意义的结果。

memoryview() 提供了一种灵活且高效的方式来处理原始数据，尤其适用于需要避免不必要的数据复制或需要直接操作底层数据的场景。

min(iterable, ***, key=None)

min(iterable, ***, key=None)

min(iterable, ***, default, key=None)

min(arg1, arg2, *args, key=None)

返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。

如果只提供了一个位置参数，它必须是 iterable，返回可迭代对象中最小的元素；如果提供了两个及以上的位置参数，则返回最小的位置参数。

有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。

如果有多个最小元素，则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc)[0] 和 heapq.nsmallest(1, iterable, key=keyfunc) 保持一致。

在 3.4 版本发生变更: 增加了 default 仅限关键字形参。

在 3.8 版本发生变更: key 可以为 None。

# 返回列表中的最小值
numbers = [1, 3, 9, 7, 5]
min_number = min(numbers)
print(min_number)  # 输出: 1

当比较的对象不是数字时（例如字符串），min()函数将基于对象的自然顺序来确定哪个是最小的。对于自定义对象，你可以通过实现特殊的__lt__（小于）方法来定义它们的比较行为（或者__gt__大于）。

参考：内置函数 — Python 3.12.2 文档