最全Python函数总结和应用（超详细+建议收藏），基本所有内置函数,心得都在这了，踩的坑也在里面了,最后还有函数的魂_python函数大全及详解

前言

每个函数我都给了列子，希望能够看懂。一些难记的函数名我也找了一些完美替代的简单替代
如果有帮助到你是我的荣幸，感谢观看
print(),input(),abs(),sum()之类的应该就不用了吧

基础的函数了解

在Python中，函数是一个可以接收输入参数并执行某个特定任务的代码块。函数可以定义一次并在需要时重复使用，避免了在代码中重复编写相同的逻辑。
Python函数通常由关键字“def”开始定义，并可以接受任意数量的输入参数。函数可以执行任何代码块，并可以返回值或不返回任何值。函数可以嵌套在其他函数或类中，并且可以被其他函数调用。函数是非常重要的程序组件。使用函数可以大大简化程序代码，并提高代码的可读性和可维护性。

惊喜类

下面先来看一些，第一次看会有些惊喜的函数。也可自行跳到各类型里面找函数，第一次看的时候我觉得是真的高级
高阶函数的应用非常广泛，它们可以帮助我们编写更加简洁和灵活的代码。

all() 和 any()

all()和any()，用于判断可迭代对象中的元素是否为True。它们返回布尔值True或False

具体的判断规则如下：
all(iterable)：如果可迭代对象中的所有元素都为True，则返回True，否则返回False。如果可迭代对象为空，则返回True。
any(iterable)：如果可迭代对象中的至少一个元素为True，则返回True，否则返回False。如果可迭代对象为空，则返回False。

实例演示

numbers = [1, 2, 3, 4, 5]
if all(num > 0 for num in numbers):
    print("All numbers are positive")
else:
    print("There are some non-positive numbers")

if any(num > 4 for num in numbers):
    print("At least one number is greater than 4")
else:
    print("No number is greater than 4")
在上面的列子中，第一个if语句使用all()函数判断列表中的所有元素是否为正数，如果是，则输出"All numbers are positive"，否则输出"There are some non-positive numbers"。第二个if语句使用any()函数判断列表中是否有元素大于4，如果有，则输出"At least one number is greater than 4"，否则输出"No number is greater than 4"。
1
2
3
4
5
6
7
8
9
10
11

lambda函数

Lambda函数是一种匿名函数，也就是没有名字的函数。它通常被用来作为参数传递给其他函数，或者在需要一个简短的函数时使用。Lambda函数通常只有一行代码，并且可以使用简洁的语法来定义。

我们可以将Lambda函数看作是一个可执行的表达式，它接受一些输入参数并返回一个结果。Lambda函数可以接受任意数量的参数，但是只能返回一个结果。

Lambda函数的基本语法如下：

lambda arguments: expression
其中，arguments是Lambda函数的输入参数
，expression是Lambda函数的执行体，它会被执行并返回结果。
lambda函数可以使用常规的函数功能，例如控制流语句、条件语句等。
1
2
3
4

下面是一个简单的Lambda函数示例，它将输入参数x加上5并返回结果：

lambda x: x + 5
这个Lambda函数可以像下面这样使用：
add_five = lambda x: x + 5
result = add_five(10)
print(result)   # 输出 15
1
2
3
4
5

在这个例子中，我们首先定义了一个Lambda函数add_five，它将输入参数加上5并返回结果。然后我们使用这个函数来计算10加5的结果。

总之，lambda函数是一种简洁、灵活的函数定义方式，可以用来在代码中定义简单的函数。当它配合一些其他的高阶函数更是神效

sorted()函数

sorted()是一个内置函数，它用于对可迭代对象进行排序。
sorted()函数接受一个可迭代对象作为参数，并返回一个新的已排序的列表。

注意，sorted()函数不会改变原始的可迭代对象，而是返回一个新的已排序的列表。

sorted()函数的常见用法如下：

sorted(iterable, key=None, reverse=False)
iterable: 需要排序的可迭代对象，例如列表、元组、集合、字典等。
key（可选参数）: 用于指定排序的关键字。key是一个函数，它将作用于iterable中的每个元素，并返回一个用于排序的关键字。默认为None，表示按照元素的大小进行排序。
reverse（可选参数）: 用于指定排序的顺序。如果设置为True，则按照逆序排序。默认为False，表示按照正序排序。
1
2
3
4

