🎈个人主页：靓仔很忙i
💻B 站主页：👉B站👈
🎉欢迎 👍点赞✍评论⭐收藏
🤗收录专栏：python
🤝希望本文对您有所裨益，如有不足之处，欢迎在评论区提出指正，让我们共同学习、交流进步！

---

一 流程控制

1.1 条件分支

在Python中，条件分支（Conditional Statements）是控制程序流程的重要结构，允许根据特定条件选择性地执行代码块。Python提供了 if、elif 和 else 来实现条件分支。

1.1.1 if 语句

if 语句用于执行一个代码块，如果指定的条件为真（True）。语法如下：

if condition:
    # 如果条件为真时执行的代码块
    statement1
    statement2
    ...

例如：

x = 10
if x > 5:
    print("x 大于 5")

1.1.2. if … else 语句

if … else 语句用于执行两个不同的代码块，根据条件的真假分别执行。语法如下：

if condition:
    # 如果条件为真时执行的代码块
    statement1
    statement2
    ...
else:
    # 如果条件为假时执行的代码块
    statement3
    statement4
    ...

例如：

x = 3
if x > 5:
    print("x 大于 5")
else:
    print("x 小于等于 5")

1.1.3 if … elif … else 语句

if … elif … else 语句用于执行多个条件分支，每个 elif 语句都检查一个新条件，直到找到为真的条件为止。最后的 else 语句是可选的，用于处理所有条件都不为真的情况。语法如下：

if condition1:
    # 如果条件1为真时执行的代码块
    statement1
    statement2
    ...
elif condition2:
    # 如果条件2为真时执行的代码块
    statement3
    statement4
    ...
elif condition3:
    # 如果条件3为真时执行的代码块
    statement5
    statement6
    ...
else:
    # 如果所有条件都不为真时执行的代码块
    statement7
    statement8
    ...

例如：

x = 10
if x > 15:
    print("x 大于 15")
elif x > 5:
    print("x 大于 5，但小于等于 15")
else:
    print("x 小于等于 5")

注意事项

• 每个条件语句后面都需要使用冒号 :。
• 每个代码块（缩进的部分）中的语句数量可以是任意的，但必须保持一致的缩进级别。
• elif 和 else 部分是可选的，可以根据需要省略。

条件分支允许根据不同的情况执行不同的代码逻辑，是编写程序时非常常用和重要的控制结构之一。

1.2 循环

在Python中，循环（Loops）是一种控制流程的结构，允许多次执行同一段代码。Python支持两种主要的循环类型：for 循环和 while 循环。

1.2.1 for 循环

for 循环用于遍历任何可迭代对象（iterable），如列表、元组、字符串等，逐个访问其元素，并执行特定的代码块。语法如下：

for element in iterable:
    # 每次迭代时执行的代码块
    statement1
    statement2
    ...

其中 element 是每次迭代中当前的元素，iterable 是要迭代的可迭代对象。例如：

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

上述代码将输出：

apple
banana
cherry

range() 函数结合 for 循环
常用于循环指定次数的情况，可以结合 range() 函数生成一系列数字。range() 函数可以指定起始值、结束值（不包括）、步长等。例如：

for i in range(5):
    print(i)

上述代码将输出：

0
1
2
3
4

1.2.2 while 循环

while 循环用于在条件为真（True）时重复执行代码块，直到条件变为假（False）。语法如下：

while condition:
    # 每次循环时执行的代码块
    statement1
    statement2
    ...

其中 condition 是一个布尔表达式，当条件为真时，循环会继续执行。例如：

i = 1
while i <= 5:
    print(i)
    i += 1

上述代码将输出：

1
2
3
4
5

1.2.3 循环控制语句

在循环中，可以使用以下控制语句来改变循环的执行流程：

• break：跳出当前循环，不再执行剩余的循环体代码。
• continue：跳过当前循环中的剩余代码，并开始下一次循环。
• pass：表示空操作，什么也不做，可以用作占位符，保持代码结构完整。

