Python编程探索：从基础语法到循环结构实践（下）

前言

接上篇 Python编程探索：从基础语法到循环结构实践（上），本篇文章将继续深入探讨Python的字符串操作、逻辑运算符、成员运算符以及条件语句和循环结构，并通过代码实例化来帮助读者更好地理解这些概念。

🍷四、 字符串拼接：连接多个字符串

在 Python 编程中，字符串拼接是将多个字符串合并为一个整体的操作。无论是在构建动态文本、生成格式化的输出，还是处理从用户或外部输入得到的多个数据段，字符串拼接都是一项必不可少的操作。Python 提供了多种灵活且高效的方法来进行字符串拼接，每种方法都有其独特的应用场景和优劣。

🍸4.1 使用 + 操作符进行字符串拼接

最直接的字符串拼接方式是使用 + 操作符。通过 + 可以将两个或多个字符串合并成一个新的字符串。

示例

# 简单的字符串拼接
s1 = "Hello"
s2 = "World"
result = s1 + " " + s2
print(result)  # 输出: Hello World

在这个示例中，我们通过 + 操作符将两个字符串和一个空格连接在一起，形成了完整的句子。

注意事项

• 不可变性：需要注意的是，Python 的字符串是不可变的，这意味着每次使用 + 操作符进行拼接时，都会创建一个新的字符串对象。这在需要拼接大量字符串时可能会影响性能。
• 效率：对于少量字符串的拼接，+ 操作符的效率是可以接受的，但如果需要在循环中拼接大量字符串，使用 + 操作符可能会导致性能下降。

🍸4.2 使用 join() 方法进行字符串拼接

如果需要拼接多个字符串，特别是存储在列表或元组中的字符串，推荐使用 Python 的内置 str.join() 方法。join() 方法通过指定的分隔符，将可迭代对象中的所有元素连接成一个字符串。

语法

result = "separator".join(iterable)

• separator：分隔符，指定用来连接每个元素的字符串。
• iterable：可迭代对象（如列表、元组），其每个元素都是字符串。

示例

# 使用 join() 拼接列表中的字符串
words = ["Python", "is", "great"]
sentence = " ".join(words)
print(sentence)  # 输出: Python is great

在这个例子中，使用 " " 作为分隔符，将列表中的三个单词拼接成一个完整的句子。

注意事项

• join() 方法比 + 操作符更高效，特别是在拼接大量字符串时。因为 join() 会先计算出所有字符串的总长度，然后只分配一次内存，而 + 操作符在每次拼接时都会创建一个新的字符串对象。
• join() 方法要求可迭代对象中的所有元素都是字符串，如果有非字符串元素，需先进行类型转换。

# 将非字符串元素转换为字符串后再拼接
mixed = ["The answer is", 42]
sentence = " ".join(map(str, mixed))
print(sentence)  # 输出: The answer is 42

🍸4.3 使用 format() 方法进行格式化拼接

format() 方法提供了一种强大且灵活的方式来格式化和拼接字符串。它允许我们在字符串中定义占位符 {}，并通过 format() 方法将变量插入到占位符中。

示例

# 使用 format() 进行字符串拼接
name = "Alice"
age = 30
sentence = "My name is {} and I am {} years old.".format(name, age)
print(sentence)  # 输出: My name is Alice and I am 30 years old.

通过使用 {} 占位符，我们可以将多个变量插入到字符串中的指定位置，这使得 format() 方法在需要动态生成文本时非常有用。

高级用法

format() 方法还支持使用命名参数、索引等进行更复杂的格式化操作。

# 使用命名参数
sentence = "My name is {name} and I am {age} years old.".format(name="Bob", age=25)
print(sentence)  # 输出: My name is Bob and I am 25 years old.

# 使用索引
sentence = "{0} is learning {1}".format("Alice", "Python")
print(sentence)  # 输出: Alice is learning Python

🍸4.4 使用 f-string（格式化字符串）

Python 3.6 及之后的版本引入了f-string（格式化字符串），这是最简洁且高效的字符串拼接方式之一。f-string 使用 f 前缀，并允许在字符串中直接嵌入变量或表达式，极大提高了代码的可读性和拼接效率。