运用实例

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出结果为 [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

words = ["apple", "banana", "cherry", "date"]
sorted_words = sorted(words, key=len)
print(sorted_words)  # 输出结果为 ["date", "apple", "banana", "cherry"]

numbers = [(1, 2), (3, 4), (2, 1), (4, 3)]
sorted_numbers = sorted(numbers, key=lambda x: x[1])
print(sorted_numbers)  # 输出结果为 [(2, 1), (1, 2), (4, 3), (3, 4)]
在上面的示例中，第一个示例对一个整数列表进行排序，第二个示例对一个字符串列表按照字符串长度进行排序，第三个示例对一个元组列表按照元组中第二个元素进行排序，其中使用了lambda表达式作为key参数来指定排序方式。
1
2
3
4
5
6
7
8
9
10
11
12

map()函数

map(函数名，可迭代对象) 是函数名不用加（
map函数是一种高阶函数，它接受一个函数和一个可迭代对象作为参数，返回一个新的可迭代对象，
其中每个元素都是将原可迭代对象中的元素应用给定函数后的结果。
可以简单理解为对可迭代对象中的每个元素都执行同一个操作，返回一个新的结果集合。
需要注意的是，map函数返回的是一个迭代器对象，因此如果要使用它的结果，需要将它转换为一个列表list()、元组tuple()或集合set()和其他可迭代对象。

map函数的一些应用
1.用来批量接收变量
n,m = map(int,input().split())

2.对可迭代对象进行批量处理返回列表map
m = map("".join,[["a","b","c"],["d","e","f"]])
print(m) -> ["abc","def"]

3.配合lambda函数达到自己想要的效果
numbers = [1, 2, 3, 4, 5]
doubled_numbers = map(lambda x: x * 2, numbers)
print(list(doubled_numbers))  -> [2, 4, 6, 8, 10]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

filter()函数

filter() 函数是 Python 内置函数之一，它用于过滤序列中的元素，返回一个满足条件的新序列。

filter() 函数的语法如下：

filter(function, iterable)
1

其中，function 是一个函数，接受一个参数，并返回 True 或 False。iterable 是一个序列，可以是列表、元组、集合、字符串等。

filter() 函数的工作原理是对序列 iterable 中的每个元素，都调用函数 function 进行判断，如果 function 返回 True，则将该元素添加到结果序列中，否则丢弃该元素。最后，filter() 函数返回结果序列。

下面是一个例子，使用 filter() 函数过滤出列表中的偶数：

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = filter(lambda x: x % 2 == 0, my_list)
print(list(result))  # 输出 [2, 4, 6, 8, 10]
在这个例子中，lambda x: x % 2 == 0 是一个 lambda 函数，用于判断一个数是否为偶数。filter() 函数将这个 lambda 函数作为参数，对列表 my_list 进行过滤，最后返回一个新列表，其中包含 my_list 中所有的偶数。
1
2
3
4

reduce()函数

reduce() 函数是 Python fuctools模块中的，用于对一个可迭代对象中的所有元素进行累积操作。具体而言，reduce() 函数将可迭代对象中的前两个元素传递给指定的函数进行处理，然后将处理结果与可迭代对象中的下一个元素进行处理，直到处理完所有元素，最终返回累积结果。

reduce() 函数的语法如下：

reduce(function, iterable[, initializer])
其中，function 是一个需要接受两个参数的函数，用于对可迭代对象中的元素进行处理。
iterable 是一个可迭代对象，包含要处理的元素。initializer 是可选的初始值，用于指定累积结果的初始值。
1
2
3

下面是一个使用 reduce() 函数计算阶乘的示例：
from functools import reduce
def factorial(n):
    return reduce(lambda x, y: x * y, range(1, n+1))
print(factorial(5)) # 输出 120
1
2
3
4
5

在上面的示例中，我们使用 reduce() 函数和一个 lambda 函数计算了 $5!$。 reduce() 函数的第一个参数是一个匿名函数，用于将前两个元素相乘，接着将结果与下一个元素相乘，直到所有元素都被处理完毕。最终的结果为 $1\times 2\times 3\times 4\times 5=120$。

需要注意的是，如果可迭代对象中的元素只有一个，那么 reduce() 函数不会对该元素进行任何操作，并返回该元素。如果可迭代对象为空，而且没有指定 initializer，则 reduce() 函数会抛出 TypeError 异常。

eval()函数

eval() 函数可以执行任意代码，包括危险的代码
因此在使用时需要谨慎。特别是当代码中包含用户输入时，应该先对输入进行安全性检查，以防止注入攻击。
1
2

eval() 函数是 Python 中的一个内置函数，用于执行一段字符串类型的 Python 代码，并返回代码的执行结果。

eval() 函数的语法格式如下：

eval(expression, globals=None, locals=None)
其中，expression 是要执行的字符串代码，globals 和 locals 分别是全局和局部变量的字典，可以用于控制代码的执行环境。这两个参数都是可选的，如果不指定则默认使用当前的全局和局部变量。
1
2

下面是一个简单的例子，展示了如何使用 eval() 函数执行一个简单的数学表达式：

result = eval("2 + 3 * 4")
print(result)  # 输出 14
在这个例子中，eval() 函数执行了字符串 "2 + 3 * 4" 中的数学表达式，并返回了结果 14。
1
2
3

除了数学表达式之外，eval() 函数还可以执行任意有效的 Python 代码。例如，下面的例子演示了如何使用 eval() 函数执行一个简单的条件语句：

x = 10
result = eval("x > 5")
print(result)  # 输出 True
在这个例子中，eval() 函数执行了字符串 "x > 5" 中的条件表达式，并返回了结果 True。
1
2
3
4

zip函数

zip()用于将多个可迭代对象中对应位置的元素打包成一个元组，并返回一个新的可迭代对象。

zip()函数的语法如下：

zip(*iterables)

其中，iterables是一个或多个可迭代对象，可以是列表、元组、集合、字符串或其他可迭代对象。
zip()函数返回一个新的可迭代对象，其中每个元素都是对应位置上输入的可迭代对象中的元素组成的元组。返回的可迭代对象的长度等于最短的可迭代对象的长度。
1
2
3
4

举个列子：

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

# Output:
# Alice is 25 years old
# Bob is 30 years old
# Charlie is 35 years old
1
2
3
4
5
6
7
8
9

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped = zip(list1, list2)
print(list(zipped))

# Output: [(1, 'a'), (2, 'b'), (3, 'c')]
在第一个示例中，我们使用zip()函数将两个列表中对应位置上的元素打包成一个元组，并遍历输出每个人的姓名和年龄。
在第二个示例中，我们将两个列表中的元素打包成一个新的列表，并输出结果。
1
2
3
4
5
6
7
8

lambda函数-进阶讲解（配合）

如果有一个列表T,里有很多的无序的元组，你要对其降序排序然后输出，单纯的用map 和 sorted 可无法穿多余的参数
因为我们知道map只能接收一个函数名，那有什么办法呢？那就是将lambda当作两个高阶函数的胶水，让另一个高阶函数可以穿多于的参数
配合自定义的函数也很好用

T = [(1,2,3,4,5),(5,9,4,3,4,6),(7,3,4,5,6)]
a = map(lambda x:sorted(x,reverse=True),T)
print(list(a))
>>[[5, 4, 3, 2, 1], [9, 6, 5, 4, 4, 3], [7, 6, 5, 4, 3]]
1
2
3
4

常用类

经常使用的一些函数稍微高级一点点

enumerate() 函数

enumerate() 它可以将一个可迭代对象（如列表、元组或字符串）转换为一个枚举对象，同时返回每个元素的索引和对应的值。

enumerate() 函数的语法如下：

enumerate(iterable, start=0)
其中，iterable 是要枚举的可迭代对象，start 是可选参数，表示枚举起始值，默认为 0。
1
2

enumerate() 函数返回的是一个枚举对象，可以通过迭代该对象来依次获取每个元素的索引和值。具体使用方法如下：

fruits = ['apple', 'banana', 'orange']

for index, fruit in enumerate(fruits):
    print(index, fruit)
运行结果为：
Copy code
0 apple
1 banana
2 orange
print(enumerate(fruits)) #可以自己想想是什么
1
2
3
4
5
6
7
8
9
10

在上述示例中，enumerate() 函数将列表 fruits 转换为一个枚举对象，然后在 for 循环中使用了 enumerate() 函数返回的索引和值。通过这种方式，我们可以方便地获取每个元素的索引值和对应的值。

ASCII码的函数

这个虽然简单确时不时能用上
ord() # 接收字符转换ASCII码
chr() # 接收ASCII码转换字符

一些应用
[chr(i) for i in range(ord("a"),ord("b")+1)] -> 就算记不到ASCII也可快速生成字母表 # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']


生成随机字符串：使用 chr() 函数结合random随机函数库，可以生成随机的字符串，用于测试或其他用途。
1
2
3
4
5
6
7
8
9

转进制函数

其它进制通用转10进制
int("x",y) # x是你要转的数，而y是这个数是由什么进制表示的，当y为0时就按x的前缀来看如 0bx 二进制,0b 0o 0x,分别是二，八，十六

10进制转其他进制
hex() # 转16
oct() # 转8

有一个函数很适合10进制转其他各种进制
divmod(x,y)
其作用是同时返回两个数的商和余数。
所以要这样接收它的值 a,b = divmod(x,y)

def to_hex(n):
    hex_digits = "0123456789abcdef"
    result = ""
    while n > 0:
        n, r = divmod(n, 16) # 每运行一次就算出一位然后另一位代定，如现在一个数除完16后余数是11，然后商是25，其实16进制没换完前是这样的 （25）c,25是等待继续转的，如果我在运行一次就是(1)9c,然后再来（0）19c,为0了然后退出
        result = hex_digits[r] + result
    return result
    
这个函数来转换就很优雅
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

下面按类型来给函数

这些函数不用全记完，怎么说呢Python那么多函数要记都是恐怖如斯，我建议是你知道它有这个功能就行，然后一些基础的能记下来就行。当然你全记也可以，这当然更好。

以下的全部类型都可以用三元组进行快速创建，写出来的代码也是优雅哈哈！,使用教程我放在这几个类型后面了

list-列表

Python中的list是一个非常重要的数据类型，可以用来存储多个值，包括数字、字符串、对象等等。
以下是一些常见的list函数及其示例：

append() - 将一个元素添加到list的末尾
fruits = ['apple', 'banana', 'cherry']
fruits.append('orange')
print(fruits) # ['apple', 'banana', 'cherry', 'orange']

extend() - 将一个list的所有元素添加到另一个list的末尾
fruits = ['apple', 'banana', 'cherry']
more_fruits = ['orange', 'mango', 'grape']
fruits.extend(more_fruits)
print(fruits) # ['apple', 'banana', 'cherry', 'orange', 'mango', 'grape']

insert() - 在指定的位置插入一个元素
fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, 'orange')
print(fruits) # ['apple', 'orange', 'banana', 'cherry']

