Python 内置函数

Python有很多内置函数，下面是一些常用的内置函数及其用法示例：

1. abs(x)：返回x的绝对值。

print(abs(-5))  # 输出5

2. len(x)：返回x的长度，x可以是字符串、列表、元组等。

print(len('hello'))  # 输出5
print(len([1, 2, 3]))  # 输出3

3. max(x)：返回x中的最大值，x可以是数字、字符串、列表、元组等。

print(max(1, 2, 3))  # 输出3
print(max([1, 2, 3]))  # 输出3

4. min(x)：返回x中的最小值，x可以是数字、字符串、列表、元组等。

print(min(1, 2, 3))  # 输出1
print(min([1, 2, 3]))  # 输出1

5. sum(x)：返回x中所有元素的和，x可以是数字、列表、元组等。

print(sum([1, 2, 3]))  # 输出6

6. str(x)：将x转换为字符串类型。

print(str(123))  # 输出'123'

7. int(x)：将x转换为整数类型。

print(int('123'))  # 输出123

8. float(x)：将x转换为浮点数类型。

print(float('123.45'))  # 输出123.45

9. list(x)：将x转换为列表类型。

print(list('hello'))  # 输出['h', 'e', 'l', 'l', 'o']

10. tuple(x)：将x转换为元组类型。

print(tuple([1, 2, 3]))  # 输出(1, 2, 3)

11. dict(x)：将x转换为字典类型。

print(dict([(1, 'a'), (2, 'b'), (3, 'c')]))  # 输出{1: 'a', 2: 'b', 3: 'c'}

12. set(x)：将x转换为集合类型。

print(set([1, 2, 3, 3, 4]))  # 输出{1, 2, 3, 4}

13. type(x)：返回x的类型。

print(type(123))  # 输出<class 'int'>

14. range(start, stop[, step])：这个函数返回一个从start开始到stop结束（不包括stop）的数字序列。step是可选的，用于指定序列中的数字之间的间隔。如果step为1，则序列中的数字将是连续的整数。如果step为2，则序列中的数字将是连续的偶数。

例如：

print(list(range(5)))    # 输出：[0, 1, 2, 3, 4]
print(list(range(5, 9))) # 输出：[5, 6, 7, 8]
print(list(range(5, 9, 2))) # 输出：[5, 7]

15. input([prompt])：这个函数返回用户在命令行中输入的一行文本。如果提供了prompt参数，它将被打印出来，提示用户输入。

例如：

name = input("What's your name? ")
print(f"Hello, {name}!")

16. print(*objects[, sep[, end]])：这个函数将objects中指定的所有对象打印到标准输出流中。sep参数是可选的，用于指定在每个对象之间插入的文本。end参数也是可选的，用于指定在最后一个对象之后打印的文本。默认情况下，sep为空格，end为换行符。

例如：

print("Hello", "world!") # 输出：Hello world!
print("apple", "banana", "cherry") # 输出：apple banana cherry

以上只是Python内置函数的一部分，Python内置函数还包括许多其他函数，用于执行各种任务，如文件I/O、数学运算、日期和时间处理等。
17. sorted(iterable[, key][, reverse])：这个函数返回一个排序后的列表，包含可迭代对象iterable中的元素。key参数是可选的，用于指定一个函数，该函数将被用于从每个元素中提取一个比较键。reverse参数也是可选的，用于指定排序的方向，默认为升序。如果reverse为True，则排序将按照降序进行。

例如：

numbers = [5, 1, 9, 3, 7]
print(sorted(numbers)) # 输出：[1, 3, 5, 7, 9]
print(sorted(numbers, key=lambda x: -x)) # 输出：[9, 7, 5, 3, 1]

18. list(iterable)：这个函数返回一个列表，包含可迭代对象iterable中的元素。

例如：

numbers = (5, 1, 9)
print(list(numbers)) # 输出：[5, 1, 9]

19. tuple(iterable)：这个函数返回一个元组，包含可迭代对象iterable中的元素。

例如：