示例

# 使用 f-string 拼接字符串
name = "Charlie"
age = 22
sentence = f"My name is {name} and I am {age} years old."
print(sentence)  # 输出: My name is Charlie and I am 22 years old.

f-string 让代码看起来更加简洁，因为不需要调用 format() 方法或使用 + 进行拼接。它还支持在花括号 {} 中嵌入任意的 Python 表达式。

嵌入表达式

# 在 f-string 中嵌入表达式
a = 5
b = 10
sentence = f"The sum of {a} and {b} is {a + b}."
print(sentence)  # 输出: The sum of 5 and 10 is 15.

f-string 是拼接多个字符串的推荐方法，特别是在需要拼接变量时，因为它结合了可读性和性能的优势。

🍸4.5 使用 % 进行格式化拼接（老方法）

在 Python 的早期版本中，使用 % 操作符进行字符串格式化是常见的做法。虽然这种方法逐渐被 format() 和 f-string 取代，但它在某些场景下仍然可以看到。

示例

# 使用 % 进行字符串拼接
name = "Dave"
age = 28
sentence = "My name is %s and I am %d years old." % (name, age)
print(sentence)  # 输出: My name is Dave and I am 28 years old.

• %s 用于表示字符串占位符。
• %d 用于表示整数占位符。

注意事项

• % 格式化的功能较为有限，代码的可读性也较低，因此在现代 Python 编程中通常不再推荐使用。
• 这种方法在拼接大量字符串时效率较低。

🍸4.6 拼接文件路径

在处理文件路径时，手动使用 + 操作符进行拼接并不方便。为了避免处理不同操作系统的路径分隔符差异，Python 提供了 os.path.join() 或 pathlib 模块来进行路径拼接。

示例

import os

# 使用 os.path.join 拼接文件路径
folder = "/home/user"
filename = "document.txt"
full_path = os.path.join(folder, filename)
print(full_path)  # 输出: /home/user/document.txt

这种方法不仅能够确保路径分隔符的正确性，还能处理不同操作系统的文件路径标准。

🍸4.7 性能比较

当我们需要拼接大量字符串时，选择合适的拼接方式非常重要。以下是不同拼接方式的性能比较：

• + 操作符：适合拼接少量字符串。大量字符串拼接时性能较差，因为每次拼接都会创建一个新的字符串对象。
• join() 方法：在拼接大量字符串时最为高效。它只会分配一次内存，不会反复创建新的字符串对象。
• format() 和 f-string：适合拼接带变量的字符串，性能接近 join() 方法，且代码更具可读性。
• % 操作符：是一种老式的格式化方法，性能一般，代码的可读性较低。

性能测试

import time

# 使用 + 拼接字符串
start = time.time()
result = ""
for i in range(100000):
    result += str(i)
end = time.time()
print(f"Using +: {end - start} seconds")

# 使用 join 拼接字符串
start = time.time()
result = "".join([str(i) for i in range(100000)])
end = time.time()
print(f"Using join: {end - start} seconds")

从性能角度来看，join() 通常是处理大量字符串拼接的最佳选择。

总结

Python 提供了多种方法来进行字符串拼接，每种方法都有其适用的场景。对于简单的拼接操作，+ 操作符非常直观；对于处理多个字符串或列表中的元素，join() 是更高效的选择；而在需要格式化字符串的场景下，format() 和 f-string 是非常灵活且简洁的选择。根据具体的

🍷五、逻辑运算符：处理布尔值

在 Python 编程中，逻辑运算符用于处理布尔值（True 和 False）并执行与、或、非等逻辑操作。它们是控制程序流、条件判断和决策的核心部分。逻辑运算符帮助开发者基于多个条件的组合进行判断，从而控制程序的行为。

Python 提供了三个主要的逻辑运算符：

• and：逻辑与运算
• or：逻辑或运算
• not：逻辑非运算

这些运算符通常用于布尔表达式之间的组合，以生成复杂的条件判断。

🍸5.1 布尔值与逻辑运算

布尔值是 Python 中表示逻辑真值的基本数据类型，它只有两个取值：True 和 False。通过布尔运算符，多个布尔值或条件表达式可以组合在一起，返回一个新的布尔结果。