remove() - 删除指定的元素
fruits = ['apple', 'banana', 'cherry']
fruits.remove('banana')
print(fruits) # ['apple', 'cherry']

pop() - 删除指定位置的元素（默认为最后一个元素），并返回该元素的值
fruits = ['apple', 'banana', 'cherry']
last_fruit = fruits.pop()
print(last_fruit) # 'cherry'
print(fruits) # ['apple', 'banana']

index() - 返回指定元素在list中的索引位置
fruits = ['apple', 'banana', 'cherry']
banana_index = fruits.index('banana')
print(banana_index) # 1

count() - 返回指定元素在list中出现的次数
fruits = ['apple', 'banana', 'cherry', 'banana', 'banana']
banana_count = fruits.count('banana')
print(banana_count) # 3

sort() - 将list中的元素进行排序
fruits = ['apple', 'banana', 'cherry']
fruits.sort()
print(fruits) # ['apple', 'banana', 'cherry']

reverse() - 将list中的元素翻转
fruits = ['apple', 'banana', 'cherry']
fruits.reverse()
print(fruits) # ['cherry', 'banana', 'apple']

len() - 返回list中元素的数量
fruits = ['apple', 'banana', 'cherry']
num_fruits = len(fruits)
print(num_fruits) # 3

copy() - 返回一个list的副本
fruits = ['apple', 'banana', 'cherry']
fruits_copy = fruits.copy()
print(fruits_copy) # ['apple', 'banana', 'cherry']

clear() - 删除list中的所有元素
fruits = ['apple', 'banana', 'cherry']
fruits.clear()
print(fruits) # []

max() - 返回list中最大的元素
numbers = [5, 10, 3, 8, 15]
max_num = max(numbers)
print(max_num) # 15

min() - 返回list中最小的元素
numbers = [5, 10, 3, 8, 15]
min_num = min(numbers)
print(min_num) # 3