numbers = ['5', '1', '9']
print(tuple(numbers)) # 输出：('5', '1', '9')

20. dict(mapping)：这个函数返回一个字典，其中包含一个键值对映射。mapping可以是一个字典或一个键值对序列。如果mapping是一个字典，则返回一个新的字典，包含mapping中的所有键值对。如果mapping是一个键值对序列，则返回一个新的字典，包含序列中的所有键值对。

例如：

print(dict([('a', 1), ('b', 2)])) # 输出：{'a': 1, 'b': 2}
print(dict({'a': 1, 'b': 2})) # 输出：{'a': 1, 'b': 2}

21. enumerate(iterable)：这个函数返回一个枚举对象，用于在可迭代对象中同时进行迭代和索引。返回的枚举对象包含两个属性，一个是索引值（index），一个是迭代对象的值（value）。

例如：

numbers = ['a', 'b', 'c']
for i, letter in enumerate(numbers):
    print(f"Index: {i}, Value: {letter}")

22. zip(iterable1 [, iterable2 [, …]])：这个函数将可迭代对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。当可迭代对象的元素数量不一致时，返回的列表长度将与最短的输入可迭代对象一致。

例如：

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name}: {age}")

23. map(function, iterable1 [, iterable2 [, …]])：这个函数将可迭代对象中对应的元素传递给函数，然后返回由函数返回值组成的列表。当可迭代对象的元素数量不一致时，返回的列表长度将与最短的输入可迭代对象一致。

例如：

def square(n):
    return n * n
numbers = [1, 2, 3]
print(map(square, numbers))  # 输出：[1, 4, 9]

24. any(iterable)：这个函数用于检查可迭代对象中是否有任何元素为True。如果有任何一个元素为True，则返回True，否则返回False。

例如：

print(any([False, False, True]))  # 输出：True
25. **all(iterable)**：这个函数用于检查可迭代对象中的所有元素是否都为True。如果所有元素都为True，则返回True，否则返回False。

例如：