5.1.1 真值测试

在 Python 中，以下类型的值会被解释为 False：

• 布尔值 False
• 数值 0（包括 0 和 0.0）
• 空字符串 ""
• 空列表 []、空元组 ()、空字典 {}、空集合 set()
• 特殊值 None

任何其他值都会被解释为 True。理解这些真值的转换可以帮助我们在逻辑运算中更好地处理各种类型的数据。

🍸5.2 and 运算符：逻辑与

and 运算符用于检查两个条件是否都为 True。如果两个条件都为真，则返回 True，否则返回 False。

语法

condition1 and condition2

只有当 condition1 和 condition2 都为 True 时，整个表达式才为 True。

示例

# 两个条件都为 True
print(True and True)   # 输出: True

# 一个条件为 False
print(True and False)  # 输出: False

# 两个条件都为 False
print(False and False) # 输出: False

结合条件判断

逻辑 and 常用于结合多个条件进行判断，例如检查一个数是否在某个范围内：

# 检查一个数是否在 0 到 100 之间
num = 50
if num > 0 and num < 100:
    print("The number is between 0 and 100.")
else:
    print("The number is out of range.")

短路运算

and 运算符具有短路行为，这意味着如果第一个条件为 False，Python 不会检查第二个条件，因为结果已经确定为 False。

# 短路行为示例
a = False
b = True
print(a and b)  # 输出: False（b 不会被评估，因为 a 为 False）

🍸5.3 or 运算符：逻辑或

or 运算符用于检查至少一个条件为 True。只要有一个条件为 True，则整个表达式为 True。如果所有条件都为 False，结果才会是 False。

语法

condition1 or condition2

只要 condition1 或 condition2 其中一个为 True，整个表达式就是 True。

示例

# 两个条件都为 True
print(True and True)   # 输出: True

# 一个条件为 True
print(True or False)   # 输出: True

# 两个条件都为 False
print(False or False)  # 输出: False

结合条件判断

or 常用于检查多个可能的情况，例如判断一个数是否在两个区间之外：

# 检查一个数是否小于 0 或大于 100
num = -5
if num < 0 or num > 100:
    print("The number is out of range.")
else:
    print("The number is between 0 and 100.")

短路运算

or 运算符同样具有短路行为。如果第一个条件为 True，Python 不会检查第二个条件，因为结果已经确定为 True。

# 短路行为示例
a = True
b = False
print(a or b)  # 输出: True（b 不会被评估，因为 a 为 True）

🍸5.4 not 运算符：逻辑非

not 运算符是用于取反的逻辑运算符。它将布尔值 True 转换为 False，将 False 转换为 True。

语法

not condition

not 会将 condition 的布尔值取反。如果 condition 为 True，则结果为 False；如果 condition 为 False，则结果为 True。

示例

print(not True)    # 输出: False
print(not False)   # 输出: True

结合条件判断

not 运算符常用于逻辑条件的反转，例如检查某个条件是否不成立：

# 检查用户是否不是管理员
is_admin = False
if not is_admin:
    print("Access denied.")
else:
    print("Welcome, admin!")

🍸5.5 逻辑运算符的组合使用

可以将 and、or 和 not 组合使用来处理更复杂的条件逻辑。例如，检查多个条件并根据不同的组合进行操作。

示例

age = 25
has_permission = True

# 组合逻辑：检查用户是否有权限，并且年龄大于 18
if has_permission and age > 18:
    print("Access granted.")
else:
    print("Access denied.")

🍸5.6 使用逻辑运算符处理非布尔值

在 Python 中，逻辑运算符不仅可以用于布尔值，还可以用于非布尔值。Python 评估非布尔值时，会根据真值测试规则，将其转换为 True 或 False。

5.6.1 and 和 or 的短路返回

• and 返回第一个 False 的值或最后一个 True 的值。
• or 返回第一个 True 的值或最后一个 False 的值。

# 非布尔值与 and 运算符
print(0 and 5)       # 输出: 0（第一个 False）
print(4 and 5)       # 输出: 5（两个都为 True）

# 非布尔值与 or 运算符
print(0 or 5)        # 输出: 5（第一个 True）
print(4 or 5)        # 输出: 4（第一个 True）