sum() - 返回list中所有元素的和（仅适用于数字类型的list）
numbers = [5, 10, 3, 8, 15]
sum_nums = sum(numbers)
print(sum_nums) # 41

any() - 如果list中至少有一个元素为True，则返回True
bool_list = [False, True, False]
has_true = any(bool_list)
print(has_true) # True

all() - 如果list中的所有元素都为True，则返回True
bool_list = [True, True, True]
all_true = all(bool_list)
print(all_true) # True

enumerate() - 返回一个枚举对象，其中包含list中每个元素的索引和值
fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(index, fruit)
# 0 apple
# 1 banana
# 2 cherry


map() - 对list中的每个元素应用函数，并返回结果的list
numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x ** 2, numbers))
print(squares) # [1, 4, 9, 16]

filter() - 返回list中符合条件的元素的子集
numbers = [1, 2, 3, 4, 5, 6]
even_nums = list(filter(lambda x: x % 2 == 0, numbers))
print(even_nums) # [2, 4, 6]

reduce() - 对list中的元素应用函数，将其归约为单个值
from functools import reduce
numbers = [1, 2, 3, 4]
sum_nums = reduce(lambda x, y: x + y, numbers)
print(sum_nums) # 10

zip() - 将多个list的元素配对，返回一个元组的list
fruits = ['apple', 'banana', 'cherry']
colors = ['red', 'yellow', 'red']
fruit_colors = list(zip(fruits, colors))
print(fruit_colors) # [('apple', 'red'), ('banana', 'yellow'), ('cherry', 'red')]

sorted() - 返回一个新的已排序的list
numbers = [3, 2, 1, 5, 4]
sorted_nums = sorted(numbers)
print(sorted_nums) # [1, 2, 3, 4, 5]

join() - 将list中的字符串连接成一个字符串
fruits = ['apple', 'banana', 'cherry']
fruit_string = ', '.join(fruits)
print(fruit_string) # 'apple, banana, cherry'

slice() - 返回一个list的子集，根据索引的起始和结束位置
fruits = ['apple', 'banana', 'cherry', 'orange', 'grape']
subset = fruits[1:4]
print(subset) # ['banana', 'cherry', 'orange']

希望这些函数能够帮助你更好地使用Python的list类型。
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

tuple-元组

Python元组是不可变序列，它不支持在原地修改元素。因此，Python元组的函数相对较少。
以下是Python元组的所有函数：
count
count方法返回元组中指定元素的数量。
my_tuple = ('apple', 'banana', 'apple', 'orange', 'banana', 'apple')
count = my_tuple.count('apple')
print(count)  # 输出：3

index
index方法返回元组中指定元素第一次出现的索引。
my_tuple = ('apple', 'banana', 'apple', 'orange', 'banana', 'apple')
index = my_tuple.index('orange')
print(index)  # 输出：3

len
len方法返回元组中元素的数量。
my_tuple = ('apple', 'banana', 'orange')
length = len(my_tuple)
print(length)  # 输出：3

tuple
tuple函数用于将一个可迭代对象转换为元组。
my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple)  # 输出：(1, 2, 3)

zip
zip函数将多个可迭代对象的对应元素打包成元组，返回一个包含这些元组的迭代器。
fruits = ('apple', 'banana', 'orange')
quantities = (5, 2, 3)
prices = (1.2, 1.5, 0.8)
# 将三个元组打包成一个迭代器
inventory = zip(fruits, quantities, prices)
# 遍历迭代器中的元素
for item in inventory:
    print(item)
# 输出：
# ('apple', 5, 1.2)
# ('banana', 2, 1.5)
# ('orange', 3, 0.8)

sorted
sorted函数返回一个按指定顺序排序后的可迭代对象，可以接收一个关键字参数key来指定排序的关键字。
my_tuple = (3, 2, 1)
sorted_tuple = sorted(my_tuple)
print(sorted_tuple)  # 输出：[1, 2, 3]
# 按绝对值大小排序
my_tuple = (-3, 2, -1)
sorted_tuple = sorted(my_tuple, key=abs)
print(sorted_tuple)  # 输出：[-1, 2, -3]

reversed
reversed函数返回一个迭代器，包含按相反顺序排列的可迭代对象中的元素。
my_tuple = ('apple', 'banana', 'orange')
reversed_tuple = reversed(my_tuple)
for item in reversed_tuple:
    print(item)
# 输出：
# orange
# banana
# apple

继续
max
max函数返回可迭代对象中最大的元素，可以接收一个关键字参数key来指定比较的关键字。
my_tuple = (3, 2, 1)
max_element = max(my_tuple)
print(max_element)  # 输出：3
# 按绝对值大小比较
my_tuple = (-3, 2, -1)
max_element = max(my_tuple, key=abs)
print(max_element)  # 输出：-3

min
min函数返回可迭代对象中最小的元素，可以接收一个关键字参数key来指定比较的关键字。
my_tuple = (3, 2, 1)
min_element = min(my_tuple)
print(min_element)  # 输出：1
# 按绝对值大小比较
my_tuple = (-3, 2, -1)
min_element = min(my_tuple, key=abs)
print(min_element)  # 输出：-1

sum
sum函数返回可迭代对象中所有元素的和，可以接收一个可选参数start指定求和的起始值。
my_tuple = (3, 2, 1)
sum_value = sum(my_tuple)
print(sum_value)  # 输出：6
# 指定求和的起始值为5
my_tuple = (3, 2, 1)
sum_value = sum(my_tuple, 5)
print(sum_value)  # 输出：11

all
all函数返回可迭代对象中所有元素都为真值（即不为False、0、None等）时返回True，否则返回False。
my_tuple = (1, 2, 3)
result = all(my_tuple)
print(result)  # 输出：True
my_tuple = (1, 2, 0)
result = all(my_tuple)
print(result)  # 输出：False