```python
print(all([True, True, True]))  # 输出：True
print(all([True, False, True]))  # 输出：False

26. dict.get(key[, default])：这个方法返回字典中指定键的值。如果键不在字典中，则返回default值，如果没有指定default值，则返回None。

例如：

my_dict = {'a': 1, 'b': 2}
print(my_dict.get('a'))  # 输出：1
print(my_dict.get('c'))  # 输出：None
print(my_dict.get('c', 'default'))  # 输出：'default'

27. list.append(object)：这个方法将指定的对象添加到列表的末尾。

例如：

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出：[1, 2, 3, 4]

28. list.remove(value)：这个方法从列表中删除第一个出现的指定值。

例如：

my_list = [1, 2, 3, 2]
my_list.remove(2)
print(my_list)  # 输出：[1, 3, 2]

29. list.extend(iterable)：这个方法将可迭代对象中的元素添加到列表的末尾。

例如：

my_list = [1, 2, 3]
my_list.extend([4, 5])
print(my_list)  # 输出：[1, 2, 3, 4, 5]

30. set.union(iterables)：这个方法返回一个新集合，包含该集合和其他可迭代对象中的所有元素。

例如：

my_set = {1, 2, 3}
other_set = {3, 4, 5}
print(my_set.union(other_set))  # 输出：[1, 2, 3, 4, 5]

31. set.intersection(iterables)：这个方法返回一个新集合，包含该集合和指定可迭代对象中的共有元素。

例如：

my_set = {1, 2, 3}
other_set = {3, 4, 5}
print(my_set.intersection(other_set))  # 输出：[3]

32. set.difference(iterables)：这个方法返回一个新集合，包含该集合中存在但其他可迭代对象中不存在的元素。

例如：

my_set = {1, 2, 3}
other_set = {3, 4, 5}
print(my_set.difference(other_set))  # 输出：[1, 2]

33. set.symmetric_difference(iterables)：这个方法返回一个新集合，包含该集合和其他可迭代对象中的不同元素。

例如：

my_set = {1, 2, 3}
other_set = {3, 4, 5}
print(my_set.symmetric_difference(other_set))  # 输出：[1, 2, 4, 5]

34. set.issubset(iterable)：这个方法用于检查该集合是否是另一个可迭代对象的子集。

例如：

my_set = {1, 2, 3}
other_set = {1, 2, 3, 4, 5}
print(my_set.issubset(other_set))  # 输出：True

35. set.issuperset(iterable)：这个方法用于检查该集合是否是另一个可迭代对象的超集。

36. bytes.fromhex(string)：这个方法将一个包含十六进制数字的字符串转换成一个字节对象。

例如：

print(bytes.fromhex('48656c6c6f'))  # 输出：b'Hello'

37. bytes.tohex(byte)：这个方法将一个字节对象转换成一个包含十六进制数字的字符串。

例如：

byte_data = b'Hello'
print(byte_data.tohex())  # 输出：'48656c6c6f'

38. memoryview(object)：这个函数返回一个对缓冲区数据的内存视图对象。可以用来查看、操作内存中的数据，而不需要拷贝数据。

例如：

byte_data = b'Hello'
mv = memoryview(byte_data)
print(mv[1])  # 输出：101，这表示内存中第二个字节是 'e' 的 ASCII 码值

39. struct.pack(format, *args)：这个函数将数据打包成二进制数据。例如，将几个数值打包成一个二进制字符串。

例如：

import struct
print(struct.pack('3i', 1, 2, 3))  # 输出：b'\x00\x00\x01\x00\x00\x02\x00\x00\x03'

40. struct.unpack(format, string)：这个函数解包二进制字符串并返回元组。例如，将二进制字符串解包成几个数值。

例如：

import struct
binary_data = b'\x00\x00\x01\x00\x00\x02\x00\x00\x03'
args = struct.unpack('3i', binary_data)
print(args)  # 输出：(1, 2, 3)

41. re.match(pattern, string)：这个函数用正则表达式模式匹配指定的字符串。如果匹配成功，返回一个匹配对象，否则返回None。

例如：

import re
print(re.match('abc', 'abcdef').group())  # 输出：'abc'

42. re.search(pattern, string)：这个函数扫描字符串，返回第一个成功的匹配。如果匹配成功，返回一个匹配对象，否则返回None。

例如：

import re
print(re.search('abc', 'abcdef').group())  # 输出：'abc'

43. re.findall(pattern, string)：这个函数返回一个列表，包含所有与正则表达式匹配的结果。

例如：

import re
print(re.findall('abc', 'abcdefabcghi'))  # 输出：['abc', 'abc']

44. enumerate(iterable[, start])：这个函数返回一个枚举对象，允许在可迭代对象上进行索引访问。

例如：

for i, value in enumerate(['a', 'b', 'c']):
    print(i, value)  # 输出：0 a, 1 b, 2 c

45. zip(iterable1[, iterable2[, …]])：这个函数将可迭代对象中的元素一一对应，返回一个zip对象。当使用*号操作符展开时，返回一个由元组组成的列表。

例如：

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
print(list(zip(list1, list2)))  # 输出：[1, 'a'], [2, 'b'], [3, 'c']]

46. sorted(iterable, key=None, reverse=False)：这个函数可以对可迭代对象进行排序。key参数可以指定一个函数用于从每个元素中提取一个比较键，reverse参数可以指定排序的方向。

例如：

numbers = [5, 1, 9, 3, 7]
print(sorted(numbers))  # 输出：[1, 3, 5, 7, 9]
print(sorted(numbers, key=lambda x: -x))  # 输出：[9, 7, 5, 3, 1]

47. list(map(function, iterable1, [iterable2, …]))：这个函数将map函数的输出转换为一个列表。map函数会将指定的函数应用于可迭代对象中的每一个元素。

例如：

def square(n):
    return n * n
numbers = [1, 2, 3]
print(list(map(square, numbers)))  # 输出：[1, 4, 9]

48. any(iterable)：这个函数用于检查可迭代对象中是否有任何元素为True。如果有任何一个元素为True，则返回True，否则返回False。

例如：

numbers = [0, 1, 2]
print(any(numbers))  # 输出：True，因为1是True

49. all(iterable)：这个函数用于检查可迭代对象中的所有元素是否都为True。如果所有元素都为True，则返回True，否则返回False。

例如：

numbers = [1, 1, 1]
print(all(numbers))  # 输出：True，因为所有元素都是1

50. dict.update(mapping)：这个方法用来更新字典。mapping参数可以是另一个字典，或者是一个(key, value)元组的列表。

例如：

d = {'a': 1, 'b': 2}
d.update({'b': 3, 'c': 4})
print(d)  # 输出：{'a': 1, 'b': 3, 'c': 4}

51. dict.keys()：这个方法返回一个包含字典所有键的视图对象。

例如：

d = {'a': 1, 'b': 2}
print(d.keys())  # 输出：'dict_keys(['a', 'b'])'

52. dict.values()：这个方法返回一个包含字典所有值的视图对象。

例如：

d = {'a': 1, 'b': 2}
print(d.values())  # 输出：'dict_values([1, 2])'

53. dict.items()：这个方法返回一个包含字典所有(key, value)元组的视图对象。

例如：

d = {'a': 1, 'b': 2}
print(d.items())  # 输出：'dict_items([('a', 1), ('b', 2)])'

54. reversed(sequence)：这个函数返回一个反向迭代器。对于序列类型，如字符串，列表等，可以用来得到反向序列。

例如：

print(list(reversed([1, 2, 3, 4, 5])))  # 输出：[5, 4, 3, 2, 1]

55. enumerate(iterable)：这个函数用于在迭代一个可迭代对象时同时获取元素的索引和值。

例如：

print(list(enumerate('Hello')))  # 输出：[('H', 0), ('e', 1), ('l', 2), ('l', 3), ('o', 4)]

56. zip(iterable1[, iterable2[, …]])：这个函数可以将多个可迭代对象中的元素一一对应，返回一个zip对象。当使用*号操作符展开时，返回一个由元组组成的列表。

例如：

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
print(list(zip(list1, list2)))  # 输出：[(1, 'a'), (2, 'b'), (3, 'c')]

57. map(function, iterable1[, iterable2[, …]])：这个函数将指定的函数应用于可迭代对象中的每一个元素，并返回一个包含结果的列表。

例如：

def square(n):
    return n * n
numbers = [1, 2, 3]
print(list(map(square, numbers)))  # 输出：[1, 4, 9]

58. filter(function, iterable)：这个函数将可迭代对象中的元素传递给指定的函数进行判定，返回值为True的元素被留下来。

例如：

def is_even(n):
    return n % 2 == 0
numbers = [1, 2, 3, 4, 5]
print(list(filter(is_even, numbers)))  # 输出：[2, 4]

59. reduce(function, iterable, initializer)：这个函数会对可迭代对象中的元素进行累积计算。先从可迭代对象中取两个元素，把结果继续和序列的下一个元素做累积计算，如此往复。initializer参数是可选的，用于初始化累积器。

例如：

from functools import reduce
def add(x, y):
    return x + y
numbers = [1, 2, 3, 4, 5]
result = reduce(add, numbers)
print(result)  # 输出：15

60. sorted(iterable, key=None, reverse=False)：这个函数可以对可迭代对象进行排序。key参数可以指定一个函数用于从每个元素中提取一个比较键，reverse参数可以指定排序的方向。

例如：

numbers = [5, 1, 9, 3, 7]
print(sorted(numbers))  # 输出：[1, 3, 5, 7, 9]

61. any(iterable)：这个函数用于检查可迭代对象中是否有任何元素为True。如果有任何一个元素为True，则返回True，否则返回False。

例如：

numbers = [0, 1, 2]
print(any(numbers))  # 输出：True，因为1是True

62. all(iterable)：这个函数用于检查可迭代对象中的所有元素是否都为True。如果所有元素都为True，则返回True，否则返回False。

例如：

numbers = [1, 1, 1]
print(all(numbers))  # 输出：True，因为所有元素都是1