在这个例子中，Python 根据短路行为直接返回第一个能确定结果的值，而不是返回布尔值。这种特性可以用于简化代码，避免显式的 if 语句。

5.6.2 not 的应用

not 运算符可以将非布尔值的真值转换为布尔值，然后取反：

print(not 0)      # 输出: True（0 被视为 False）
print(not 5)      # 输出: False（5 被视为 True）

🍸5.7 常见应用场景

5.7.1 检查多个条件

逻辑运算符广泛用于 if 语句中检查多个条件：

username = "admin"
password = "secret"

# 组合多个条件进行检查
if username == "admin" and password == "secret":
    print("Login successful.")
else:
    print("Login failed.")

5.7.2 默认值的使用

逻辑运算符常用于处理默认值或为空值的情况。例如，使用 or 运算符为变量设置默认值：

python复制代码name = input("Enter your name: ") or "Guest"
print(f"Hello, {name}!")

如果用户没有输入任何内容，name 会被赋值为 "Guest"，因为空字符串会被评估为 False，而 or 会返回第二个值。

🍸5.8 运算符的优先级

在组合使用逻辑运算符时，运算符的优先级非常重要。not 的优先级最高，其次是 and，最后是 or。这意味着在没有使用括号时，Python 会按照这个优先级顺序计算表达式。

示例

# 默认优先级下的运算
result = True or False and not False
print(result)  # 输出: True

# 添加括号改变优先级
result = (True or False) and not False
print(result)  # 输出: True

🍷六、 成员运算符：检查值是否存在于序列中

在Python中，成员运算符用于检查一个值是否存在于一个序列（如列表、元组、字符串或字典）中。主要有两个成员运算符：

1. in 运算符：检查值是否存在于序列中。
2. not in 运算符：检查值是否不存在于序列中。

示例

# 检查值是否在列表中
my_list = [1, 2, 3, 4, 5]

# 使用 in 运算符
if 3 in my_list:
    print("3 存在于列表中")

# 使用 not in 运算符
if 6 not in my_list:
    print("6 不存在于列表中")

# 检查值是否在字符串中
my_string = "Hello, World!"
if "Hello" in my_string:
    print('"Hello" 存在于字符串中')

# 检查值是否在字典的键中
my_dict = {"name": "Alice", "age": 25}
if "name" in my_dict:
    print('"name" 是字典中的一个键')

# 检查值是否在元组中
my_tuple = (10, 20, 30)
if 20 in my_tuple:
    print("20 存在于元组中")

说明

• in 运算符可以用于任何可迭代对象，如列表、元组、字符串和字典（在字典中，它检查键）。
• not in 是 in 的否定形式，表示如果值不在序列中则返回 True。

🍷七、 条件语句：根据条件执行不同代码块

在Python中，条件语句用于根据不同的条件执行不同的代码块。最常见的条件语句是 if、elif 和 else。

🍸7.1 基本语法

if 条件:
    # 当条件为 True 时执行的代码块
elif 其他条件:
    # 当上一个条件为 False，且该条件为 True 时执行的代码块
else:
    # 当所有条件都为 False 时执行的代码块

示例

x = 10

# 使用 if 条件语句
if x > 10:
    print("x 大于 10")
elif x == 10:
    print("x 等于 10")
else:
    print("x 小于 10")

🍸7.2 嵌套的条件语句

可以在 if 语句内部嵌套另一个 if 语句，形成条件的组合逻辑。

x = 15
y = 20

if x > 10:
    if y > 15:
        print("x 大于 10 且 y 大于 15")
    else:
        print("x 大于 10 但 y 小于等于 15")
else:
    print("x 小于等于 10")

🍸7.3 简化条件表达式（Ternary Operator）

Python 也支持在一行中编写条件语句，称为三元表达式。

x = 5
result = "x 大于 0" if x > 0 else "x 小于等于 0"
print(result)

🍸7.4 多条件判断

可以使用逻辑运算符 and、or 和 not 来进行多个条件的组合判断。

x = 8
y = 12

if x > 5 and y < 15:
    print("x 大于 5 且 y 小于 15")

总结