any
any函数返回可迭代对象中至少有一个元素为真值（即不为False、0、None等）时返回True，否则返回False。
my_tuple = (0, False, None)
result = any(my_tuple)
print(result)  # 输出：False
my_tuple = (0, False, 1)
result = any(my_tuple)
print(result)  # 输出：True
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

dict-字典

Python字典（dictionary）是一个无序的键值对集合。Python中有许多内置函数可以操作字典。
以下是一些常用的函数及其示例：

创建字典
# 创建一个空字典
my_dict = {}

# 创建一个非空字典
my_dict = {'apple': 1, 'banana': 2, 'orange': 3}

访问字典
# 获取字典中指定键对应的值
value = my_dict['apple']
print(value)  # 输出：1

# 使用get()方法获取字典中指定键对应的值
value = my_dict.get('banana')
print(value)  # 输出：2

# 获取字典中所有键的列表
keys = list(my_dict.keys())
print(keys)  # 输出：['apple', 'banana', 'orange']

# 获取字典中所有值的列表
values = list(my_dict.values())
print(values)  # 输出：[1, 2, 3]

修改字典
# 修改字典中指定键对应的值
my_dict['apple'] = 4
print(my_dict)  # 输出：{'apple': 4, 'banana': 2, 'orange': 3}

# 使用update()方法修改字典中的值
my_dict.update({'apple': 5, 'orange': 6})
print(my_dict)  # 输出：{'apple': 5, 'banana': 2, 'orange': 6}

删除字典
# 删除字典中指定键值对
del my_dict['apple']
print(my_dict)  # 输出：{'banana': 2, 'orange': 6}

# 删除字典中所有键值对
my_dict.clear()
print(my_dict)  # 输出：{}

其他函数
# 获取字典中键值对的数量
num_items = len(my_dict)
print(num_items)  # 输出：0

# 检查字典中是否存在指定键
if 'apple' in my_dict:
    print('Yes')  # 输出：No

# 复制字典
new_dict = my_dict.copy()
print(new_dict)  # 输出：{}


遍历字典
# 遍历字典中所有键值对
for key, value in my_dict.items():
    print(key, value)

# 遍历字典中所有键
for key in my_dict.keys():
    print(key)

# 遍历字典中所有值
for value in my_dict.values():
    print(value)

设置默认值
# 使用setdefault()方法设置默认值
my_dict.setdefault('apple', 0)
print(my_dict)  # 输出：{'banana': 2, 'orange': 6, 'apple': 0}

合并字典
# 使用update()方法合并字典
dict1 = {'apple': 1, 'banana': 2}
dict2 = {'orange': 3, 'pear': 4}
dict1.update(dict2)
print(dict1)  # 输出：{'apple': 1, 'banana': 2, 'orange': 3, 'pear': 4}

# 使用**运算符合并字典
dict1 = {'apple': 1, 'banana': 2}
dict2 = {'orange': 3, 'pear': 4}
dict3 = {**dict1, **dict2}
print(dict3)  # 输出：{'apple': 1, 'banana': 2, 'orange': 3, 'pear': 4}

字典推导式
# 创建字典推导式
my_dict = {i: i*2 for i in range(5)}
print(my_dict)  # 输出：{0: 0, 1: 2, 2: 4, 3: 6, 4: 8}

反转字典
# 反转字典中的键值对
my_dict = {'apple': 1, 'banana': 2, 'orange': 3}
reversed_dict = {value: key for key, value in my_dict.items()}
print(reversed_dict)  # 输出：{1: 'apple', 2: 'banana', 3: 'orange'}

排序字典
# 按键排序
my_dict = {'apple': 1, 'banana': 2, 'orange': 3}
sorted_dict = {key: my_dict[key] for key in sorted(my_dict)}
print(sorted_dict)  # 输出：{'apple': 1, 'banana': 2, 'orange': 3}

# 按值排序
my_dict = {'apple': 1, 'banana': 2, 'orange': 3}
sorted_dict = {key: value for key, value in sorted(my_dict.items(), key=lambda item: item[1])}
print(sorted_dict)  # 输出：{'apple': 1, 'banana': 2, 'orange': 3}

过滤字典
# 过滤字典中满足条件的键值对
my_dict = {'apple': 1, 'banana': 2, 'orange': 3}
filtered_dict = {key: value for key, value in my_dict.items() if value > 1}
print(filtered_dict)  # 输出：{'banana': 2, 'orange': 3}

计数器
# 使用collections模块中的Counter类创建计数器
from collections import Counter
my_list = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
my_counter = Counter(my_list)
print(my_counter)  # 输出：Counter({'apple': 3, 'banana': 2, 'orange': 1})

# 获取计数器中指定元素的数量
count = my_counter['apple']
print(count)  # 输出：3

# 获取计数器中出现次数最多的元素和出现次数
most_common = my_counter.most_common(1)
print(most_common)  # 输出：[('apple', 3)]
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

set-集合

以下是Python set对象支持的一些常用方法：

add(): 将一个元素添加到set中，如果元素已经存在，什么都不会发生。
fruits = {'apple', 'banana', 'orange'}
fruits.add('kiwi')
print(fruits) # {'orange', 'banana', 'kiwi', 'apple'}

clear(): 移除set中的所有元素。
fruits = {'apple', 'banana', 'orange'}
fruits.clear()
print(fruits) # set()

copy(): 返回set的一个副本。
fruits = {'apple', 'banana', 'orange'}
fruits_copy = fruits.copy()
print(fruits_copy) # {'orange', 'banana', 'apple'}

difference(): 返回一个包含set和另一个set或iterable中不同元素的新set。也可以直接减 eg:fruits - more_fruits
fruits = {'apple', 'banana', 'orange'}
more_fruits = {'banana', 'kiwi', 'pineapple'}
diff_fruits = fruits.difference(more_fruits)
print(diff_fruits) # {'orange', 'apple'}