这些控制语句通常与条件语句结合使用，以便根据特定条件在循环中执行特定的操作。

1.2.4 示例

下面是一个结合 for 循环和 if 条件语句的示例，用于打印列表中的偶数：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for num in numbers:
    if num % 2 == 0:
        print(num)

输出结果为：

2
4
6
8
10

注意事项

• 在使用循环时，确保循环条件最终会变为假，否则可能导致无限循环。
• 循环体内的代码块需要严格缩进，通常使用四个空格来表示缩进层级。
• 不同的循环类型适用于不同的场景，选择合适的循环结构可以使代码更加清晰和高效。

循环结构是程序中常见的控制结构之一，掌握好循环的基本语法和应用场景，能够有效地处理和操作多次重复执行的任务。

二 函数

2.1 定义

在Python中，函数（Functions）是一种重要的代码组织和复用结构，允许将一段代码逻辑封装起来，以便在程序中多次调用。函数定义的基本语法如下：

def function_name(parameters):
    """
    Docstring: 函数的文档字符串，用于描述函数的作用、参数和返回值等信息（可选）
    """
    # 函数体，即函数执行的代码块
    statement1
    statement2
    ...
    return expression   # 可选，用于返回值

其中各部分的解释如下：

• def 关键字：用于定义函数，后面跟着函数的名称。
• function_name：函数的名称，遵循命名规则，用于在程序中调用函数。
• parameters：函数的参数列表，包括函数调用时需要传递的参数。参数可以是位置参数、默认参数、可变长参数和关键字参数等。
• Docstring：函数的文档字符串，用于描述函数的作用、参数、返回值等信息。文档字符串是可选的，但推荐在定义函数时编写，可以通过 help() 函数查看。
• 函数体：函数体是函数的核心部分，包含函数执行的代码块，以冒号 : 开始，需要缩进来表示属于函数体的代码块。
• return 语句：可选的 return 语句用于从函数中返回值给调用者。函数可以不返回任何值（此时返回 None），也可以返回一个或多个值。如果没有 return 语句，函数执行完毕后默认返回 None。
  示例
  下面是一个简单的函数定义示例，用于计算两个数的和：

def add_numbers(a, b):
    """
    计算两个数的和，并返回结果
    """
    result = a + b
    return result

在上述示例中：

• 函数名称为 add_numbers，接受两个参数 a 和 b。
• 函数体内部计算了 a 和 b 的和，并通过 return 语句返回结果。

2.1.1 调用函数

定义好函数后，可以通过函数名称加上参数列表来调用函数，例如：

sum_result = add_numbers(3, 5)
print(sum_result)  # 输出 8

2.1.2 参数类型

Python 中的函数参数可以有多种类型：

• 位置参数：按照顺序传递给函数的参数，如上述示例中的 a 和 b。
• 默认参数：在定义函数时指定默认值的参数，调用时可以不传递这些参数。
• 可变长参数：允许传递任意数量的参数，包括不定数量的位置参数和关键字参数。
• 关键字参数：传递给函数的参数带有名称，可以在函数内部使用名称来访问这些参数。

2.1.3 注意事项

• 函数的命名应遵循命名规则，通常使用小写字母和下划线 _ 组合命名，以提高代码可读性。
• 函数体内的代码块需要缩进，通常使用四个空格来表示缩进层级。
• 在定义函数时，建议编写清晰、简洁的文档字符串，描述函数的作用、参数、返回值等信息，以方便他人或自己日后使用时的参考。

函数是Python编程中非常重要的概念，能够有效地组织和管理代码，提高代码的重用性和可维护性。

2.2 参数传递

在Python中，参数传递是指在调用函数时将数据传递给函数的过程。Python 中的函数参数可以分为四种类型：位置参数、默认参数、可变长参数和关键字参数。这些参数的使用方式和传递方式略有不同。

2.2.1. 位置参数

位置参数是最常见的参数类型，按照顺序依次传递给函数。在定义函数时，函数声明中列出的参数称为位置参数。调用函数时，传递的实际参数必须按照与函数声明中参数的顺序相匹配。