• if 后面是条件表达式，条件为 True 执行对应代码块，否则跳过。
• 可以使用 elif 和 else 扩展 if 语句，以处理更多情况。
• 使用 and、or、not 组合多个条件。
• 三元表达式适合在简单情况下进行条件判断。

🍷八、 for循环：遍历序列

在Python中，for 循环用于遍历序列，如列表、元组、字典、字符串等。通过 for 循环，可以逐个访问序列中的每个元素。

🍸8.1 基本语法

for 变量 in 序列:
    # 执行的代码块

🍸8.2 遍历列表

my_list = [1, 2, 3, 4, 5]

for item in my_list:
    print(item)

🍸8.3 遍历字符串

my_string = "Hello"

for char in my_string:
    print(char)

🍸8.4 遍历字典

my_dict = {"name": "Alice", "age": 25}

# 遍历字典的键
for key in my_dict:
    print(key)

# 遍历字典的键和值
for key, value in my_dict.items():
    print(f"{key}: {value}")

🍸8.5 使用 range() 生成数值序列

range() 函数用于生成一个数值序列，常用于 for 循环中。

# 打印 0 到 4
for i in range(5):
    print(i)

你还可以指定起始值和步长：

# 打印 2, 4, 6, 8
for i in range(2, 10, 2):
    print(i)

🍸8.6 使用 enumerate() 获取索引和值

enumerate() 函数用于在遍历序列时同时获取索引和值。

my_list = ["apple", "banana", "cherry"]

for index, value in enumerate(my_list):
    print(f"索引 {index} 的值是 {value}")

🍸8.7 使用 break 和 continue

• break：用于提前终止循环。
• continue：跳过本次循环，继续下一次迭代。

# 终止循环
for i in range(5):
    if i == 3:
        break
    print(i)

# 跳过某次循环
for i in range(5):
    if i == 3:
        continue
    print(i)

总结

• for 循环适用于遍历任何可迭代对象。
• 使用 range() 生成数值序列，控制循环的次数和步长。
• 使用 enumerate() 获取序列中的索引和值。
• break 和 continue 控制循环的执行流程。

🍷九、 while循环：基于条件的重复执行

在Python中，while 循环用于基于条件的重复执行。当条件为 True 时，while 循环中的代码块将会被执行，直到条件变为 False。

🍸9.1 基本语法

while 条件:
    # 执行的代码块

🍸9.2 简单的 while 循环

count = 0

while count < 5:
    print(f"当前计数是 {count}")
    count += 1

🍸9.3 使用 break 和 continue

• break：提前终止循环。
• continue：跳过本次循环，继续下一次循环。

count = 0

while count < 5:
    if count == 3:
        break  # 当 count 等于 3 时终止循环
    print(f"当前计数是 {count}")
    count += 1

# 使用 continue 跳过特定的迭代
count = 0

while count < 5:
    count += 1
    if count == 3:
        continue  # 当 count 等于 3 时跳过本次循环
    print(f"当前计数是 {count}")

🍸9.4 无限循环

while 循环在条件始终为 True 时会变成无限循环。通常通过 break 来终止循环，避免程序陷入无限循环。

count = 0

while True:
    print(f"当前计数是 {count}")
    count += 1
    if count >= 5:
        break  # 使用 break 终止无限循环

🍸9.5 使用 while 循环处理用户输入

user_input = ""

while user_input != "exit":
    user_input = input("请输入内容 (输入 'exit' 退出): ")
    print(f"你输入了: {user_input}")

🍸9.6else 和 while 结合

和 for 循环一样，while 循环也可以有一个 else 语句块，在循环条件变为 False 时执行（除非被 break 终止）。

count = 0

while count < 5:
    print(f"当前计数是 {count}")
    count += 1
else:
    print("循环结束")

总结：

• while 循环根据条件重复执行代码块，直到条件变为 False。
• 使用 break 提前终止循环，continue 跳过当前迭代。
• 小心编写条件，避免产生无限循环，除非是特意设计的。

结语

今天的分享到这里就结束啦！如果觉得文章还不错的话，可以三连支持一下，17的主页还有很多有趣的文章，欢迎小伙伴们前去点评，您的支持就是17前进的动力！