discard(): 从set中移除一个元素，如果元素不存在，什么都不会发生。
fruits = {'apple', 'banana', 'orange'}
fruits.discard('banana')
print(fruits) # {'orange', 'apple'}

intersection(): 返回一个包含set和另一个set或iterable中共同元素的新set。也可以直接交 eg:fruits & more_fruits
fruits = {'apple', 'banana', 'orange'}
more_fruits = {'banana', 'kiwi', 'pineapple'}
common_fruits = fruits.intersection(more_fruits)
print(common_fruits) # {'banana'}

isdisjoint(): 如果set和另一个set或iterable没有共同元素，返回True，否则返回False。也可以直接交然后判断 eg:return fruits & more_fruits == set()
fruits = {'apple', 'banana', 'orange'}
more_fruits = {'kiwi', 'pineapple'}
print(fruits.isdisjoint(more_fruits)) # True

issubset(): 如果set是另一个set的子集，返回True，否则返回False。
也可以直接交然后判断是不是等于自身 eg:return fruits & more_fruits == fruits
fruits = {'apple', 'banana', 'orange'}
more_fruits = {'banana', 'orange', 'kiwi', 'pineapple'}
print(fruits.issubset(more_fruits)) # False

issuperset(): 如果set是另一个set的超集，返回True，否则返回False。
fruits = {'apple', 'banana', 'orange'}
more_fruits = {'banana', 'orange'}
print(fruits.issuperset(more_fruits)) # True

pop(): 移除并返回set中的一个元素，如果set为空，抛出KeyError异常。
fruits = {'apple', 'banana', 'orange'}
print(fruits.pop()) # 'orange'
print(fruits) # {'apple', 'banana'}

remove(): 从set中移除一个元素，如果元素不存在，抛出KeyError异常。
fruits = {'apple', 'banana', 'orange'}
fruits.remove('banana')
print(fruits) # {'orange', 'apple'}

symmetric_difference(): 返回一个包含set和另一个set或iterable中不重复元素的新set

symmetric_difference_update(): 将set和另一个set或iterable中不重复的元素更新到set中。
fruits = {'apple', 'banana', 'orange'}
more_fruits = {'banana', 'kiwi', 'pineapple'}
fruits.symmetric_difference_update(more_fruits)
print(fruits) # {'orange', 'kiwi', 'pineapple', 'apple'}

union(): 返回一个包含set和另一个set或iterable中所有元素的新set。
不可以+，除了 union() 方法，我们还可以使用 | 运算符来实现两个 set 的并集
fruits = {'apple', 'banana', 'orange'}
more_fruits = {'banana', 'kiwi', 'pineapple'}
all_fruits = fruits.union(more_fruits)
print(all_fruits) # {'kiwi', 'apple', 'pineapple', 'orange', 'banana'}

update(): 将set和另一个set或iterable中所有元素更新到set中。
fruits = {'apple', 'banana', 'orange'}
more_fruits = {'banana', 'kiwi', 'pineapple'}
fruits.update(more_fruits)
print(fruits) # {'kiwi', 'apple', 'pineapple', 'orange', 'banana'}

difference_update(): 将set和另一个set或iterable中不同的元素更新到set中。
fruits = {'apple', 'banana', 'orange'}
more_fruits = {'banana', 'kiwi', 'pineapple'}
fruits.difference_update(more_fruits)
print(fruits) # {'orange', 'apple'}

intersection_update(): 将set和另一个set或iterable中共同的元素更新到set中。
fruits = {'apple', 'banana', 'orange'}
more_fruits = {'banana', 'kiwi', 'pineapple'}
fruits.intersection_update(more_fruits)
print(fruits) # {'banana'}

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

Python的推导式的优雅

在Python中，推导式是一种方便的语法结构，用于根据一些规则来构建新的序列对象。Python支持以下几种类型的推导式：
列表推导式
列表推导式允许您根据一些规则来创建一个新的列表。它的语法为：
css
[表达式 for 变量 in 序列对象 if 条件]
其中，表达式是根据变量计算的值，变量是迭代序列对象的每个元素，并且如果条件为真，则包含在生成的列表中。
例如，以下列表推导式生成一个由1到10的偶数构成的列表：
even_numbers = [x for x in range(1, 11) if x % 2 == 0]print(even_numbers)  # 输出 [2, 4, 6, 8, 10]

字典推导式
字典推导式允许您根据一些规则创建一个新的字典。它的语法为：
css
{键表达式: 值表达式 for 变量 in 序列对象 if 条件}
其中，键表达式和值表达式是根据变量计算的值，变量是迭代序列对象的每个元素，并且如果条件为真，则包含在生成的字典中。
例如，以下字典推导式生成一个由1到5的整数平方组成的字典：
squares = {x: x ** 2 for x in range(1, 6)}print(squares)  # 输出 {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

集合推导式
集合推导式允许您根据一些规则创建一个新的集合。它的语法与列表推导式类似，只是用花括号替代了方括号。
例如，以下集合推导式生成一个由1到10的奇数组成的集合：
odd_numbers = {x for x in range(1, 11) if x % 2 == 1}print(odd_numbers)  # 输出 {1, 3, 5, 7, 9}

生成器表达式
生成器表达式与列表推导式类似，但是它生成一个生成器对象，而不是一个列表对象。它的语法与列表推导式类似，只是用圆括号替代了方括号。例如，以下生成器表达式生成一个由1到10的偶数构成的生成器对象：
even_numbers = (x for x in range(1, 11) if x % 2 == 0)for num in even_numbers:    print(num)  # 输出 2, 4, 6, 8, 10hello
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

Python的推导式应用

我现在有四个字母，我要他们以三三的全部排列，有Python的推导式只需要一行