示例：

def greet(name, greeting):
    print(f"{greeting}, {name}!")

greet("Alice", "Hello")

在上述示例中，“Alice” 和 “Hello” 分别被传递给 name 和 greeting 位置参数。

2.2.2 默认参数

默认参数在函数定义时提供默认值，如果调用函数时没有传递该参数，则使用默认值。默认参数必须位于位置参数之后。
示例：

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice")          # 输出 "Hello, Alice!"
greet("Bob", "Hi")      # 输出 "Hi, Bob!"

在上述示例中，greeting 参数有默认值 “Hello”，因此在调用 greet() 函数时可以选择不传递 greeting 参数。

2.2.3. 可变长参数

可变长参数允许传递任意数量的位置参数或关键字参数给函数。Python 提供了两种形式的可变长参数：*args 和 **kwargs。

• *args：用于传递不定数量的位置参数，将参数作为元组(tuple)传递给函数。
• **kwargs：用于传递不定数量的关键字参数，将参数作为字典(dictionary)传递给函数。
  示例：

def sum_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total

result = sum_numbers(1, 2, 3, 4)
print(result)  # 输出 10

在上述示例中，*args 接收传递给 sum_numbers() 函数的所有位置参数，并将它们作为元组 (1, 2, 3, 4) 进行处理。

2.2.4. 关键字参数

关键字参数允许传递不定数量的关键字参数给函数，即传递参数时指定参数名。在函数内部，关键字参数被视为字典。

示例：

def greet(name, greeting="Hello", **kwargs):
    additional_info = ", ".join(f"{key}={value}" for key, value in kwargs.items())
    print(f"{greeting}, {name}! {additional_info}")

greet("Alice", greeting="Hi", age=30, city="New York")

在上述示例中，除了 name 和 greeting 参数外，greet() 函数还接受任意数量的关键字参数 (age=30 和 city=“New York”)，这些参数被捕获并作为字典 kwargs 在函数内部处理。

2.2.5 参数传递方式

在Python中，参数传递是通过对象的引用来实现的。当传递不可变对象（如整数、字符串、元组）时，传递的是对象的值。而当传递可变对象（如列表、字典）时，传递的是对象的引用，因此在函数内部对可变对象的修改会影响到外部对象。

示例：

def modify_list(lst):
    lst.append(4)

my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)  # 输出 [1, 2, 3, 4]

在上述示例中，my_list 是一个列表，作为参数传递给 modify_list() 函数时，lst 是对同一列表的引用，因此在函数内部对 lst 的修改也影响了外部的 my_list。

理解参数传递的方式对于编写和理解函数的行为非常重要，特别是在处理可变对象时需要注意。

2.3 作用域

在Python中，作用域（Scope）指的是变量的可见性和访问规则，即变量在程序中的有效范围。了解作用域对于理解变量的生命周期、名称空间以及程序中函数和模块之间的交互至关重要。

2.3.1 局部作用域（Local Scope）

局部作用域是在函数内部定义的作用域，其变量只能在函数内部访问。当函数调用结束时，局部作用域也随之销毁，其中的变量也将被释放。

示例：

def my_function():
    x = 10  # x 是局部变量
    print(x)

my_function()  # 输出 10
print(x)  # 这里会报错，因为 x 是局部变量，超出了其作用域

在上述示例中，x 是 my_function() 函数内的局部变量，它在函数外部是不可见的。

2.3.2 全局作用域（Global Scope）

全局作用域是在模块顶层定义的作用域，其变量可以在整个模块内访问，包括模块中的函数内部。在模块被导入和运行时创建，在程序执行期间一直存在。

示例：

x = 10  # x 是全局变量

def my_function():
    print(x)

my_function()  # 输出 10
print(x)  # 输出 10

在上述示例中，x 是在模块顶层定义的全局变量，可以被模块中的任何地方访问。

2.3.4 嵌套作用域（Enclosing Scope）

嵌套作用域是指在函数内部定义了另一个函数的情况。在这种情况下，内部函数可以访问外部函数的变量，但外部函数不能直接访问内部函数的变量。

