表达式

|
# 简单的表达式示例
price = 29.99
quantity = 3
tax_rate = 0.08
 
# 复合表达式计算总价
total = price * quantity * (1 + tax_rate)
print(f"商品总价：{total:.2f}元")

|
# 基本算术运算
a = 15
b = 4
 
print(f"加法：{a} + {b} = {a + b}")
print(f"减法：{a} - {b} = {a - b}")
print(f"乘法：{a} * {b} = {a * b}")
print(f"除法：{a} / {b} = {a / b}")
print(f"整数除法：{a} // {b} = {a // b}")
print(f"取余：{a} % {b} = {a % b}")
print(f"幂运算：{a} ** {b} = {a ** b}")

|
# 运算符优先级示例
result1 = 2 + 3 * 4    # 结果是14，不是20
result2 = 2 ** 3 ** 2  # 结果是512（2的9次方），不是64
 
print(f"2 + 3 * 4 = {result1}")
print(f"2 ** 3 ** 2 = {result2}")
 
# 使用括号改变运算顺序
result3 = (2 + 3) * 4     # 结果是20
result4 = (2 ** 3) ** 2   # 结果是64
 
print(f"(2 + 3) * 4 = {result3}")
print(f"(2 ** 3) ** 2 = {result4}")

|
# 类型自动转换
integer_num = 10
float_num = 3.5
 
result = integer_num + float_num
print(f"整数 + 浮点数 = {result}，类型：{type(result)}")
 
# 除法运算总是返回浮点数
division_result = 20 / 4
print(f"20 / 4 = {division_result}，类型：{type(division_result)}")
 
# 整数除法返回整数（如果操作数都是整数）
floor_division_result = 20 // 3
print(f"20 // 3 = {floor_division_result}，类型：{type(floor_division_result)}")

|
import math
 
# 无穷大
positive_infinity = float('inf')
negative_infinity = float('-inf')
 
print(f"正无穷：{positive_infinity}")
print(f"负无穷：{negative_infinity}")
print(f"1 / 0 的结果（当用浮点数时）：{1.0 / 0}")  # 会产生警告但不会错误
 
# 非数值 (Not a Number)
not_a_number = float('nan')
print(f"NaN：{not_a_number}")
print(f"0 / 0 的结果：{0.0 / 0}")  # 会产生警告

|
# 数值比较示例
score = 85
passing_grade = 60
 
print(f"是否及格：{score >= passing_grade}")
print(f"是否满分：{score == 100}")
print(f"是否需要补考：{score < passing_grade}")
 
# 可以进行链式比较
age = 25
print(f"是否成年且未满退休年龄：{18 <= age < 65}")
 
# 浮点数比较需要注意精度问题
result = 0.1 + 0.2
print(f"0.1 + 0.2 是否等于 0.3：{result == 0.3}")
print(f"实际结果：{result}")

|
# 字符串比较
name1 = "Alice"
name2 = "Bob"
name3 = "alice"
 
print(f"字典序比较：{'Alice' < 'Bob'}")
print(f"大小写敏感：{'Alice' == 'alice'}")
print(f"长度对比较的影响：{'cat' < 'category'}")
 
# 字符串方法在比较中的应用
print(f"忽略大小写比较：{name1.lower() == name3.lower()}")

|
# 列表比较
list1 = [1, 2, 3]
list2 = [1, 2, 4]
list3 = [1, 2]
 
print(f"列表按字典序比较：{list1 < list2}")
print(f"长度对比较的影响：{list3 < list1}")
 
# 元组比较
tuple1 = (1, 2, 3)
tuple2 = (1, 2, 3)
print(f"元组相等比较：{tuple1 == tuple2}")

|
# 身份比较
a = [1, 2, 3]
b = [1, 2, 3]
c = a
 
print(f"值相等但不是同一对象：{a == b and a is not b}")
print(f"指向同一对象：{a is c}")
 
# 成员测试
fruits = ['苹果', '香蕉', '橙子']
print(f"苹果在水果列表中：{'苹果' in fruits}")
print(f"葡萄不在水果列表中：{'葡萄' not in fruits}")
 
# 字符串成员测试
text = "Python编程很有趣"
print(f"是否包含'编程'：{'编程' in text}")

|
# 逻辑与运算示例
age = 20
income = 5000
 
# 申请信用卡的条件：年龄大于18且收入大于3000
can_apply_card = age > 18 and income > 3000
print(f"是否可以申请信用卡：{can_apply_card}")
 
# 短路特性演示
def expensive_check():
    print("执行了昂贵的检查操作")
    return True
 
# 由于第一个条件为假，不会执行expensive_check函数
result = False and expensive_check()
print(f"短路结果：{result}")

|
# 逻辑或运算示例
weekend = True
holiday = False
 
# 可以休息的条件：周末或者假期
can_rest = weekend or holiday
print(f"今天可以休息：{can_rest}")
 
# 设置默认值的常见用法
user_name = ""
display_name = user_name or "匿名用户"
print(f"显示名称：{display_name}")
 
# 多条件的或运算
score = 75
is_excellent = score >= 90 or score >= 80 and has_bonus_points