[i + j + k for i in "ABCD" for j in "ABCD" if i != j for k in "ABCD" if k not in j + i]
>>>['ABC', 'ABD', 'ACB', 'ACD', 'ADB', 'ADC', 'BAC', 'BAD', 'BCA', 'BCD', 'BDA', 'BDC', 'CAB', 'CAD', 'CBA', 'CBD', 'CDA', 'CDB', 'DAB', 'DAC', 'DBA', 'DBC', 'DCA', 'DCB']
1
2

如果只要组合呢？
利用set集合不就行了

a = [i + j + k for i in "ABCD" for j in "ABCD" if i != j for k in "ABCD" if k not in j + i]
set(list(map(lambda x:tuple(sorted(x)),a)))
1
2

字符串处理的函数

大小写处理
s,s1 = "aaaBBBccc", "123456"
s.upper() # 将字符串全部大写 AAABBBCCC
s.lower() # 将字符串全部小写 aaabbbccc
s.swapcase() # 将s大小写反转 AAAbbbCCC

字符判断
isdigit() , isnumeric # 判断字符串中是否全是数字字符
print(list(map(lambda x:x.isdigit(),[Z,Z2]))) # [False, True]
isdigit：是否为数字字符，包括Unicode数字，单字节数字，双字节全角数字，不包括汉字数字，罗马数字、小数
isnumeric：是否所有字符均为数值字符，包括Unicode数字、双字节全角数字、罗马数字、汉字数字，不包括小数。

s.isalpha() # 判断字符串中是否全为字母
s.isalnum() # 判断字符串中是否全为字母或者数字
1
2
3
4
5
6
7
8
9
10
11
12
13
14

你真的会用函数吗？理解下面才是真正理解函数

如果上面那些是函数的型，那么下面这些就是函数的魂了！

可以传任意参数的函数

自己多调用试试

*args用于将可变数量的参数传递给函数。它用于传递非关键词的可变长度参数列表 eg:传入list
**kwargs用于传递带关键字的可变长度参数列表。我们使用带有双星的名称kwargs 。
		原因是双星允许我们传递关键字参数（以及任意数量的关键字参数）eg:传入dict
def fuc(*argv):
    for arg in argv:
        print(arg)
fuc('One', 'Two', 'Three', 'Four') # 自己掉用试试

def myFun(**kwargs):
    for key, value in kwargs.items():
        print("%s == %s" % (key, value))
myFun(first='One', mid='Two', last='Three')

同时放入*argv和**kwargs,*只能在**的前面
def myFun(*args, **kwargs):
    print("args: ", args)
    print("kwargs: ", kwargs)
myFun("geeks","for","geeks")
myFun(first="Geeks",mid="for",last="Geeks")
myFun('geeks', 'for', 'geeks', first="Geeks", mid="for", last="Geeks")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

函数是对象

什么是函数，函数就是对象

python一切皆是对象
函数当然也是
a = max()  ; a(x,y) # 报错
a = max  ; a(x,y)	# 成功运行
函数加括号是调用，如果没有那它只是对象甚至可以这样
1
2
3
4
5

函数调用函数

函数可以被返回

从函数中返回函数
其实并不需要在一个函数里去执行另一个函数，我们也可以将其作为输出返回出来：
def one_def(num=1):
    def two_def(two):
        return "now you are in the function two_def(){}".format(two)
 
    def three_def(three):
        return "now you are in the function two_def(){}".format(three)
 
    if name == "yasoob":
        return two_def
    else:
        return three_def
one_def(1) -> <function one_def.<locals>.two_def at 0x000001BE5FBF8EA0>
one_def(2) -> <function one_def.<locals>.three_def at 0x000001BE5FBF8F40>

能返回函数我们就可以继续调用返回的这个函数
one_def(1)(hello) -> "now you are in the function two_def()Hello"
one_def(2)(Hi)    -> "now you are in the function two_def()HI"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

函数也可以把函数作为参数

函数可以作为参数

def RUN(func):
    print("OK")
    print(func())
def Hello():
    return "Hello"
RUN(Hello)
->
"OK"
"Hello"
1
2
3
4
5
6
7
8
9

装饰器（很重要）

装饰器语法先看不用理解

def yyy(fun):
	def zzz(*a,**b):
		fun(*a,**b)
	return zzz
@yyy
def xxx(n):
	pass
1
2
3
4
5
6
7

这个很重要所以才放的最后
Python的装饰器（Decorator）是一种特殊的函数，它可以接受一个函数作为输入，并返回一个新的函数作为输出。它可以在不改变原函数代码的情况下，增加一些额外的功能，例如计时、记录日志、缓存结果等，特别是很多函数都要加的一些辅助函数。
装饰器可以使代码更加简洁和可维护，因为它们可以让开发者把代码的不同部分分开，使得代码更加模块化。例如，如果我们有多个函数需要进行某种操作，我们可以使用装饰器来把这个操作抽象出来，并应用于这些函数。
先来看这个函数，没理解先不要慌

def my_decorator(func):
    def wrapper():
        print("Before the function is called.")
        func()
        print("After the function is called.")
    return wrapper

@my_decorator 
def say_hello():
    print("Hello World!")

say_hello()
1
2
3
4
5
6
7
8
9
10
11
12

在这个代码里面，@my_decorator 等效于执行了这个操作:

def my_decorator(func):
    def wrapper():
        print("Before the function is called.")
        func()
        print("After the function is called.")
    return wrapper
    
def say_hello():
    print("Hello World!")
say_hello = my_decorator(say_hello)
say_hello()
1
2
3
4
5
6
7
8
9
10
11

就是@my_decorator
在这个例子中，my_decorator 是一个装饰器函数，它接受一个函数作为参数，并返回一个新的函数 wrapper。wrapper 函数在原函数 say_hello 的前后分别打印了一些信息。