示例：

def outer_function():
    y = 20  # y 是外部函数的局部变量
    
    def inner_function():
        print(y)  # 内部函数可以访问外部函数的变量 y
    
    inner_function()

outer_function()  # 输出 20

在上述示例中，inner_function() 可以访问外部函数 outer_function() 中的变量 y，这是因为嵌套作用域的存在。

2.3.4 作用域规则

Python 的作用域规则可以概括为以下几点：

• 在函数内部可以访问全局变量，但不能修改它（除非使用 global 关键字）。
• 在函数内部可以创建新的局部变量，其作用域限定在函数内部。
• 函数参数也是局部变量，其作用域限定在函数内部。

2.3.5 global 和 nonlocal 关键字

global 关键字：用于在函数内部声明一个变量是全局变量，可以在函数内部修改全局变量的值。
示例：

x = 10

def my_function():
    global x
    x = 20  # 修改全局变量 x 的值

my_function()
print(x)  # 输出 20

nonlocal 关键字：用于在嵌套函数中声明一个变量是外部（非全局）作用域的变量，用来修改闭包中的变量。

def outer_function():
    y = 30
    
    def inner_function():
        nonlocal y
        y = 40  # 修改外部函数的变量 y
    
    inner_function()
    print(y)  # 输出 40

outer_function()

在上述示例中，inner_function() 使用 nonlocal 关键字来修改外部函数 outer_function() 中的变量 y。

2.4 lambda表达式

Lambda 表达式是Python中的一种匿名函数，也称为lambda函数。它允许在代码中创建小的、一次性的、没有名称的函数。

2.4.1 Lambda 表达式的语法

Lambda 表达式的基本语法如下：

lambda arguments: expression

其中：

lambda 是关键字，表示创建lambda函数。
arguments 是函数的参数列表，可以是任意数量的参数，但只能有一个表达式。
expression 是一个返回值的表达式，表示函数要执行的操作。
示例
下面是一个简单的 lambda 表达式的例子，用于计算两个数的和：

add_numbers = lambda x, y: x + y
print(add_numbers(3, 5))  # 输出 8

在上述示例中，lambda x, y: x + y 创建了一个 lambda 函数，并将其赋值给变量 add_numbers。这个 lambda 函数接受两个参数 x 和 y，并返回它们的和。

2.4.2 使用 lambda 表达式的场景

Lambda 表达式通常用于以下场景：

• 作为简单函数的替代：当函数体较短且仅需要执行单一操作时，可以使用 lambda 表达式定义一个简洁的匿名函数。
• 作为函数参数：lambda 表达式常用于函数的参数中，例如在 map()、filter()、sorted() 等函数中，用于传递简单的操作逻辑。
• 在闭包中使用：lambda 表达式可以用在函数内部，用来定义内部函数的返回值。

2.4.3 与 def 定义函数的区别

Lambda 表达式与使用 def 关键字定义的普通函数相比，有以下几点不同：

• 匿名性：lambda 表达式是匿名的，没有函数名。
• 单一表达式：lambda 表达式只能包含一个表达式，而普通函数可以包含多个语句和复杂的逻辑。
• 语法简洁：lambda 表达式语法更为紧凑，适合简单的函数操作。

2.4.4 注意事项

虽然 lambda 表达式非常方便和简洁，但也有一些限制和适用情况：

• lambda 函数的功能通常较简单，适合处理一些简单的数据转换和过滤操作。
• 不推荐在 lambda 表达式中编写复杂的逻辑或多行代码，这样会降低代码的可读性。

总体来说，lambda 表达式在需要快速定义和使用简单函数时非常有用，能够提高代码的简洁性和可读性，但在复杂逻辑和功能需求较多的情况下，建议使用普通的命名函数（使用 def 定义）。

2.4.5 代码示例

# 示例 1：计算平方
square = lambda x: x ** 2
print(square(5))  # 输出 25