|
# 逻辑非运算示例
is_logged_in = False
needs_login = not is_logged_in
print(f"需要登录：{needs_login}")
 
# 检查空容器
shopping_cart = []
cart_is_empty = not shopping_cart
print(f"购物车为空：{cart_is_empty}")
 
# 复杂条件中的非运算
password = "12345"
is_weak_password = not (len(password) >= 8 and any(c.isalpha() for c in password))
print(f"密码强度不够：{is_weak_password}")

|
# 复杂逻辑表达式示例
age = 25
has_license = True
has_car = False
emergency = True
 
# 可以驾驶的条件
can_drive = (age >= 18 and has_license) and (has_car or emergency)
print(f"可以驾驶：{can_drive}")
 
# 学生折扣条件
is_student = True
age = 20
has_student_id = True
 
gets_discount = is_student and (age <= 25 or has_student_id)
print(f"享受学生折扣：{gets_discount}")

|
# 字符串连接
first_name = "张"
last_name = "小明"
full_name = first_name + last_name
print(f"完整姓名：{full_name}")
 
# 字符串重复
separator = "-" * 20
print(separator)
print("重要通知")
print(separator)
 
# 连接多个字符串
greeting = "您好，" + full_name + "先生"
print(greeting)
 
# 更复杂的字符串构建
border = "=" * 30
title = "欢迎使用Python"
formatted_title = border + "\n" + title.center(30) + "\n" + border
print(formatted_title)

|
# f-字符串格式化
name = "小王"
age = 28
salary = 8500.5
 
# 基本格式化
intro = f"我叫{name}，今年{age}岁"
print(intro)
 
# 表达式计算
next_year_age = f"明年我就{age + 1}岁了"
print(next_year_age)
 
# 数字格式化
formatted_salary = f"我的月薪是{salary:,.2f}元"
print(formatted_salary)
 
# 条件表达式在f-字符串中的使用
status = f"{name}{'已成年' if age >= 18 else '未成年'}"
print(status)

|
# 字符串方法链式调用
user_input = "  Hello, World!  "
processed = user_input.strip().lower().replace("world", "python")
print(f"处理后的字符串：'{processed}'")
 
# 字符串测试方法
email = "user@example.com"
is_valid_format = "@" in email and "." in email.split("@")[1]
print(f"邮箱格式正确：{is_valid_format}")
 
# 字符串分割和组合
sentence = "Python是一门优秀的编程语言"
words = sentence.split("是")
reconstructed = "确实是".join(words)
print(f"重构后的句子：{reconstructed}")
 
# 条件检查方法
password = "MyPassword123"
is_strong = (len(password) >= 8 and 
             any(c.isupper() for c in password) and
             any(c.islower() for c in password) and
             any(c.isdigit() for c in password))
print(f"密码强度足够：{is_strong}")

|
# 字符串切片
text = "Python编程很有趣"
 
# 基本切片
first_part = text[:6]  # 前6个字符
last_part = text[6:]   # 从第7个字符到末尾
middle = text[2:8]     # 第3到第8个字符
 
print(f"前半部分：{first_part}")
print(f"后半部分：{last_part}")
print(f"中间部分：{middle}")
 
# 带步长的切片
reversed_text = text[::-1]  # 反转字符串
every_second = text[::2]    # 每隔一个字符取一个
 
print(f"反转后：{reversed_text}")
print(f"每隔一个字符：{every_second}")
 
# 组合切片操作
filename = "document.pdf"
name_part = filename[:filename.rfind('.')]
extension = filename[filename.rfind('.') + 1:]
print(f"文件名：{name_part}，扩展名：{extension}")

|
# 列表创建和访问
scores = [85, 92, 78, 96, 88]
student_names = ["小明", "小红", "小刚", "小丽", "小华"]
 
# 索引访问表达式
best_score = scores[0] if scores else 0
last_student = student_names[-1]
print(f"最高分：{best_score}")
print(f"最后一个学生：{last_student}")
 
# 条件索引访问
index = 2
safe_access = scores[index] if 0 <= index < len(scores) else "无效索引"
print(f"安全访问结果：{safe_access}")
 
# 列表切片表达式
top_three = scores[:3]
bottom_two = scores[-2:]
middle_section = scores[1:-1]
 
print(f"前三名分数：{top_three}")
print(f"后两名分数：{bottom_two}")
print(f"中间部分：{middle_section}")

|
# 列表方法表达式
numbers = [1, 2, 3, 2, 4, 2, 5]
 
# 查找方法
first_occurrence = numbers.index(2)
count_of_twos = numbers.count(2)
print(f"数字2第一次出现的位置：{first_occurrence}")
print(f"数字2出现的次数：{count_of_twos}")
 
# 列表复制和扩展
original = [1, 2, 3]
doubled = original * 2
extended = original + [4, 5, 6]
 
print(f"重复列表：{doubled}")
print(f"扩展列表：{extended}")
 
# 列表推导式表达式
squares = [x**2 for x in range(1, 6)]
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
 
print(f"平方数列表：{squares}")
print(f"偶数的平方：{even_squares}")

