python基础语法--笔记1
格式化字符串
在 Python 中，格式化字符串是一种非常重要的功能，用于将变量或表达式嵌入到字符串中，从而生成动态的文本内容。Python 提供了多种字符串格式化的方法，包括
%运算符、str.format()方法和 f-string（Python 3.6+）。每种方法都有其特点和适用场景。1. 使用
%运算符
%运算符是 Python 早期版本中用于格式化字符串的方式。它通过%符号将变量嵌入到字符串中。示例
Python复制
name = "Alice" age = 25 print("My name is %s and I am %d years old." % (name, age)) # 输出：My name is Alice and I am 25 years old.格式化占位符
%s：字符串
%d：十进制整数
%f：浮点数
%x：十六进制整数
%o：八进制整数格式化浮点数
Python复制
pi = 3.141592653589793 print("Pi is approximately %.2f" % pi) # 输出：Pi is approximately 3.142. 使用
str.format()
str.format()方法是 Python 2.6 引入的，比%运算符更灵活和强大。它通过{}占位符将变量嵌入到字符串中。示例
Python复制
name = "Alice" age = 25 print("My name is {} and I am {} years old.".format(name, age)) # 输出：My name is Alice and I am 25 years old.格式化占位符
str.format()方法支持更复杂的格式化选项，例如指定字段宽度、精度、对齐方式等。Python复制
pi = 3.141592653589793 print("Pi is approximately {:.2f}".format(pi)) # 输出：Pi is approximately 3.14 # 指定字段宽度 print("Pi is approximately {:10.2f}".format(pi)) # 输出：Pi is approximately 3.14格式化数字
Python复制
number = 123456789 print("Number: {:,}".format(number)) # 输出：Number: 123,456,789格式化日期
Python复制
from datetime import datetime now = datetime.now() print("Current time: {:%Y-%m-%d %H:%M:%S}".format(now)) # 输出：Current time: 2025-02-08 14:30:003. 使用 f-string（Python 3.6+）
f-string 是 Python 3.6 引入的一种新的字符串格式化方法，通过在字符串前加
f或F，并在字符串中直接嵌入变量或表达式。f-string 的语法简洁且性能更高。示例
Python复制
name = "Alice" age = 25 print(f"My name is {name} and I am {age} years old.") # 输出：My name is Alice and I am 25 years old.格式化表达式
f-string 支持在大括号中直接写表达式。
Python复制
a = 10 b = 20 print(f"The sum of {a} and {b} is {a + b}.") # 输出：The sum of 10 and 20 is 30.格式化数字
Python复制
pi = 3.141592653589793 print(f"Pi is approximately {pi:.2f}") # 输出：Pi is approximately 3.14格式化日期
Python复制
from datetime import datetime now = datetime.now() print(f"Current time: {now:%Y-%m-%d %H:%M:%S}") # 输出：Current time: 2025-02-08 14:30:004. 格式化字符串的比较
%运算符
优点：语法简单，适合简单的格式化任务。
缺点：不够灵活，可读性较差。
str.format()
优点：功能强大，支持复杂的格式化选项。
缺点：语法稍显复杂，性能不如 f-string。
f-string
优点：语法简洁，性能高，可读性强。
缺点：仅在 Python 3.6 及以上版本中可用。
5. 注意事项
选择合适的格式化方法：根据实际需求选择合适的格式化方法。如果使用的是 Python 3.6 及以上版本，推荐使用 f-string。
格式化占位符：在使用
str.format()和 f-string 时，可以通过:后跟格式化选项来指定字段宽度、精度、对齐方式等。性能优化：f-string 的性能优于
str.format()和%运算符，特别是在处理大量字符串时。总结
Python 提供了多种字符串格式化的方法，每种方法都有其特点和适用场景。掌握这些方法可以帮助你更高效地生成动态的字符串内容。以下是推荐的使用场景：
简单格式化：使用
%运算符。复杂格式化：使用
str.format()。现代代码：使用 f-string（Python 3.6+）。
print函数
在 Python 中，
print()是一个非常常用的内置函数，用于将指定的内容输出到控制台（终端）或其他输出流。以下是关于print()函数的详细解释：1. 基本语法
Python复制
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
*objects：表示可以传入多个对象作为参数，这些对象会被依次输出。
sep：指定多个对象之间的分隔符，默认值是空格' '。例如：Python复制
print("Hello", "World", sep="-") # 输出：Hello-World
end：指定输出的结尾字符，默认值是换行符'\n'。例如：Python复制
print("Hello", end=" ") print("World") # 输出：Hello World（两个输出在同一行）
file：指定输出的目标文件或流，默认是标准输出（sys.stdout）。例如，可以将输出重定向到文件：Python复制
with open("output.txt", "w") as f: print("Hello, World!", file=f)
flush：如果设置为True，则会强制刷新输出缓冲区，立即将内容输出，而不是等待缓冲区满或遇到换行符。默认值是False。2. 功能
输出文本：
print()最基本的功能是将字符串或其他对象转换为文本并输出到控制台。例如：Python复制
print("Hello, Python!")输出多个对象：可以一次性输出多个对象，它们之间会用默认的分隔符（空格）分隔。例如：
Python复制
name = "Alice" age = 25 print("Name:", name, "Age:", age) # 输出：Name: Alice Age: 25格式化输出：虽然
print()本身没有直接的格式化功能，但可以通过字符串格式化方法（如f-string或format()）来实现更复杂的输出。例如：Python复制
print(f"Name: {name}, Age: {age}")
input函数
在 Python 中，
input()是一个内置函数，用于从用户获取输入。以下是关于input()函数的详细解释：基本语法
Python复制
input([prompt])
prompt：这是一个可选参数，用于在屏幕上显示提示信息，帮助用户了解需要输入的内容。功能
接收用户输入：
input()函数会暂停程序的执行，等待用户从标准输入设备（通常是键盘）输入数据。用户输入的内容在按下回车键后被返回。返回值类型：无论用户输入的是什么，
input()函数总是将输入的内容作为字符串（str类型）返回。示例
Python复制
name = input("请输入您的名字：") print(f"您好，{name}！欢迎来到Python的世界。")在这个例子中，程序会显示提示信息“请输入您的名字：”，然后等待用户输入。用户输入的名字将被存储在变量
name中，并通过print()函数显示欢迎信息。输入类型转换
由于
input()返回的是字符串，如果需要将用户输入的数字转换为整数或浮点数，可以使用int()或float()函数进行类型转换。Python复制
age = int(input("请输入您的年龄：")) print(f"您的年龄是：{age}")接收多个输入
可以通过
split()方法将用户输入的多个值分割成列表。Python复制
numbers_input = input("请输入一组数字，用空格分隔：") numbers_list = numbers_input.split() numbers = [int(num) for num in numbers_list] print(f"您输入的数字列表是：{numbers}")
注释
在 Python 中，注释是一种非常重要的编程习惯，它可以帮助开发者更好地理解代码的功能、逻辑和用途，同时也便于团队协作和代码维护。Python 提供了两种主要的注释方法：单行注释和多行注释。
1. 单行注释
单行注释是 Python 中最简单的注释方式，它使用井号（
#）来标识。从井号开始到该行末尾的所有内容都会被 Python 解释器忽略，不会被执行。语法
Python复制
# 这是单行注释示例
Python复制
# 定义一个变量 x = 10 # 这是变量 x 的值 print(x) # 输出变量 x 的值在上面的代码中，
# 定义一个变量和# 这是变量 x 的值是单行注释，它们分别对代码的功能进行了说明。# 输出变量 x 的值也是单行注释，用于解释单行注释通常用于对代码的某一行或某一部分进行简短的说明，它可以帮助其他开发者快速理解代码的意图。
2. 多行注释
多行注释用于对代码块进行更详细的说明，它可以通过以下两种方式实现：
（1）使用三引号（
'''或"""）三引号可以用来创建多行字符串，而当这些多行字符串不被赋值给任何变量时，它们就会被当作注释处理。
语法
Python复制
''' 这是多行注释的第一行 这是多行注释的第二行 这是多行注释的第三行 ''' """ 这是另一种多行注释的第一行 这是第二种多行注释的第二行 这是第二种多行注释的第三行 """示例
Python复制
''' 这是一个示例函数，用于计算两个数的和。 参数： a -- 第一个加数 b -- 第二个加数 返回值： 两个数的和 ''' def add(a, b): return a + b print(add(3, 5))在上面的代码中，三引号内的内容是多行注释，它对
add函数的功能、参数和返回值进行了详细的说明。这种注释方式通常用于函数、类或模块的文档说明，也被称为文档字符串（docstring）。（2）使用多个单行注释
虽然不推荐，但也可以通过连续使用多个单行注释来实现多行注释的效果。
示例
Python复制
# 这是一个示例函数，用于计算两个数的和。 # 参数： # a -- 第一个加数 # b -- 第二个加数 # 返回值： # 两个数的和 def add(a, b): return a + b print(add(3, 5))虽然这种方法也可以实现多行注释的效果，但它不如使用三引号直观和方便，因此在实际开发中较少使用。
保留字与标识符
在 Python 中，保留字（Reserved Words）和标识符（Identifiers）是编程中非常重要的概念。它们在语法和语义上有明确的定义和用途。
1. 保留字（Reserved Words）
保留字是 Python 语言中具有特殊含义的单词，它们被语言本身保留，不能用作变量名、函数名、类名或其他标识符。
Python 保留字列表
Python 的保留字是固定的，以下是 Python 3.x 中的保留字列表（截至 Python 3.10）：
plaintext复制
False await else import pass None break except in raise True class finally is return and continue for lambda try as def from nonlocal while assert del global not with async elif if or yield特点
不可用作标识符：保留字不能用作变量名、函数名、类名等标识符。
Python复制
# 错误示例 class = 10 # 会报错，因为 class 是保留字区分大小写：Python 是大小写敏感的语言，保留字也不例外。
Python复制
# 正确示例 Class = 10 # 这是合法的，因为 Class 不是保留字具有特殊语法功能：保留字在 Python 的语法结构中具有特定的用途，例如
if用于条件语句，for用于循环语句等。检查是否为保留字
可以使用
keyword模块来检查一个单词是否为保留字：Python复制
import keyword print(keyword.iskeyword("class")) # True print(keyword.iskeyword("my_var")) # False2. 标识符（Identifiers）
标识符是用于标识变量名、函数名、类名、模块名等的名称。它们必须遵循一定的规则。
标识符的命名规则
字母或下划线开头：标识符必须以字母（
a-z或A-Z）或下划线（_）开头，不能以数字开头。Python复制
# 正确示例 my_var = 10 _private_var = 20 # 错误示例 1var = 10 # 会报错字母、数字或下划线组成：标识符的其余部分可以包含字母（
a-z或A-Z）、数字（0-9）或下划线（_）。Python复制
# 正确示例 my_var_1 = 10区分大小写：Python 是大小写敏感的语言，
MyVar和myvar是两个不同的标识符。Python复制
myvar = 10 MyVar = 20 print(myvar) # 输出 10 print(MyVar) # 输出 20不能使用保留字：标识符不能与保留字相同。
Python复制
# 错误示例 class = 10 # 会报错不能使用特殊符号：标识符不能包含特殊符号（如
@,#,$等）。Python复制
# 错误示例 my@var = 10 # 会报错常见的标识符命名约定
变量名：通常使用小写字母和下划线组合，例如
my_variable。函数名：通常使用小写字母和下划线组合，例如
my_function。类名：通常使用大写字母开头的驼峰命名法，例如
MyClass。模块名：通常使用小写字母和下划线组合，例如
my_module。常量名：通常使用大写字母和下划线组合，例如
MY_CONSTANT。3. 实际应用示例
以下是一个简单的 Python 示例，展示了保留字和标识符的使用：
Python复制
# 定义一个变量 my_variable = 10 # my_variable 是一个合法的标识符 # 定义一个函数 def my_function(): if my_variable > 5: # if 是保留字 print("Greater than 5") else: print("Less than or equal to 5") # 调用函数 my_function()在这个示例中：
my_variable是一个合法的标识符，用于定义变量。
my_function是一个合法的标识符，用于定义函数。
if和else是保留字，用于控制流程。总结
保留字：是 Python 语言中具有特殊含义的单词，不能用作标识符。
标识符：是用于标识变量名、函数名、类名等的名称，必须遵循一定的命名规则。
合理使用保留字和标识符是编写清晰、可读性强的 Python 代码的基础。
round函数
在 Python 中，
round()函数是一个内置函数，用于对数值进行四舍五入操作。它将一个浮点数或整数四舍五入到指定的小数位数。语法
round()函数的基本语法如下：Python复制
round(number, ndigits)参数说明
number：需要四舍五入的数值（可以是整数或浮点数）。
ndigits（可选）：指定四舍五入到的小数位数。如果省略此参数，则默认四舍五入到最接近的整数。返回值
如果不指定
ndigits，则返回一个整数。如果指定了
ndigits，则返回一个浮点数，保留指定的小数位数。示例
示例 1：四舍五入到整数
Python复制
print(round(3.7)) # 输出：4 print(round(3.2)) # 输出：3 print(round(-2.7)) # 输出：-3 print(round(-2.2)) # 输出：-2示例 2：四舍五入到指定的小数位数
Python复制
print(round(3.14159, 2)) # 输出：3.14 print(round(3.14159, 3)) # 输出：3.142 print(round(1.23456, 4)) # 输出：1.2346示例 3：负数的四舍五入
Python复制
print(round(-3.14159, 2)) # 输出：-3.14 print(round(-3.14159, 3)) # 输出：-3.142特殊情况
当数字恰好在中间时（如 0.5）：Python 的
round()函数遵循“银行家舍入法”（Banker's Rounding），即如果数字恰好在中间（例如 0.5），则四舍五入到最接近的偶数。Python复制
print(round(2.5)) # 输出：2 print(round(3.5)) # 输出：4 print(round(4.5)) # 输出：4 print(round(-2.5)) # 输出：-2 print(round(-3.5)) # 输出：-4整数的四舍五入：如果传入的是整数，
ndigits参数仍然有效。Python复制
print(round(10, 1)) # 输出：10.0 print(round(10, 2)) # 输出：10.0
ndigits为负数：如果ndigits是负数，则四舍五入到小数点左侧的位数。Python复制
print(round(1234.5678, -1)) # 输出：1230.0 print(round(1234.5678, -2)) # 输出：1200.0注意事项
精度问题：由于浮点数在计算机中的表示可能存在精度问题，
round()函数的结果可能与预期略有不同。Python复制
print(round(2.675, 2)) # 输出：2.67，而不是 2.68与
math.floor()和math.ceil()的区别：
round()是四舍五入。
math.floor()是向下取整（取小于等于该数的最大整数）。
math.ceil()是向上取整（取大于等于该数的最小整数）。Python复制
import math print(math.floor(3.7)) # 输出：3 print(math.ceil(3.7)) # 输出：4总结
round()函数是一个非常实用的工具，用于对数值进行四舍五入操作。它支持多种用法，包括四舍五入到整数和指定的小数位数。了解其行为（特别是银行家舍入法）可以帮助你更准确地使用它来处理数值数据。
python中的复数类型
在 Python 中，复数是一种内置的数据类型，用于表示形如 a+bj 的数学复数，其中 a 是实部，b 是虚部，j 是虚数单位（满足 j2=−1）。Python 提供了丰富的复数操作功能，包括基本运算、属性访问和方法调用。
复数的表示和创建
直接使用复数语法：可以通过
a + bj的形式直接创建复数，其中j或J是虚数单位。Python复制
z1 = 3 + 4j z2 = 1 - 2J使用
complex()函数：可以通过complex(real, imag)函数创建复数。Python复制
z1 = complex(3, 4) # 创建复数 3 + 4j z2 = complex(1, -2) # 创建复数 1 - 2j从字符串解析：
complex()函数也可以从字符串中解析复数。Python复制
z = complex("3+4j") # 从字符串解析复数复数的属性和方法
实部和虚部：可以通过
.real和.imag属性访问复数的实部和虚部。Python复制
z = 3 + 4j print(z.real) # 输出：3.0 print(z.imag) # 输出：4.0共轭复数：可以通过
.conjugate()方法获取复数的共轭复数。Python复制
z = 3 + 4j print(z.conjugate()) # 输出：(3-4j)复数的基本运算
Python 支持复数的加法、减法、乘法、除法和幂运算。
Python复制
z1 = 3 + 4j z2 = 1 - 2j # 加法 print(z1 + z2) # 输出：(4+2j) # 减法 print(z1 - z2) # 输出：(2+6j) # 乘法 print(z1 * z2) # 输出：(11+2j) # 除法 print(z1 / z2) # 输出：(-1+2j) # 幂运算 print(z1 ** 2) # 输出：(-7+24j)复数的模
复数的模（绝对值）可以通过内置的
abs()函数计算。Python复制
z = 3 + 4j print(abs(z)) # 输出：5.0应用场景
复数在数学、物理学、工程学等领域有广泛应用，例如在信号处理中用于傅里叶变换，在量子力学中用于描述量子态。
总结
Python 的复数类型提供了强大的功能，支持直接创建、基本运算、属性访问和方法调用。通过内置的
complex类型和相关函数，可以方便地处理复数相关的计算。
字符串类型
在 Python 中，字符串（String）是一种不可变（immutable）的数据类型，用于表示文本信息。字符串由字符组成，可以包含字母、数字、符号等。Python 提供了多种方式来创建、操作和处理字符串，使其成为处理文本数据的强大工具。
1. 创建字符串
字符串可以使用单引号（
'）、双引号（"）或三引号（'''或"""）来定义。不同类型的引号可以嵌套使用。示例
Python复制
# 使用单引号 s1 = 'Hello, world!' # 使用双引号 s2 = "Python is fun!" # 使用三引号（用于多行字符串） s3 = '''This is a multi-line string.''' # 使用三引号（也可以包含引号） s4 = """He said, "Hello!" and she replied, 'Hi!'"""2. 字符串的基本操作
（1）访问字符
字符串中的字符可以通过索引来访问，索引从 0 开始。负索引从字符串的末尾开始，-1 表示最后一个字符。
Python复制
s = "Python" print(s[0]) # 输出：P print(s[-1]) # 输出：n（2）切片
可以通过切片操作获取字符串的子串。切片的语法为
s[start:end]，其中start是起始索引，end是终止索引（不包含）。Python复制
s = "Python" print(s[1:4]) # 输出：yth print(s[:3]) # 输出：Pyt print(s[3:]) # 输出：hon print(s[-3:]) # 输出：hon（3）长度
可以使用内置函数
len()获取字符串的长度。Python复制
s = "Python" print(len(s)) # 输出：63. 字符串的不可变性
字符串是不可变的数据类型，这意味着字符串中的字符不能被修改。如果需要修改字符串的内容，可以创建一个新的字符串。
Python复制
s = "Hello" # s[0] = "h" # 会报错 s = "hello" # 创建一个新的字符串4. 字符串的常用方法
（1）大写和小写
str.upper()：将字符串中的所有字符转换为大写。
str.lower()：将字符串中的所有字符转换为小写。
str.capitalize()：将字符串的第一个字符转换为大写，其余字符转换为小写。
str.title()：将字符串中每个单词的首字母大写。Python复制
s = "python is fun" print(s.upper()) # 输出：PYTHON IS FUN print(s.lower()) # 输出：python is fun print(s.capitalize()) # 输出：Python is fun print(s.title()) # 输出：Python Is Fun（2）查找和替换
str.find(sub)：返回子字符串sub在字符串中的第一个索引，如果未找到则返回-1。
str.replace(old, new)：将字符串中的old替换为new。Python复制
s = "hello world" print(s.find("world")) # 输出：6 print(s.replace("world", "Python")) # 输出：hello Python（3）分割和连接
str.split(sep)：将字符串按照指定的分隔符sep分割，返回一个列表。
str.join(iterable)：将可迭代对象中的元素连接成一个字符串，每个元素用指定的字符串分隔。s = "hello world python" words = s.split(" ") # 按空格分割 print(words) # 输出：['hello', 'world', 'python'] new_s = "-".join(words) # 用短横线连接 print(new_s) # 输出：hello-world-python（4）去除空白字符
str.strip()：去除字符串首尾的空白字符（包括空格、换行符等）。
str.lstrip()：去除字符串左侧的空白字符。
str.rstrip()：去除字符串右侧的空白字符。Python复制
s = " hello world " print(s.strip()) # 输出：hello world print(s.lstrip()) # 输出：hello world print(s.rstrip()) # 输出： hello world5. 格式化字符串
Python 提供了多种方式来格式化字符串，包括使用
%运算符、str.format()方法和 f-string（Python 3.6+）。（1）使用
%运算符name = "Alice" age = 25 print("My name is %s and I am %d years old." % (name, age)) # 输出：My name is Alice and I am 25 years old.（2）使用
str.format()name = "Alice" age = 25 print("My name is {} and I am {} years old.".format(name, age)) # 输出：My name is Alice and I am 25 years old.（3）使用 f-string
f-string 是 Python 3.6 及以上版本中引入的，可以更方便地嵌入变量和表达式。
name = "Alice" age = 25 print(f"My name is {name} and I am {age} years old.") # 输出：My name is Alice and I am 25 years old.6. 字符串编码和解码
Python 中的字符串是 Unicode 编码的，可以使用
.encode()和.decode()方法进行编码和解码操作。Python复制
s = "你好，世界" encoded = s.encode("utf-8") # 编码为 UTF-8 print(encoded) # 输出：b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c' decoded = encoded.decode("utf-8") # 解码为 UTF-8 print(decoded) # 输出：你好，世界7. 扩展：正则表达式
Python 的
re模块提供了强大的正则表达式功能，用于字符串的搜索、匹配、替换等操作。Python复制
import re s = "hello world" match = re.search("world", s) if match: print("Found:", match.group()) # 输出：Found: world8. 注意事项
不可变性：字符串是不可变的，所有字符串操作实际上都返回了一个新的字符串。
大写和小写：
str.upper()和str.lower()等方法不会修改原字符串，而是返回一个新的字符串。编码问题：在处理文件或网络数据时，注意字符串的编码和解码，避免出现乱码问题。
总结
Python 的字符串类型提供了丰富的功能和方法，使其成为处理文本数据的强大工具。掌握字符串的创建、基本操作、常用方法和格式化技巧，可以帮助你高效地处理各种文本处理任务。
字符串的常用方法
Python 中的字符串提供了许多内置方法，用于执行各种常见的文本处理操作。这些方法可以帮助你更高效地处理字符串，包括大小写转换、查找和替换、分割和连接等。以下是一些常用的字符串方法及其示例。
1. 大小写转换
（1）
upper()：将字符串中的所有字符转换为大写。Python复制
s = "hello" print(s.upper()) # 输出：HELLO（2）
lower()：将字符串中的所有字符转换为小写。Python复制
s = "HELLO" print(s.lower()) # 输出：hello（3）
capitalize()：将字符串的第一个字符转换为大写，其余字符转换为小写。Python复制
s = "hello world" print(s.capitalize()) # 输出：Hello world（4）
title()：将字符串中每个单词的首字母大写。Python复制
s = "hello world" print(s.title()) # 输出：Hello World2. 查找和替换
（1）
find(sub)：返回子字符串sub在字符串中的第一个索引，如果未找到则返回-1。Python复制
s = "hello world" print(s.find("world")) # 输出：6 print(s.find("python")) # 输出：-1（2）
index(sub)：返回子字符串sub在字符串中的第一个索引，如果未找到则引发ValueError。Python复制
s = "hello world" print(s.index("world")) # 输出：6 # print(s.index("python")) # 报错：ValueError: substring not found（3）
replace(old, new)：将字符串中的old替换为new。Python复制
s = "hello world" print(s.replace("world", "Python")) # 输出：hello Python3. 去除空白字符
（1）
strip()：去除字符串首尾的空白字符（包括空格、换行符等）。Python复制
s = " hello world " print(s.strip()) # 输出：hello world（2）
lstrip()：去除字符串左侧的空白字符。Python复制
s = " hello world" print(s.lstrip()) # 输出：hello world（3）
rstrip()：去除字符串右侧的空白字符。Python复制
s = "hello world " print(s.rstrip()) # 输出：hello world4. 分割和连接
（1）
split(sep)：将字符串按照指定的分隔符sep分割，返回一个列表。Python复制
s = "hello world python" words = s.split() # 默认按空格分割 print(words) # 输出：['hello', 'world', 'python']（2）
join(iterable)：将可迭代对象中的元素连接成一个字符串，每个元素用指定的字符串分隔。Python复制
words = ['hello', 'world', 'python'] new_s = "-".join(words) print(new_s) # 输出：hello-world-python5. 格式化字符串
（1）
format()：使用占位符格式化字符串。Python复制
name = "Alice" age = 25 print("My name is {} and I am {} years old.".format(name, age)) # 输出：My name is Alice and I am 25 years old.（2）f-string（Python 3.6+）：使用 f-string 格式化字符串。
Python复制
name = "Alice" age = 25 print(f"My name is {name} and I am {age} years old.") # 输出：My name is Alice and I am 25 years old.6. 检查字符串
（1）
isalpha()：检查字符串是否只包含字母。Python复制
s = "hello" print(s.isalpha()) # 输出：True（2）
isdigit()：检查字符串是否只包含数字。Python复制
s = "123" print(s.isdigit()) # 输出：True（3）
isalnum()：检查字符串是否只包含字母或数字。Python复制
s = "hello123" print(s.isalnum()) # 输出：True（4）
isspace()：检查字符串是否只包含空白字符。Python复制
s = " " print(s.isspace()) # 输出：True（5）
startswith(prefix)：检查字符串是否以指定的前缀开头。Python复制
s = "hello world" print(s.startswith("hello")) # 输出：True（6）
endswith(suffix)：检查字符串是否以指定的后缀结尾。Python复制
s = "hello world" print(s.endswith("world")) # 输出：True7. 其他常用方法
（1）
count(sub)：统计子字符串sub在字符串中出现的次数。Python复制
s = "hello world" print(s.count("o")) # 输出：2（2）
join(iterable)：将可迭代对象中的元素连接成一个字符串，每个元素用指定的字符串分隔。Python复制
words = ['hello', 'world', 'python'] new_s = "-".join(words) print(new_s) # 输出：hello-world-python（3）
partition(sep)：将字符串分割为三部分，返回一个元组。Python复制
s = "hello world" print(s.partition(" ")) # 输出：('hello', ' ', 'world')（4）
rpartition(sep)：从右侧开始分割字符串，返回一个元组。Python复制
s = "hello world" print(s.rpartition(" ")) # 输出：('hello', ' ', 'world')（5）
rfind(sub)和rindex(sub)：从右侧开始查找子字符串。Python复制
s = "hello world" print(s.rfind("o")) # 输出：7 print(s.rindex("o")) # 输出：7总结
Python 的字符串提供了丰富的内置方法，用于执行各种常见的文本处理操作。掌握这些方法可以帮助你更高效地处理字符串，包括大小写转换、查找和替换、分割和连接、格式化以及检查字符串。这些方法在处理文本数据时非常实用，能够显著提高代码的可读性和效率。
字符串切片操作等
s1 = "Hello"
s2 = "World"
s3 = s1 + " " + s2
print(s3) # 输出：Hello World字符串切片（Slicing）是 Python 中一种非常强大的功能，用于从字符串中提取子字符串。通过切片操作，可以快速地获取字符串的任意部分，而无需逐个字符地访问。切片操作的语法简单且直观，非常适用于处理文本数据。
字符串切片的语法
字符串切片的基本语法如下：
s[start:end:step]
start：切片的起始索引（包含）。如果省略，默认从字符串的开头开始。
end：切片的终止索引（不包含）。如果省略，默认到字符串的末尾。
step：步长，表示每次跳过的字符数。如果省略，默认为 1。示例
假设我们有一个字符串
s = "Hello, World!"，以下是一些常见的切片操作：1. 提取子字符串
s = "Hello, World!" print(s[0:5]) # 从索引 0 到 4，提取 "Hello" print(s[7:12]) # 从索引 7 到 11，提取 "World"2. 省略起始或终止索引
print(s[:5]) # 从开头到索引 4，提取 "Hello" print(s[7:]) # 从索引 7 到末尾，提取 "World!" print(s[:]) # 提取整个字符串 "Hello, World!"3. 使用负索引
负索引从字符串的末尾开始计数，
-1表示最后一个字符。print(s[-6:-1]) # 从倒数第 6 个字符到倒数第 1 个字符，提取 "World"4. 使用步长
步长表示每次跳过的字符数。如果步长为 2，则每隔一个字符提取一个字符。
print(s[::2]) # 从开头到末尾，每隔一个字符提取，提取 "Hlo ol!" print(s[::-1]) # 使用负步长，反转字符串，提取 "!dlroW ,olleH"常见用法
1. 提取特定部分
s = "Python is fun" print(s[7:9]) # 提取 "is"2. 反转字符串
s = "Python" print(s[::-1]) # 输出 "nohtyP"3. 提取每隔几个字符
s = "abcdefgh" print(s[::3]) # 输出 "adg"4. 去掉首尾字符
s = "###Python###" print(s[3:-3]) # 输出 "Python"注意事项
索引范围：切片的
end索引是不包含的，即s[start:end]提取的是从start到end-1的子字符串。越界处理：如果
start或end超出了字符串的范围，Python 会自动调整为字符串的实际边界，不会报错。s = "Hello" print(s[0:10]) # 输出 "Hello"，而不是报错步长为 0：步长不能为 0，否则会报错。
s = "Hello" print(s[::0]) # 报错：ValueError: slice step cannot be zero总结
字符串切片是 Python 中处理字符串的强大工具，通过简单的语法可以实现复杂的字符串操作。掌握切片的基本语法和常见用法，可以帮助你更高效地处理文本数据。
转义字符
在 Python 中，转义字符（Escape Characters）用于表示那些在字符串中无法直接输入的特殊字符，例如换行符、制表符、引号等。转义字符以反斜杠
\开头，后跟一个特定的字符或序列，用来表示这些特殊字符。常见的转义字符
以下是一些常用的转义字符及其含义：
转义字符 描述 示例 \n换行符 "Hello\nWorld"\t制表符（水平制表符） "Name:\tAlice"\\反斜杠本身 "C:\\Users\\Alice"\'单引号 \'It\'s a good day\'\"双引号 "He said, \"Hello!\""\b退格符 "Hello\bWorld"\r回车符 "Hello\rWorld"\f换页符 "Page1\fPage2"\ooo八进制数表示的字符 "\123"（八进制 123）\xhh十六进制数表示的字符 "\x41"（十六进制 41，即 A）示例
以下是一些使用转义字符的示例：
换行符
\nprint("Hello\nWorld") # 输出： # Hello # World制表符
\tprint("Name:\tAlice") # 输出：Name: Alice反斜杠
\\print("C:\\Users\\Alice") # 输出：C:\Users\Alice单引号
\'和双引号\"Python复制
print('It\'s a good day') # 输出：It's a good day print("He said, \"Hello!\"") # 输出：He said, "Hello!"退格符
\bprint("Hello\bWorld") # 输出：HellWorld回车符
\rprint("Hello\rWorld") # 输出：World八进制和十六进制表示
Python复制
print("\123") # 输出：A（八进制 123 对应 ASCII 码的 A） print("\x41") # 输出：A（十六进制 41 对应 ASCII 码的 A）原始字符串（Raw Strings）
如果不想让反斜杠作为转义字符，可以使用原始字符串（Raw Strings）。在原始字符串中，反斜杠不会被特殊处理，而是作为普通字符。
示例
print(r"C:\Users\Alice") # 输出：C:\Users\Alice注意事项
转义字符的用途：转义字符主要用于在字符串中表示那些无法直接输入的字符，例如换行符、制表符等。
原始字符串：在处理文件路径或正则表达式时，通常使用原始字符串，以避免反斜杠被误解释为转义字符。
多行字符串：如果需要在字符串中包含换行符，可以使用三引号（
'''或"""）定义多行字符串，而无需使用\n。Python复制
print('''This is a multi-line string.''') # 输出： # This is a # multi-line string.总结
转义字符是 Python 中处理字符串时的一个重要概念，它允许你在字符串中表示特殊字符。掌握常见的转义字符及其用法，可以帮助你更灵活地处理字符串中的各种情况。
str.format()方法
str.format()是 Python 中一种非常强大且灵活的字符串格式化方法，适用于各种复杂的格式化需求。它通过在字符串中使用占位符{}，然后通过.format()方法将变量或表达式嵌入到字符串中。以下是str.format()的详细用法和一些常见示例。基本用法
示例 1：基本格式化
Python复制
name = "Alice" age = 25 print("My name is {} and I am {} years old.".format(name, age)) # 输出：My name is Alice and I am 25 years old.在上面的代码中，
{}是占位符，format(name, age)将变量name和age的值分别替换到占位符的位置。占位符的编号
可以通过在
{}中添加编号来指定变量的顺序。示例 2：带编号的占位符
Python复制
print("My name is {0} and I am {1} years old.".format(name, age)) # 输出：My name is Alice and I am 25 years old. print("My name is {0} and my age is {1}. {0} is a great name.".format(name, age)) # 输出：My name is Alice and my age is 25. Alice is a great name.在上面的代码中，
{0}和{1}分别表示format()方法中第一个和第二个参数。格式化数字
str.format()提供了丰富的格式化选项，尤其是对于数字。示例 3：格式化浮点数
Python复制
pi = 3.141592653589793 print("Pi is approximately {:.2f}".format(pi)) # 输出：Pi is approximately 3.14 print("Pi is approximately {:.5f}".format(pi)) # 输出：Pi is approximately 3.14159在上面的代码中，
:.2f表示保留两位小数，:.5f表示保留五位小数。示例 4：格式化整数
Python复制
number = 123456789 print("Number: {:,}".format(number)) # 输出：Number: 123,456,789 print("Number: {:d}".format(number)) # 输出：Number: 123456789在上面的代码中，
:,表示在数字中添加逗号作为千位分隔符，{:d}表示格式化为十进制整数。格式化日期
str.format()也可以用于格式化日期和时间。示例 5：格式化日期
Python复制
from datetime import datetime now = datetime.now() print("Current time: {:%Y-%m-%d %H:%M:%S}".format(now)) # 输出：Current time: 2025-02-08 14:30:00在上面的代码中，
{:%Y-%m-%d %H:%M:%S}是格式化日期的占位符，%Y表示四位年份，%m表示两位月份，%d表示两位日期，%H表示两位小时（24 小时制），%M表示两位分钟，%S表示两位秒数。格式化对齐和宽度
str.format()提供了对齐和宽度的格式化选项。示例 6：对齐和宽度
Python复制
print("{:10} is a fruit.".format("Apple")) # 输出：Apple is a fruit. print("{:>10} is a fruit.".format("Apple")) # 输出： Apple is a fruit. print("{:^10} is a fruit.".format("Apple")) # 输出： Apple is a fruit.在上面的代码中：
{:10}表示将字符串右对齐，总宽度为 10 个字符。
{:>10}表示将字符串右对齐。
:^10表示将字符串居中对齐。格式化填充字符
可以通过指定填充字符来控制对齐。
示例 7：填充字符
Python复制
print("{:*^10} is a fruit.".format("Apple")) # 输出：***Apple*** is a fruit. print("{:*<10} is a fruit.".format("Apple")) # 输出：Apple**** is a fruit. print("{:*>10} is a fruit.".format("Apple")) # 输出：****Apple is a fruit.在上面的代码中：
:*^10表示将字符串居中对齐，并用*填充。
:*<10表示将字符串左对齐，并用*填充。
:*>10表示将字符串右对齐，并用*填充。格式化字典
str.format()可以直接从字典中提取值。示例 8：格式化字典
Python复制
data = {"name": "Alice", "age": 25} print("My name is {name} and I am {age} years old.".format(**data)) # 输出：My name is Alice and I am 25 years old.在上面的代码中，
**data将字典data中的键值对作为关键字参数传递给format()方法。格式化嵌套数据
str.format()可以处理嵌套的数据结构。示例 9：格式化嵌套数据
Python复制
person = {"name": "Alice", "details": {"age": 25, "city": "New York"}} print("My name is {name} and I live in {details[city]}.".format(**person)) # 输出：My name is Alice and I live in New York.在上面的代码中，
{details[city]}表示从嵌套的字典details中提取city的值。总结
str.format()是 Python 中非常强大且灵活的字符串格式化方法，支持多种格式化选项，包括对齐、宽度、精度、填充字符、数字格式化、日期格式化等。掌握这些用法可以帮助你更高效地生成复杂的字符串内容。
布尔类型
在 Python 中，布尔类型（Boolean Type）是一种特殊的类型，用于表示逻辑值。布尔类型只有两个值：
True和False。布尔类型通常用于条件判断、逻辑运算等场景。1. 布尔值的表示
布尔类型只有两个值：
True：表示逻辑上的“真”。
False：表示逻辑上的“假”。2. 布尔类型的创建
布尔值可以通过布尔运算符（如
==、!=、>、<、>=、<=）或布尔函数（如bool()）来创建。示例
Python复制
# 使用比较运算符 print(10 > 5) # 输出：True print(10 < 5) # 输出：False # 使用布尔函数 print(bool(1)) # 输出：True print(bool(0)) # 输出：False print(bool("")) # 输出：False print(bool("Hello")) # 输出：True3. 布尔运算
布尔运算符用于对布尔值进行逻辑运算，包括逻辑与（
and）、逻辑或（or）和逻辑非（not）。示例
Python复制
# 逻辑与 print(True and True) # 输出：True print(True and False) # 输出：False # 逻辑或 print(True or False) # 输出：True print(False or False) # 输出：False # 逻辑非 print(not True) # 输出：False print(not False) # 输出：True4. 布尔类型的用途
布尔类型主要用于条件判断和循环控制。
示例
Python复制
# 条件判断 if 10 > 5: print("10 is greater than 5") # 输出：10 is greater than 5 # 循环控制 while True: print("This is an infinite loop") break # 使用 break 避免无限循环5. 布尔类型的隐式转换
在 Python 中，某些值在布尔上下文中会被隐式转换为布尔值。以下是一些常见的隐式转换规则：
数值：
非零数值（如
1、-1、3.14）会被转换为True。零（如
0、0.0）会被转换为False。字符串：
非空字符串（如
"Hello"）会被转换为True。空字符串（如
""）会被转换为False。集合：
非空集合（如
[1, 2, 3]、{1, 2, 3}、{"key": "value"}）会被转换为True。空集合（如
[]、{}、set()）会被转换为False。示例
Python复制
# 数值 print(bool(1)) # 输出：True print(bool(0)) # 输出：False # 字符串 print(bool("Hello")) # 输出：True print(bool("")) # 输出：False # 集合 print(bool([1, 2, 3])) # 输出：True print(bool([])) # 输出：False6. 布尔类型与条件表达式
布尔类型常用于条件表达式中，条件表达式可以返回一个布尔值。
示例
Python复制
# 条件表达式 x = 10 y = 20 result = "x is greater" if x > y else "y is greater" print(result) # 输出：y is greater7. 布尔类型与
all()和any()Python 提供了
all()和any()函数，用于处理布尔值的集合。
all()：如果所有元素都为True，则返回True。
any()：如果至少有一个元素为True，则返回True。示例
Python复制
# all() print(all([True, True, True])) # 输出：True print(all([True, False, True])) # 输出：False # any() print(any([False, False, True])) # 输出：True print(any([False, False, False])) # 输出：False8. 注意事项
布尔值的大小写：
True和False是 Python 中的保留字，必须使用正确的大小写。布尔值的隐式转换：了解布尔值的隐式转换规则可以帮助你更好地理解代码的行为。
逻辑运算的短路行为：
and运算符在遇到第一个False值时会停止计算。
or运算符在遇到第一个True值时会停止计算。示例
Python复制
# 短路行为 print(True and False and True) # 输出：False print(False or True or False) # 输出：True总结
布尔类型是 Python 中用于表示逻辑值的基本类型，只有两个值：
True和False。布尔类型广泛用于条件判断、逻辑运算和循环控制。掌握布尔值的创建、布尔运算和隐式转换规则，可以帮助你更高效地编写逻辑清晰的代码。
数据类型之间的转换
隐式转换 a=10 b=6 print(a/b,type(a/b)) print(a//b,type(a//b)) ------------------------------------------------ 1.6666666666666667 <class 'float'> 1 <class 'int'> 显示转换 a=3.14 print(a,int(a),type(a),type(int(a))) ----------------------------------------------- 3.14 3 <class 'float'> <class 'int'>
eval()函数
语法
eval()的基本语法如下：eval(expression, globals=None, locals=None)
expression：要计算的字符串形式的表达式。
globals（可选）：指定全局变量的字典。默认为当前全局变量。
locals（可选）：指定局部变量的字典。默认为当前局部变量。示例
示例 1：基本用法
expression = "2 + 3 * 4" result = eval(expression) print(result) # 输出：14示例 2：使用变量
x = 10 y = 20 expression = "x + y" result = eval(expression) print(result) # 输出：30示例 3：使用
globals和localsx = 10 y = 20 expression = "x + y" globals_dict = {"x": 5, "y": 15} result = eval(expression, globals_dict) print(result) # 输出：20 locals_dict = {"x": 100, "y": 200} result = eval(expression, globals_dict, locals_dict) print(result) # 输出：300示例4：与input()一起使用
age=eval(input('输入你的年龄；')) print(age,type(age)) ------------------------------------------------- age=input('输入你的年龄；') print(age,type(age))
运算符
在 Python 中，运算符是用于执行特定操作的符号。Python 提供了多种类型的运算符，包括算术运算符、比较运算符、逻辑运算符、赋值运算符、位运算符、成员运算符和身份运算符。以下是对这些运算符的详细介绍和示例。
1. 算术运算符
算术运算符用于执行基本的数学运算。
运算符 描述 示例 +加法 a + b-减法 a - b*乘法 a * b/除法（返回浮点数） a / b//整除（返回整数） a // b%求余 a % b**幂运算 a ** ba = 10 b = 3 print(a + b) # 输出：13 print(a - b) # 输出：7 print(a * b) # 输出：30 print(a / b) # 输出：3.3333333333333335 print(a // b) # 输出：3 print(a % b) # 输出：1 print(a ** b) # 输出：10002. 比较运算符
比较运算符用于比较两个值的大小，返回布尔值
True或False。
运算符 描述 示例 ==等于 a == b!=不等于 a != b>大于 a > b<小于 a < b>=大于等于 a >= b<=小于等于 a <= ba = 10 b = 3 print(a == b) # 输出：False print(a != b) # 输出：True print(a > b) # 输出：True print(a < b) # 输出：False print(a >= b) # 输出：True print(a <= b) # 输出：False3. 逻辑运算符
逻辑运算符用于执行逻辑操作，返回布尔值
True或False。
运算符 描述 示例 and逻辑与 a and bor逻辑或 a or bnot逻辑非 not aa = True b = False print(a and b) # 输出：False print(a or b) # 输出：True print(not a) # 输出：False4. 赋值运算符
赋值运算符用于将值赋给变量。
运算符 描述 示例 =简单赋值 a = b+=加法赋值 a += b-=减法赋值 a -= b*=乘法赋值 a *= b/=除法赋值 a /= b//=整除赋值 a //= b%=求余赋值 a %= b**=幂运算赋值 a **= ba = 10 a += 5 # 等同于 a = a + 5 print(a) # 输出：15 a -= 3 # 等同于 a = a - 3 print(a) # 输出：12 a *= 2 # 等同于 a = a * 2 print(a) # 输出：24 a /= 4 # 等同于 a = a / 4 print(a) # 输出：6.0 a //= 2 # 等同于 a = a // 2 print(a) # 输出：3.0 a %= 2 # 等同于 a = a % 2 print(a) # 输出：1.0 a **= 3 # 等同于 a = a ** 3 print(a) # 输出：1.05. 位运算符
位运算符（Bitwise Operators）是 Python 中用于对整数的二进制表示进行操作的运算符。它们直接操作数字的二进制位，因此在处理底层数据（如加密、图像处理、硬件编程等）时非常有用。以下是 Python 中的位运算符及其用法。
1. 位运算符的种类
Python 提供了以下几种位运算符：
运算符 描述 示例 &位与（Bitwise AND） a & b| 位或（Bitwise OR） |a ^位异或（Bitwise XOR） a ^ b~位取反（Bitwise NOT） ~a<<左移（Bitwise Left Shift） a << n>>右移（Bitwise Right Shift） a >> n2. 位运算符的详细用法
（1）位与（
&）位与运算符
&对两个操作数的每一位进行与操作。只有当两个对应的位都为 1 时，结果才为 1。a = 10 # 二进制：1010 b = 3 # 二进制：0011 result = a & b # 二进制：0010 print(result) # 输出：2（2）位或（
|）位或运算符
|对两个操作数的每一位进行或操作。只要有一个对应的位为 1，结果就为 1。a = 10 # 二进制：1010 b = 3 # 二进制：0011 result = a | b # 二进制：1011 print(result) # 输出：11（3）位异或（
^）位异或运算符
^对两个操作数的每一位进行异或操作。只有当两个对应的位不同时，结果才为 1。相同为0不同为1。a = 10 # 二进制：1010 b = 3 # 二进制：0011 result = a ^ b # 二进制：1001 print(result) # 输出：9（4）位取反（
~）位取反运算符
~对操作数的每一位进行取反操作。0 变为 1，1 变为 0。需要注意的是，Python 中的整数是补码表示的，因此取反操作可能会得到一个负数。a = 10 # 二进制：1010 result = ~a # 二进制：11110101（补码表示） print(result) # 输出：-11（5）左移（
<<）左移运算符
<<将操作数的二进制表示向左移动指定的位数。左移时，左边的位被丢弃，右边补 0。a = 10 # 二进制：1010 result = a << 2 # 二进制：101000 print(result) # 输出：40（6）右移（
>>）右移运算符
>>将操作数的二进制表示向右移动指定的位数。右移时，右边的位被丢弃，左边补符号位（对于负数补 1，对于正数补 0）。a = 10 # 二进制：1010 result = a >> 2 # 二进制：0010 print(result) # 输出：23. 位运算符的应用场景
位运算符在以下场景中非常有用：
位掩码（Bit Masking）：用于设置、清除或检查特定的位。
位操作：用于高效地处理二进制数据。
加密和解密：在加密算法中，位运算符可以用于生成复杂的位模式。
硬件编程：直接操作硬件寄存器时，位运算符用于设置和清除特定的位。
# 设置特定位 def set_bit(value, bit): return value | (1 << bit) # 清除特定位 def clear_bit(value, bit): return value & ~(1 << bit) # 检查特定位 def check_bit(value, bit): return value & (1 << bit) # 示例 value = 10 # 二进制：1010 print(set_bit(value, 1)) # 输出：14 (二进制：1110) print(clear_bit(value, 1)) # 输出：8 (二进制：1000) print(check_bit(value, 1)) # 输出：2 (二进制：0010)6. 成员运算符
成员运算符用于检查某个值是否存在于某个序列（如字符串、列表、元组等）中。
运算符 描述 示例 in检查是否存在于序列中 a in bnot in检查是否不存在于序列中 a not in ba = "hello" b = "hello world" print(a in b) # 输出：True print(a not in b) # 输出：False c = [1, 2, 3, 4] print(5 in c) # 输出：False print(3 in c) # 输出：True7. 身份运算符
身份运算符用于比较两个对象是否是同一个对象（即是否指向同一个内存地址）。
运算符 描述 示例 is检查两个对象是否相同 a is bis not检查两个对象是否不同 a is not ba = [1, 2, 3] b = [1, 2, 3] c = a print(a is b) # 输出：False print(a is c) # 输出：True print(a is not b) # 输出：True print(a is not c) # 输出：False
选择结构
在 Python 中，选择结构（Selection Structure）用于根据条件执行不同的代码块。选择结构允许程序根据特定的条件做出决策，从而选择不同的执行路径。Python 中的选择结构主要包括
if语句、if-else语句和if-elif-else语句。1.
if语句
if语句用于在满足某个条件时执行特定的代码块。如果条件为True，则执行代码块；如果条件为False，则跳过代码块。语法
Python复制
if condition: # 代码块示例
Python复制
x = 10 if x > 5: print("x is greater than 5") # 输出：x is greater than 52.
if-else语句
if-else语句用于在满足某个条件时执行一个代码块，否则执行另一个代码块。如果条件为True，则执行if块；如果条件为False，则执行else块。语法
Python复制
if condition: # if 代码块 else: # else 代码块示例
Python复制
x = 10 if x > 5: print("x is greater than 5") else: print("x is not greater than 5") # 输出：x is greater than 53.
if-elif-else语句
if-elif-else语句用于在多个条件中选择一个执行路径。elif是 "else if" 的缩写，用于检查多个条件。如果所有条件都不满足，则执行else块（如果存在）。语法
Python复制
if condition1: # if 代码块 elif condition2: # elif 代码块 elif condition3: # elif 代码块 else: # else 代码块示例
Python复制
x = 10 if x > 10: print("x is greater than 10") elif x == 10: print("x is equal to 10") else: print("x is less than 10") # 输出：x is equal to 104. 嵌套的
if语句可以在
if语句中嵌套另一个if语句，以实现更复杂的条件判断。示例
Python复制
x = 10 y = 5 if x > 5: if y > 3: print("Both conditions are true") else: print("The first condition is true, but the second is not") else: print("The first condition is not true") # 输出：Both conditions are true5. 条件表达式（三元运算符）
Python 提供了一种更简洁的条件表达式，也称为三元运算符。它可以在一行代码中完成简单的
if-else逻辑。语法
Python复制
value_if_true if condition else value_if_false示例
Python复制
x = 10 result = "x is greater than 5" if x > 5 else "x is not greater than 5" print(result) # 输出：x is greater than 56. 注意事项
条件表达式：条件表达式（三元运算符）适用于简单的条件判断，但对于复杂的逻辑，建议使用完整的
if-elif-else语句以提高代码的可读性。缩进：Python 中的代码块是通过缩进来定义的，因此在使用选择结构时，确保代码块的缩进正确。
逻辑清晰：在使用嵌套的
if语句时，尽量保持逻辑清晰，避免过多的嵌套，以免影响代码的可读性。总结
选择结构是 Python 中实现条件判断的重要工具。通过
if、if-else和if-elif-else语句，可以实现复杂的条件逻辑。条件表达式（三元运算符）提供了一种更简洁的方式来处理简单的条件判断。掌握这些选择结构的用法可以帮助你编写更灵活和高效的代码。
模式匹配
在 Python 中，模式匹配（Pattern Matching）是一种强大的功能，用于检查一个值是否符合某种模式，并根据模式提取数据。Python 3.10 引入了一种新的模式匹配语法，称为“结构化模式匹配”（Structural Pattern Matching），它类似于其他语言中的“模式匹配”或“解构”功能。
1. 模式匹配的基本语法
结构化模式匹配使用
match和case关键字。match语句将一个值与多个模式进行匹配，并根据匹配的模式执行相应的代码块。语法
Python复制
match subject: case pattern1: # 代码块1 case pattern2: # 代码块2 ... case _: # 默认代码块（可选）2. 示例
示例 1：基本模式匹配
Python复制
def describe_point(point): match point: case (0, 0): print("Origin") case (0, y): print(f"On the y-axis at {y}") case (x, 0): print(f"On the x-axis at {x}") case (x, y): print(f"Point is at ({x}, {y})") case _: print("Not a valid point") describe_point((0, 0)) # 输出：Origin describe_point((0, 10)) # 输出：On the y-axis at 10 describe_point((10, 0)) # 输出：On the x-axis at 10 describe_point((10, 10))# 输出：Point is at (10, 10) describe_point("not a point") # 输出：Not a valid point示例 2：匹配字典
Python复制
def describe_person(person): match person: case {"name": name, "age": age}: print(f"Name: {name}, Age: {age}") case _: print("Not a valid person") describe_person({"name": "Alice", "age": 25}) # 输出：Name: Alice, Age: 25 describe_person({"name": "Bob"}) # 输出：Not a valid person3. 模式匹配的类型
Python 的模式匹配支持多种模式类型，包括字面量模式、变量模式、序列模式、映射模式等。
（1）字面量模式
匹配具体的值。
Python复制
match x: case 0: print("Zero") case 1: print("One") case _: print("Other")（2）变量模式
匹配任何值，并将值绑定到变量。
Python复制
match x: case y: print(f"x is {y}")（3）序列模式
匹配序列（如列表或元组）。
Python复制
match point: case (x, y): print(f"Point is at ({x}, {y})") case (x, y, z): print(f"Point is at ({x}, {y}, {z})") case _: print("Not a valid point")（4）映射模式
匹配字典。
Python复制
match person: case {"name": name, "age": age}: print(f"Name: {name}, Age: {age}") case _: print("Not a valid person")4. 高级特性
（1）守卫（Guard）
可以在
case语句中添加条件表达式，称为守卫。Python复制
match point: case (x, y) if x > 0 and y > 0: print(f"Point is in the first quadrant: ({x}, {y})") case (x, y) if x < 0 and y > 0: print(f"Point is in the second quadrant: ({x}, {y})") case (x, y) if x < 0 and y < 0: print(f"Point is in the third quadrant: ({x}, {y})") case (x, y) if x > 0 and y < 0: print(f"Point is in the fourth quadrant: ({x}, {y})") case _: print("Point is on an axis or at the origin")（2）捕获模式
可以捕获匹配的值并绑定到变量。
Python复制
match point: case (x, y) as p: print(f"Point is {p} with x={x} and y={y}")5. 注意事项
Python 3.10+：模式匹配是 Python 3.10 中引入的新特性，因此需要使用 Python 3.10 或更高版本。
性能：模式匹配的性能通常优于传统的
if-elif-else结构，尤其是在处理复杂的数据结构时。可读性：模式匹配可以显著提高代码的可读性和可维护性，尤其是在处理多种数据结构时。
总结
模式匹配是 Python 3.10 引入的一种强大的功能，用于检查值是否符合某种模式，并根据模式提取数据。通过使用
match和case关键字，可以实现复杂的匹配逻辑，同时保持代码的简洁和可读性。掌握模式匹配的用法可以帮助你编写更高效和灵活的代码。
循环结构
循环结构是编程中用于重复执行某段代码直到满足特定条件为止的控制结构。Python 提供了两种主要的循环结构：
for循环和while循环。此外，Python 还提供了一些循环控制语句（如break、continue和else），用于更精细地控制循环的行为。1.
for循环
for循环用于遍历可迭代对象（如列表、元组、字典、集合、字符串等），并依次执行循环体中的代码。语法
Python复制
for item in iterable: # 循环体代码示例
Python复制
# 遍历列表 fruits = ['apple', 'banana', 'cherry'] for fruit in fruits: print(fruit) # 输出： # apple # banana # cherry遍历字符串
Python复制
s = "hello" for char in s: print(char) # 输出： # h # e # l # l # o使用
range()函数
range()函数用于生成一个整数序列，常用于控制循环次数。Python复制
for i in range(5): # 生成 0 到 4 的整数序列 print(i) # 输出： # 0 # 1 # 2 # 3 # 42.
while循环
while循环用于在满足某个条件时重复执行代码块。只要条件为True，循环就会继续执行。语法
Python复制
while condition: # 循环体代码示例
Python复制
# 使用 while 循环计算 1 到 10 的和 sum = 0 i = 1 while i <= 10: sum += i i += 1 print(sum) # 输出：553. 循环控制语句
Python 提供了一些控制循环流程的语句，如
break、continue和else。（1）
break语句
break语句用于在循环中提前退出循环。示例
Python复制
for i in range(10): if i == 5: break print(i) # 输出： # 0 # 1 # 2 # 3 # 4（2）
continue语句
continue语句用于跳过当前循环迭代，继续执行下一次迭代。示例
Python复制
for i in range(10): if i % 2 == 0: continue print(i) # 输出： # 1 # 3 # 5 # 7 # 9（3）
else子句
else子句可以与for或while循环结合使用。如果循环正常结束（没有被break语句中断），则执行else子句中的代码。示例
Python复制
for i in range(5): if i == 3: break else: print("Loop completed without break") # 输出：无（因为循环被 break 中断） for i in range(5): pass else: print("Loop completed without break") # 输出：Loop completed without break4. 嵌套循环
可以在一个循环中嵌套另一个循环，以实现更复杂的迭代逻辑。
示例
Python复制
# 打印乘法表 for i in range(1, 10): for j in range(1, i + 1): print(f"{j}x{i}={i * j}", end="\t") print() # 输出： # 1x1=1 # 1x2=2 2x2=4 # 1x3=3 2x3=6 3x3=9 # ...5. 注意事项
避免无限循环：确保循环条件最终会变为
False，否则会导致无限循环。循环变量的作用域：在
for循环中，循环变量在循环结束后仍然存在。代码可读性：尽量避免过多的嵌套循环，以免影响代码的可读性。
总结
循环结构是 Python 中实现重复任务的重要工具。
for循环适用于遍历可迭代对象，而while循环适用于在满足条件时重复执行代码。通过合理使用循环控制语句（如break、continue和else），可以更灵活地控制循环流程。掌握这些循环结构的用法可以帮助你编写更高效和灵活的代码。