# 排序列表
points = [(1, 2), (3, 1), (5, 4), (2, 5)]
points_sorted = sorted(points, key=lambda x: x[1])  # 按照元组的第二个元素排序
print(points_sorted)  # 输出 [(3, 1), (1, 2), (5, 4), (2, 5)]


# 将列表中的字符串转换为大写
words = ['apple', 'banana', 'cherry']
uppercase_words = list(map(lambda x: x.upper(), words))
print(uppercase_words)  # 输出 ['APPLE', 'BANANA', 'CHERRY']

# 过滤列表中的偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出 [2, 4, 6, 8, 10]

#使用 lambda 表达式作为排序的键函数
students = [
    {'name': 'Alice', 'grade': 80},
    {'name': 'Bob', 'grade': 75},
    {'name': 'Charlie', 'grade': 90},
    {'name': 'David', 'grade': 85}
]
students_sorted = sorted(students, key=lambda x: x['grade'], reverse=True)
print(students_sorted)
# 输出 [{'name': 'Charlie', 'grade': 90}, {'name': 'David', 'grade': 85}, {'name': 'Alice', 'grade': 80}, {'name': 'Bob', 'grade': 75}]

2.5 常用内置函数

Python内置了许多常用的函数，这些函数可以直接在Python解释器中使用，无需导入额外的模块。以下是一些常用的内置函数及其简要说明：

1. 类型转换函数

int()：将一个数值或字符串转换为整数。
float()：将一个数值或字符串转换为浮点数。
str()：将指定的对象转换为字符串。
list()：将一个可迭代对象转换为列表。
tuple()：将一个可迭代对象转换为元组。
dict()：创建一个字典。可以接受关键字参数、可迭代对象（如元组）或者映射对象（如字典）。

2. 数学相关函数

abs()：返回一个数的绝对值。
max()：返回给定参数的最大值。
min()：返回给定参数的最小值。
pow()：返回 x 的 y 次方，即 x>>y。
round()：对一个数进行四舍五入。

3. 序列操作函数

len()：返回对象的长度（元素个数）。
sorted()：对可迭代对象进行排序，返回一个新的列表。
reversed()：返回一个反向迭代器，用于反向遍历序列。

4. 输入输出函数

print()：打印输出到控制台。
input()：从控制台获取用户输入。

5. 函数操作函数

lambda：创建匿名函数。
map()：将一个函数应用于迭代器的每个元素，返回一个结果迭代器。
filter()：过滤器函数，返回一个由使函数返回 True 的元素组成的迭代器。

6. 其他常用函数

range()：生成一个指定范围内的整数序列。
enumerate()：返回一个枚举对象，包含迭代器的索引和值。
zip()：将多个可迭代对象打包成一个元组序列。

示例
下面是一些常用内置函数的示例：

# 类型转换函数示例
print(int("10"))  # 输出 10
print(float("3.14"))  # 输出 3.14
print(str(123))  # 输出 "123"
print(list(range(5)))  # 输出 [0, 1, 2, 3, 4]
print(tuple([1, 2, 3]))  # 输出 (1, 2, 3)
print(dict([('a', 1), ('b', 2)]))  # 输出 {'a': 1, 'b': 2}

# 数学相关函数示例
print(abs(-5))  # 输出 5
print(max(3, 7, 1))  # 输出 7
print(min(4, 2, 6))  # 输出 2
print(pow(2, 3))  # 输出 8
print(round(3.14159, 2))  # 输出 3.14

# 序列操作函数示例
print(len([1, 2, 3]))  # 输出 3
print(sorted([3, 1, 2]))  # 输出 [1, 2, 3]
print(list(reversed([1, 2, 3])))  # 输出 [3, 2, 1]

# 输入输出函数示例
name = input("Enter your name: ")
print("Hello,", name)

# 函数操作函数示例
add = lambda x, y: x + y
print(add(3, 5))  # 输出 8

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # 输出 [1, 4, 9, 16, 25]

even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出 [2, 4]

# 其他常用函数示例
print(list(range(1, 5)))  # 输出 [1, 2, 3, 4]

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

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