|
# 成员测试表达式
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
vegetables = ["白菜", "萝卜", "西红柿"]
 
has_apple = "苹果" in fruits
has_tomato = "西红柿" in vegetables
has_both = "苹果" in fruits and "萝卜" in vegetables
 
print(f"有苹果：{has_apple}")
print(f"有西红柿：{has_tomato}")
print(f"既有苹果又有萝卜：{has_both}")
 
# 列表比较表达式
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = [1, 2, 4]
 
are_equal = list1 == list2
is_lexicographically_smaller = list1 < list3
 
print(f"列表相等：{are_equal}")
print(f"字典序比较：{is_lexicographically_smaller}")
 
# 嵌套容器的成员测试
matrix = [[1, 2], [3, 4], [5, 6]]
has_row = [3, 4] in matrix
has_element = any(3 in row for row in matrix)
 
print(f"包含行[3, 4]：{has_row}")
print(f"包含元素3：{has_element}")

|
# 数学函数调用
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
 
maximum = max(numbers)
minimum = min(numbers)
total = sum(numbers)
count = len(numbers)
average = sum(numbers) / len(numbers)
 
print(f"最大值：{maximum}")
print(f"最小值：{minimum}")
print(f"总和：{total}")
print(f"平均值：{average:.2f}")
 
# 类型转换函数
user_input = "123"
number = int(user_input) if user_input.isdigit() else 0
float_number = float(user_input) if user_input.replace('.', '').isdigit() else 0.0
 
print(f"转换后的整数：{number}")
print(f"转换后的浮点数：{float_number}")
 
# 序列函数
text = "hello world"
characters = list(text)
unique_chars = list(set(text))
sorted_chars = sorted(unique_chars)
 
print(f"字符列表：{characters}")
print(f"唯一字符：{unique_chars}")
print(f"排序后的字符：{sorted_chars}")

|
# 字符串方法链式调用
text = "  HELLO, PYTHON WORLD!  "
processed = text.strip().lower().replace("world", "universe").title()
print(f"处理后的文本：{processed}")
 
# 列表方法链式调用结合列表推导式
data = ["apple", "Banana", "Cherry", "date"]
normalized = [item.lower().strip() for item in data]
sorted_data = sorted(normalized, key=len)
print(f"标准化并排序：{sorted_data}")
 
# 数字处理的链式调用
import math
 
angle_degrees = 45
result = math.sin(math.radians(angle_degrees))
rounded_result = round(result, 4)
print(f"sin(45°) = {rounded_result}")

|
# 复杂表达式的优先级演示
a, b, c = 2, 3, 4
 
# 算术和比较的组合
result1 = a + b * c > 10  # 相当于 (a + (b * c)) > 10
print(f"a + b * c > 10 的结果：{result1}")
 
# 逻辑和比较的组合
x, y, z = 5, 10, 15
complex_condition = x < y and y < z or x > 20
print(f"复杂条件的结果：{complex_condition}")
 
# 函数调用的优先级
numbers = [1, 2, 3, 4, 5]
avg_greater_than_three = sum(numbers) / len(numbers) > 3
print(f"平均值大于3：{avg_greater_than_three}")

|
# 使用括号明确意图
price = 100
discount_rate = 0.1
tax_rate = 0.05
 
# 不清晰的表达式
unclear_total = price - price * discount_rate + price * tax_rate
 
# 清晰的表达式
clear_total = price - (price * discount_rate) + (price * tax_rate)
 
# 更清晰的分步计算
discount_amount = price * discount_rate
tax_amount = price * tax_rate
final_total = price - discount_amount + tax_amount
 
print(f"不清晰计算：{unclear_total}")
print(f"清晰计算：{clear_total}")
print(f"分步计算：{final_total}")

|
# 短路求值的应用
def expensive_operation():
    print("执行了耗时操作")
    return True
 
# 短路避免不必要的计算
flag = False
result = flag and expensive_operation()
print(f"短路结果：{result}")
 
# 短路避免错误
data = []
has_data = len(data) > 0 and data[0] > 10
print(f"安全检查结果：{has_data}")
 
# 使用短路设置默认值
user_input = ""
name = user_input or "匿名用户"
print(f"用户名：{name}")

|
# 复杂嵌套表达式的分解
students = [
    {"name": "小明", "scores": [85, 90, 78]},
    {"name": "小红", "scores": [92, 88, 95]},
    {"name": "小刚", "scores": [76, 84, 80]}
]
 
# 一次性的复杂表达式（不推荐）
complex_result = sum(sum(student["scores"]) / len(student["scores"]) for student in students) / len(students)
 
# 分解后的清晰表达式（推荐）
student_averages = []
for student in students:
    student_average = sum(student["scores"]) / len(student["scores"])
    student_averages.append(student_average)
 
class_average = sum(student_averages) / len(student_averages)
 
print(f"复杂表达式结果：{complex_result:.2f}")
print(f"分解表达式结果：{class_average:.2f}")
 
# 使用列表推导式的中等复杂度表达式
class_average_comprehension = sum(sum(s["scores"])/len(s["scores"]) for s in students) / len(students)
print(f"推导式结果：{class_average_comprehension:.2f}")