python基础---2.流程控制及函数

在这里插入图片描述

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

一流程控制

1.1 条件分支

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

1.1.1 if 语句

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

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

例如：

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

1.1.2. if … else 语句

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

if condition:# 如果条件为真时执行的代码块statement1statement2...
else:# 如果条件为假时执行的代码块statement3statement4...

例如：

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为真时执行的代码块statement1statement2...
elif condition2:# 如果条件2为真时执行的代码块statement3statement4...
elif condition3:# 如果条件3为真时执行的代码块statement5statement6...
else:# 如果所有条件都不为真时执行的代码块statement7statement8...

例如：

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:# 每次迭代时执行的代码块statement1statement2...

其中 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)

上述代码将输出：

1.2.2 while 循环

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

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

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

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

上述代码将输出：

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.1 定义

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

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

其中各部分的解释如下：

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

def add_numbers(a, b):"""计算两个数的和，并返回结果"""result = a + breturn 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 = 0for num in args:total += numreturn totalresult = 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)  # 内部函数可以访问外部函数的变量 yinner_function()outer_function()  # 输出 20

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

2.3.4 作用域规则

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

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

2.3.5 global 和 nonlocal 关键字

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

x = 10def my_function():global xx = 20  # 修改全局变量 x 的值my_function()
print(x)  # 输出 20

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

def outer_function():y = 30def inner_function():nonlocal yy = 40  # 修改外部函数的变量 yinner_function()print(y)  # 输出 40outer_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解释器中使用，无需导入额外的模块。以下是一些常用的内置函数及其简要说明：

类型转换函数

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

数学相关函数

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

序列操作函数

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

输入输出函数

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

函数操作函数

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

其他常用函数

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))  # 输出 8numbers = [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 cprint(list(zip([1, 2, 3], ['a', 'b', 'c'])))  # 输出 [(1, 'a'), (2, 'b'), (3, 'c')]

python基础---2.流程控制及函数

一流程控制

1.1 条件分支

1.1.1 if 语句

1.1.2. if … else 语句

1.1.3 if … elif … else 语句

1.2 循环

1.2.1 for 循环

1.2.2 while 循环

1.2.3 循环控制语句

1.2.4 示例

二函数

2.1 定义

2.1.1 调用函数

2.1.2 参数类型

2.1.3 注意事项

2.2 参数传递

2.2.1. 位置参数

2.2.2 默认参数

2.2.3. 可变长参数

2.2.4. 关键字参数

2.2.5 参数传递方式

2.3 作用域

2.3.1 局部作用域（Local Scope）

2.3.2 全局作用域（Global Scope）

2.3.4 嵌套作用域（Enclosing Scope）

2.3.4 作用域规则

2.3.5 global 和 nonlocal 关键字

2.4 lambda表达式

2.4.1 Lambda 表达式的语法

2.4.2 使用 lambda 表达式的场景

2.4.3 与 def 定义函数的区别

2.4.4 注意事项

2.4.5 代码示例

2.5 常用内置函数

相关资讯

热文排行

最新新闻

推荐新闻

热搜词

python基础---2.流程控制及函数

一 流程控制

1.1 条件分支

1.1.1 if 语句

1.1.2. if … else 语句

1.1.3 if … elif … else 语句

1.2 循环

1.2.1 for 循环

1.2.2 while 循环

1.2.3 循环控制语句

1.2.4 示例

二 函数

2.1 定义

2.1.1 调用函数

2.1.2 参数类型

2.1.3 注意事项

2.2 参数传递

2.2.1. 位置参数

2.2.2 默认参数

2.2.3. 可变长参数

2.2.4. 关键字参数

2.2.5 参数传递方式

2.3 作用域

2.3.1 局部作用域（Local Scope）

2.3.2 全局作用域（Global Scope）

2.3.4 嵌套作用域（Enclosing Scope）

2.3.4 作用域规则

2.3.5 global 和 nonlocal 关键字

2.4 lambda表达式

2.4.1 Lambda 表达式的语法

2.4.2 使用 lambda 表达式的场景

2.4.3 与 def 定义函数的区别

2.4.4 注意事项

2.4.5 代码示例

2.5 常用内置函数

相关资讯

热文排行

最新新闻

推荐新闻

热搜词

一流程控制

二函数