通过在 say_hello 函数的定义前加上 @my_decorator，我们就把 say_hello 函数传递给了 my_decorator 装饰器函数，并将其返回的新函数 wrapper 赋值给了 say_hello，使得我们可以直接调用 say_hello() 来执行被装饰的函数，并在执行前后打印一些信息。

装饰器的应用非常广泛，它们可以用于缓存结果、检查参数、验证身份、重试操作、限制频率等等。因为它们可以让我们在不改变原函数代码的情况下增加额外的功能，所以它们是Python 编程中的一个非常重要的概念。

我们来看个记录比较递归和动态算法那个快的装饰器，随便看看装饰器遇到递归怎么办

题目是:一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

import time
# 记时间函数
def time_f(fuc):
    def time_f2(a):
        s = time.time()
        r = fuc(a)
        e = time.time()
        print(e - s, r)

    return time_f2

@time_f #递归算法
def back_main(n):
    def back(n):
        if n == 1 or n == 0:
            return 1
        elif n == 2:
            return 2
        return back(n - 1) + back(n - 2)
    r = back(n)
    return r

@time_f #动态规划
def dp_f(n):
    dp = [0, 1, 2]
    for i in range(3, n + 1):
        dp.append(dp[i - 1] + dp[i - 2])
    return dp[n]
    
back_main(40) #递归算法
dp_f(40) #动态规划

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

时间函数就是辅助函数，而我们用装饰函数的目的就是将辅助函数和主要函数分开，装饰器可以使代码更加简洁和可维护，然后它还可以对很多函数一起加上这个函数
，如果我们有多个函数需要进行某种操作，我们可以使用装饰器来把这个操作抽象出来，并应用于这些函数。
实际上就是用辅助函数将主要函数给包起来，然后把这个辅助函数叫成主要函数。我们用的函数是辅助函数
装饰器很重要，希望可以帮助到你

装饰器配合多进程，报错！！

# coding:utf-8
import time
import os
import multiprocessing
def time_time(func):
    def time_re(*arg,**key):
        start = time.time()
        func(*arg,**key)
        end =time.time()
        print(end-start)
    return time_re

@time_time
def work_a():
    for i in range(10):
        print(i, 'a', os.getpid())
        time.sleep(1)
@time_time
def work_b():
    for i in range(10):
        print(i, 'b', os.getpid())
        time.sleep(1)


if __name__ == '__main__':
    work_a()
    work_b()
    b = work_b
    a = work_a
    a_p = multiprocessing.Process(target=a)  # 子进程1
    b_p = multiprocessing.Process(target=b)  # 子进程2
    # b_p.start()  # 子进程2执行

    for p in (a_p, b_p):
        p.start()

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
34
35
36

这个错误是因为pickle不能序列化local对象。在你的代码中，你使用了装饰器来修改了函数对象，这导致了local对象的产生。当你试图在子进程中执行这些被装饰过的函数时，会出现这个错误。

为了避免这个错误，你可以将被装饰的函数移动到一个单独的模块中，并在需要的时候导入它们。或者你可以使用另一种不会产生local对象的装饰器实现计时功能，例如使用装饰器functools.wraps()来保留函数的元信息。
@functools.wraps()

Python装饰器（decorator）在实现的时候，被装饰后的函数其实已经是另外一个函数了（函数名等函数属性会发生改变），
为了不影响，Python的functools包中提供了一个叫wraps的decorator来消除这样的副作用。
写一个decorator的时候，最好在实现之前加上functools的wrap，它能保留原有函数的名称和函数属性
所以这样写就可以了：
import time
import os
import multiprocessing
import functools

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(end-start)
        return result
    return wrapper

@timer
def work_a():
    for i in range(10):
        print(i, 'a', os.getpid())
        time.sleep(1)

@timer
def work_b():
    for i in range(10):
        print(i, 'b', os.getpid())
        time.sleep(1)

if __name__ == '__main__':
    work_a()
    work_b()
    a_p = multiprocessing.Process(target=work_a)  # 子进程1
    b_p = multiprocessing.Process(target=work_b)  # 子进程2
    

    for p in (a_p, b_p):
        p.start()
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
34
35
36
37
38
39
40

在来总结一下

functools.wraps()是一个装饰器，用于将被装饰的函数的元信息复制到装饰器函数中。它有助于解决使用装饰器时可能出现的一些问题，例如当被装饰的函数有文档说明、名称、模块名、参数列表等元信息时，这些信息可能会在使用装饰器后被覆盖或丢失。

functools.wraps()的语法如下：
def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # some code
        return func(*args, **kwargs)
    return wrapper
使用functools.wraps()将被装饰的函数的元信息复制到装饰器函数中，例如：
@my_decorator
def my_function():
    """This is a docstring."""
    pass

print(my_function.__name__)  # Output: "my_function"
print(my_function.__doc__)   # Output: "This is a docstring."
如果没有使用wraps()，则输出将分别是wrapper和None。因此，使用wraps()能够保留被装饰函数的元信息，使得装饰器更加友好和易于使用。


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

总结

函数用的好可以帮我们解决很多的问题，但是使用的方法确需要更多的了解。本文介绍了许多 Python 常用的内置函数，包括 all() 和 any()、lambda 函数、sorted()、map()、filter()、reduce()、eval()、zip() 等等。
常用类，如 enumerate() 函数、ASCII 码的函数和进制转换函数。深入探讨了 Python 中四种常见的数据类型：list、tuple、dict 和 set，以及 Python 推导式的优雅的应用。
文章还介绍了许多有趣的主题，如字符串处理函数、可变参数的函数、函数是对象、函数调用函数、函数将函数作为参数以及装饰器等。这些主题在 Python 编程中非常重要，可以帮助我们更好地利用函数来编写高效且易于维护的代码。