# Python变量与运算符完全指南：从命名规则到复合运算

## 引言：编程语言的词汇与语法

常量和变量是编程语言中最基础的数据承载单元，而运算符则是操作这些数据的基本工具。理解Python中变量命名、数据类型以及各类运算符的用法，是掌握编程逻辑的第一步。本文将从基础概念入手，深入讲解Python中的常量约定、变量特性以及各类运算符的实践应用。

## 变量与常量：数据存储的基础

### 变量声明与命名规范

```python

# 变量基础与命名规范

def variable_fundamentals():

    """变量基础概念演示"""

    

    print("=== 变量声明与赋值 ===")

    

    # 1. 基本变量赋值

    counter = 10           # 整数变量

    price = 29.99          # 浮点数变量

    product_name = "手机"  # 字符串变量

    is_available = True    # 布尔变量

    

    print(f"计数器: {counter}")

    print(f"价格: {price}")

    print(f"产品名称: {product_name}")

    print(f"是否可用: {is_available}")

    

    # 2. 多重赋值

    x = y = z = 0          # 多个变量赋相同值

    print(f"\n多重赋值: x={x}, y={y}, z={z}")

    

    # 3. 链式赋值

    a, b, c = 1, 2, 3      # 同时为多个变量赋值

    print(f"链式赋值: a={a}, b={b}, c={c}")

    

    # 4. 变量值交换

    print(f"\n交换前: a={a}, b={b}")

    a, b = b, a            # Python特色的值交换

    print(f"交换后: a={a}, b={b}")

    

    # 5. 变量重新赋值（动态类型特性）

    dynamic_var = 100

    print(f"\n初始类型: {type(dynamic_var)}, 值: {dynamic_var}")

    

    dynamic_var = "现在我是字符串"

    print(f"重新赋值后类型: {type(dynamic_var)}, 值: {dynamic_var}")

    

    print("\n=== Python命名规范 ===")

    

    # 正确命名示例

    student_count = 30      # 小写字母，单词间用下划线（推荐）

    totalPrice = 199.99     # 驼峰命名法（某些情况下使用）

    MAX_RETRIES = 3         # 常量使用大写字母和下划线

    _internal_data = []     # 单下划线开头表示内部使用

    

    # Python关键字不能用作变量名

    # 错误示例：if = 10  # 语法错误

    

    print("正确命名示例:")

    print(f"  student_count = {student_count}")

    print(f"  totalPrice = {totalPrice}")

    print(f"  MAX_RETRIES = {MAX_RETRIES}")

    print(f"  _internal_data = {_internal_data}")

    

    # 6. 查看变量信息

    print("\n=== 变量信息查询 ===")

    

    sample_var = 3.1415926

    

    # 查看类型

    var_type = type(sample_var)

    print(f"变量类型: {var_type}")

    

    # 查看内存地址

    var_id = id(sample_var)

    print(f"内存地址: {var_id}")

    

    # 查看变量大小（需要sys模块）

    import sys

    var_size = sys.getsizeof(sample_var)

    print(f"占用内存: {var_size} 字节")

# 运行变量基础演示

variable_fundamentals()

```

### 常量约定与类型系统

```python

# 常量约定与类型处理

def constants_and_types():

    """常量约定与数据类型处理"""

    

    print("=== Python中的常量约定 ===")

    

    # Python没有真正的常量，但有大写命名约定

    PI = 3.141592653589793

    MAX_CONNECTIONS = 100

    DEFAULT_TIMEOUT = 30

    API_BASE_URL = "https://api.example.com"

    

    print(f"圆周率: {PI}")

    print(f"最大连接数: {MAX_CONNECTIONS}")

    print(f"默认超时: {DEFAULT_TIMEOUT}秒")

    print(f"API基础地址: {API_BASE_URL}")

    

    # 警告：这些"常量"实际上可以被修改

    PI = 3.14  # 不推荐这样做，但语法上允许

    print(f"\n警告：常量被修改为 {PI}")

    

    print("\n=== 数据类型基础 ===")

    

    # 基本数据类型

    int_value = 42

    float_value = 3.14

    str_value = "Hello Python"

    bool_value = True

    none_value = None

    

    print(f"整数: {int_value}, 类型: {type(int_value)}")

    print(f"浮点数: {float_value}, 类型: {type(float_value)}")

    print(f"字符串: {str_value}, 类型: {type(str_value)}")

    print(f"布尔值: {bool_value}, 类型: {type(bool_value)}")

    print(f"空值: {none_value}, 类型: {type(none_value)}")

    

    print("\n=== 类型转换 ===")

    

    # 显式类型转换

    str_num = "123"

    converted_int = int(str_num)

    converted_float = float(str_num)

    

    print(f"字符串 '{str_num}' 转换:")

    print(f"  整数: {converted_int}, 类型: {type(converted_int)}")

    print(f"  浮点数: {converted_float}, 类型: {type(converted_float)}")

    

    # 布尔值转换

    print("\n布尔值转换:")

    print(f"  bool(0) = {bool(0)}")

    print(f"  bool(1) = {bool(1)}")

    print(f"  bool('') = {bool('')}")

    print(f"  bool('Hello') = {bool('Hello')}")

    print(f"  bool([]) = {bool([])}")

    print(f"  bool([1, 2]) = {bool([1, 2])}")

    

    # 类型检查

    print("\n=== 类型检查 ===")

    

    values = [42, 3.14, "text", True, None, [1, 2]]

    

    for value in values:

        if isinstance(value, int):

            print(f"{value} 是整数")

        elif isinstance(value, float):

            print(f"{value} 是浮点数")

        elif isinstance(value, str):

            print(f"'{value}' 是字符串")

        elif isinstance(value, bool):

            print(f"{value} 是布尔值")

        elif value is None:

            print("None 是空值")

        else:

            print(f"{value} 是其他类型: {type(value)}")

    

    print("\n=== 数值表示形式 ===")

    

    # 不同进制的整数表示

    decimal_num = 100

    binary_num = 0b1100100    # 二进制

    octal_num = 0o144         # 八进制

    hex_num = 0x64           # 十六进制

    

    print(f"十进制 100 = {decimal_num}")

    print(f"二进制 0b1100100 = {binary_num}")

    print(f"八进制 0o144 = {octal_num}")

    print(f"十六进制 0x64 = {hex_num}")

    

    # 科学计数法

    large_num = 1.23e6       # 1.23 × 10^6

    small_num = 5.67e-3      # 5.67 × 10^-3

    

    print(f"\n科学计数法:")

    print(f"  1.23e6 = {large_num}")

    print(f"  5.67e-3 = {small_num}")

# 运行常量与类型演示

constants_and_types()

```

## 算术运算符：数学计算基础

```python

# 算术运算符详解

def arithmetic_operators():

    """算术运算符的详细用法"""

    

    print("=== 基本算术运算 ===")

    

    a = 10

    b = 3

    

    # 基本运算

    addition = a + b          # 加法

    subtraction = a - b       # 减法

    multiplication = a * b    # 乘法

    division = a / b          # 除法（浮点数结果）

    

    print(f"a = {a}, b = {b}")

    print(f"加法: {a} + {b} = {addition}")

    print(f"减法: {a} - {b} = {subtraction}")

    print(f"乘法: {a} × {b} = {multiplication}")

    print(f"除法: {a} ÷ {b} = {division:.3f}")

    

    print("\n=== 整数除法与取余 ===")

    

    # 整数除法与取余

    floor_division = a // b   # 整数除法（向下取整）

    modulus = a % b           # 取余运算

    power = a ** b            # 幂运算

    

    print(f"整数除法: {a} // {b} = {floor_division}")

    print(f"取余运算: {a} % {b} = {modulus}")

    print(f"幂运算: {a} ** {b} = {power}")

    

    print("\n=== 运算符优先级 ===")

    

    # 运算符优先级演示

    result1 = 2 + 3 * 4       # 乘法优先

    result2 = (2 + 3) * 4     # 括号优先

    result3 = 2 ** 3 * 4      # 幂运算优先

    result4 = 2 * 3 ** 4      # 幂运算优先

    

    print(f"2 + 3 * 4 = {result1}")      # 14

    print(f"(2 + 3) * 4 = {result2}")    # 20

    print(f"2 ** 3 * 4 = {result3}")     # 32

    print(f"2 * 3 ** 4 = {result4}")     # 162

    

    print("\n=== 浮点数运算注意事项 ===")

    

    # 浮点数精度问题

    float_result = 0.1 + 0.2

    print(f"0.1 + 0.2 = {float_result}")

    print(f"精确值: {float_result:.17f}")  # 显示更多小数位

    

    # 比较浮点数时应考虑精度误差

    tolerance = 1e-10  # 容差

    if abs(float_result - 0.3) < tolerance:

        print("0.1 + 0.2 ≈ 0.3 (在容差范围内)")

    

    print("\n=== 增强的数学运算 ===")

    

    # 使用math模块进行高级运算

    import math

    

    # 平方根

    sqrt_value = math.sqrt(16)

    print(f"√16 = {sqrt_value}")

    

    # 对数

    log_value = math.log(100, 10)  # log10(100)

    print(f"log10(100) = {log_value}")

    

    # 三角函数（弧度制）

    angle_rad = math.radians(45)  # 45度转弧度

    sin_value = math.sin(angle_rad)

    cos_value = math.cos(angle_rad)

    

    print(f"sin(45°) = {sin_value:.4f}")

    print(f"cos(45°) = {cos_value:.4f}")

    

    # 圆周率和自然常数

    print(f"\n数学常数:")

    print(f"π = {math.pi:.6f}")

    print(f"e = {math.e:.6f}")

    

    print("\n=== 复数运算 ===")

    

    # 复数运算

    c1 = 3 + 4j

    c2 = 1 - 2j

    

    print(f"复数 c1 = {c1}")

    print(f"复数 c2 = {c2}")

    print(f"c1 + c2 = {c1 + c2}")

    print(f"c1 * c2 = {c1 * c2}")

    print(f"c1 的实部: {c1.real}")

    print(f"c1 的虚部: {c1.imag}")

    print(f"c1 的模: {abs(c1):.2f}")

    print(f"c1 的共轭: {c1.conjugate()}")

# 运行算术运算符演示

arithmetic_operators()

```

## 比较与逻辑运算符：条件判断核心

```python

# 比较与逻辑运算符

def comparison_logical_operators():

    """比较运算符和逻辑运算符详解"""

    

    print("=== 比较运算符 ===")

    

    x = 10

    y = 5

    z = 10

    

    # 基本比较运算

    print(f"x = {x}, y = {y}, z = {z}")

    print(f"x > y: {x > y}")       # 大于

    print(f"x < y: {x < y}")       # 小于

    print(f"x >= z: {x >= z}")     # 大于等于

    print(f"y <= z: {y <= z}")     # 小于等于

    print(f"x == z: {x == z}")     # 等于

    print(f"x != y: {x != y}")     # 不等于

    

    print("\n=== 字符串比较 ===")

    

    # 字符串比较（按字典序）

    str1 = "apple"

    str2 = "banana"

    str3 = "Apple"  # 注意大小写

    

    print(f"'apple' == 'apple': {str1 == 'apple'}")

    print(f"'apple' < 'banana': {str1 < str2}")

    print(f"'apple' == 'Apple': {str1 == str3}")

    print(f"'apple' > 'Apple': {str1 > str3}")  # 小写字母ASCII值大于大写

    

    print("\n=== 链式比较 ===")

    

    # Python特有的链式比较

    value = 15

    

    # 传统写法

    if value > 10 and value < 20:

        print(f"{value} 在10和20之间（传统写法）")

    

    # 链式比较写法

    if 10 < value < 20:

        print(f"{value} 在10和20之间（链式比较）")

    

    # 更复杂的链式比较

    a, b, c = 1, 3, 5

    if a < b < c:

        print(f"{a} < {b} < {c} 成立")

    

    print("\n=== 逻辑运算符 ===")

    

    # 逻辑运算符：and, or, not

    age = 25

    has_license = True

    has_car = False

    

    print(f"年龄: {age}, 有驾照: {has_license}, 有车: {has_car}")

    

    # and运算（与）

    can_drive = age >= 18 and has_license

    print(f"可以驾驶: {can_drive}")

    

    # or运算（或）

    can_transport = has_car or has_license

    print(f"可以运输: {can_transport}")

    

    # not运算（非）

    cannot_drive = not can_drive

    print(f"不能驾驶: {cannot_drive}")

    

    print("\n=== 逻辑运算符的短路特性 ===")

    

    def expensive_check(value):

        """模拟一个耗时的检查"""

        print(f"执行耗时检查: {value}")

        return value > 0

    

    # 短路特性演示

    print("使用and运算符:")

    result1 = False and expensive_check(10)  # 短路，不执行expensive_check

    print(f"结果: {result1}")

    

    print("\n使用or运算符:")

    result2 = True or expensive_check(10)    # 短路，不执行expensive_check

    print(f"结果: {result2}")

    

    print("\n未发生短路的情况:")

    result3 = True and expensive_check(10)   # 需要执行expensive_check

    result4 = False or expensive_check(5)    # 需要执行expensive_check

    

    print("\n=== 运算符优先级示例 ===")

    

    # 复杂的逻辑表达式

    score = 85

    attendance = 0.9

    assignments_completed = True

    

    # 使用括号明确优先级

    passed_course = (score >= 60 and attendance >= 0.8) or assignments_completed

    

    print(f"分数: {score}, 出勤率: {attendance}, 完成作业: {assignments_completed}")

    print(f"通过课程: {passed_course}")

    

    # 等价于

    passed_course_clear = (score >= 60 and attendance >= 0.8) or assignments_completed

    print(f"明确优先级后: {passed_course_clear}")

# 运行比较与逻辑运算符演示

comparison_logical_operators()

```

## 赋值与复合运算符：高效操作变量

```python

# 赋值运算符与复合运算符

def assignment_operators():

    """赋值运算符和复合赋值运算符详解"""

    

    print("=== 基本赋值运算符 ===")

    

    # 基本赋值

    x = 10

    print(f"初始值: x = {x}")

    

    # 重新赋值

    x = x + 5

    print(f"x = x + 5 后: x = {x}")

    

    print("\n=== 复合赋值运算符 ===")

    

    # 重置变量

    x = 10

    

    # 复合赋值运算符

    x += 5      # 等价于 x = x + 5

    print(f"x += 5 后: x = {x}")

    

    x -= 3      # 等价于 x = x - 3

    print(f"x -= 3 后: x = {x}")

    

    x *= 2      # 等价于 x = x * 2

    print(f"x *= 2 后: x = {x}")

    

    x /= 4      # 等价于 x = x / 4

    print(f"x /= 4 后: x = {x}")

    

    x //= 2     # 等价于 x = x // 2

    print(f"x //= 2 后: x = {x}")

    

    x %= 3      # 等价于 x = x % 3

    print(f"x %= 3 后: x = {x}")

    

    x **= 2     # 等价于 x = x ** 2

    print(f"x **= 2 后: x = {x}")

    

    print("\n=== 字符串的复合赋值 ===")

    

    text = "Hello"

    print(f"初始文本: {text}")

    

    text += " World"    # 字符串连接

    print(f"text += ' World' 后: {text}")

    

    text *= 2           # 字符串重复

    print(f"text *= 2 后: {text}")

    

    print("\n=== 列表的复合赋值 ===")

    

    numbers = [1, 2, 3]

    print(f"初始列表: {numbers}")

    

    numbers += [4, 5]   # 列表扩展

    print(f"numbers += [4, 5] 后: {numbers}")

    

    numbers *= 2        # 列表重复

    print(f"numbers *= 2 后: {numbers}")

    <"d0.p5k3.org.cn"><"h4.p5k3.org.cn"><"v6.p5k3.org.cn">

    print("\n=== 解包赋值 ===")

    

    # 元组解包

    coordinates = (10, 20, 30)

    x, y, z = coordinates

    print(f"元组 {coordinates} 解包:")

    print(f"  x = {x}, y = {y}, z = {z}")

    

    # 列表解包

    colors = ["红", "绿", "蓝"]

    r, g, b = colors

    print(f"列表 {colors} 解包:")

    print(f"  r = {r}, g = {g}, b = {b}")

    

    # 使用*收集多余元素

    first, *middle, last = [1, 2, 3, 4, 5]

    print(f"\n使用*收集:")

    print(f"  first = {first}")

    print(f"  middle = {middle}")

    print(f"  last = {last}")

    

    print("\n=== 链式赋值与多重赋值 ===")

    

    # 链式赋值

    a = b = c = 0

    print(f"链式赋值: a={a}, b={b}, c={c}")

    

    # 多重赋值

    x, y, z = 1, 2, 3

    print(f"多重赋值: x={x}, y={y}, z={z}")

    

    # 变量值交换

    print(f"\n交换前: x={x}, y={y}")

    x, y = y, x

    print(f"交换后: x={x}, y={y}")

    

    print("\n=== 海象运算符（Python 3.8+）===")

    

    # 海象运算符 := （赋值表达式）

    data = "Python 3.8"

    

    # 传统写法

    length = len(data)

    if length > 5:

        print(f"数据 '{data}' 长度 {length} 大于5")

    

    # 使用海象运算符

    if (n := len(data)) > 5:

        print(f"数据 '{data}' 长度 {n} 大于5（使用海象运算符）")

    

    # 在列表推导式中使用

    numbers = [1, 2, 3, 4, 5, 6]

    

    # 传统写法

    squared = []

    for num in numbers:

        square = num ** 2

        if square > 10:

            squared.append(square)

    

    print(f"平方大于10的数（传统）: {squared}")

    

    # 使用海象运算符的列表推导式

    squared_walrus = [square for num in numbers if (square := num ** 2) > 10]

    print(f"平方大于10的数（海象运算符）: {squared_walrus}")

# 运行赋值运算符演示

assignment_operators()

```

## 位运算符与成员运算符

```python

# 位运算符与成员运算符

def bitwise_membership_operators():

    """位运算符和成员运算符详解"""

    

    print("=== 位运算符 ===")

    

    # 二进制表示

    a = 60  # 二进制: 0011 1100

    b = 13  # 二进制: 0000 1101

    

    print(f"a = {a} (二进制: {a:08b})")

    print(f"b = {b} (二进制: {b:08b})")

    

    # 位与运算 &

    bitwise_and = a & b  # 0000 1100 = 12

    print(f"\n位与 a & b:")

    print(f"  {a:08b}")

    print(f"& {b:08b}")

    print(f"  --------")

    print(f"  {bitwise_and:08b} = {bitwise_and}")

    

    # 位或运算 |

    bitwise_or = a | b   # 0011 1101 = 61

    print(f"\n位或 a | b:")

    print(f"  {a:08b}")

    print(f"| {b:08b}")

    print(f"  --------")

    print(f"  {bitwise_or:08b} = {bitwise_or}")

    

    # 位异或运算 ^

    bitwise_xor = a ^ b  # 0011 0001 = 49

    print(f"\n位异或 a ^ b:")

    print(f"  {a:08b}")

    print(f"^ {b:08b}")

    print(f"  --------")

    print(f"  {bitwise_xor:08b} = {bitwise_xor}")

    

    # 位取反运算 ~

    bitwise_not = ~a     # 1100 0011 = -61（补码表示）

    print(f"\n位取反 ~a:")

    print(f"  ~{a:08b}")

    print(f"  --------")

    print(f"  {bitwise_not & 0xFF:08b} = {bitwise_not}")

    

    # 左移运算 <<

    left_shift = a << 2  # 1111 0000 = 240

    print(f"\n左移 a << 2:")

    print(f"  {a:08b} << 2")

    print(f"  --------")

    print(f"  {left_shift:08b} = {left_shift}")

    

    # 右移运算 >>

    right_shift = a >> 2  # 0000 1111 = 15

    print(f"\n右移 a >> 2:")

    print(f"  {a:08b} >> 2")

    print(f"  --------")

    print(f"  {right_shift:08b} = {right_shift}")

    

    print("\n=== 位运算应用示例 ===")

    

    # 1. 判断奇偶性

    def is_even(num):

        """使用位运算判断奇偶"""

        return (num & 1) == 0

    

    for num in [1, 2, 3, 4, 5]:

        print(f"{num} 是偶数: {is_even(num)}")

    

    # 2. 交换两个数（不使用临时变量）

    x, y = 10, 20

    print(f"\n交换前: x={x}, y={y}")

    

    x = x ^ y

    y = x ^ y

    x = x ^ y

    

    print(f"交换后: x={x}, y={y}")

    

    # 3. 检查是否2的幂

    def is_power_of_two(num):

        """检查是否是2的幂"""

        return num > 0 and (num & (num - 1)) == 0

    

    for num in [1, 2, 3, 4, 8, 9, 16]:

        print(f"{num} 是2的幂: {is_power_of_two(num)}")

    

    print("\n=== 成员运算符 ===")

    

    # 列表

    fruits = ["apple", "banana", "orange", "grape"]

    

    print(f"水果列表: {fruits}")

    print(f"'apple' in fruits: {'apple' in fruits}")

    print(f"'pear' in fruits: {'pear' in fruits}")

    print(f"'banana' not in fruits: {'banana' not in fruits}")

    

    # 字符串

    text = "Python programming"

    <"s3.p5k3.org.cn"><"f7.p5k3.org.cn"><"z9.p5k3.org.cn">

    print(f"\n文本: '{text}'")

    print(f"'Python' in text: {'Python' in text}")

    print(f"'Java' in text: {'Java' in text}")

    print(f"'gram' in text: {'gram' in text}")

    

    # 字典（检查键）

    student = {"name": "张三", "age": 20, "major": "CS"}

    

    print(f"\n学生信息: {student}")

    print(f"'name' in student: {'name' in student}")

    print(f"'age' in student: {'age' in student}")

    print(f"'grade' in student: {'grade' in student}")

    print(f"'张三' in student: {'张三' in student}")  # 注意：检查键，不是值

    

    # 集合

    primes = {2, 3, 5, 7, 11, 13}

    

    print(f"\n质数集合: {primes}")

    print(f"5 in primes: {5 in primes}")

    print(f"4 in primes: {4 in primes}")

    print(f"6 not in primes: {6 not in primes}")

    

    print("\n=== 身份运算符 ===")

    

    # is 和 is not 运算符

    list1 = [1, 2, 3]

    list2 = [1, 2, 3]

    list3 = list1

    

    print(f"list1: {list1}, id: {id(list1)}")

    print(f"list2: {list2}, id: {id(list2)}")

    print(f"list3: {list3}, id: {id(list3)}")

    

    print(f"\nlist1 is list2: {list1 is list2}")      # False，不同对象

    print(f"list1 is list3: {list1 is list3}")      # True，同一对象

    print(f"list1 is not list2: {list1 is not list2}")  # True

    

    print(f"\nlist1 == list2: {list1 == list2}")      # True，值相等

    

    # 小整数缓存（Python的特性）

    a = 100

    b = 100

    c = 1000

    d = 1000

    

    print(f"\n小整数缓存测试:")

    print(f"a=100, b=100, a is b: {a is b}")      # True，使用缓存

    print(f"c=1000, d=1000, c is d: {c is d}")    # False，可能不缓存

# 运行位运算和成员运算符演示

bitwise_membership_operators()

```

## 综合应用：运算符优先级与表达式

```python

# 运算符优先级综合应用

def operator_precedence():

    """运算符优先级综合示例"""

    

    print("=== 运算符优先级表 ===")

    

    # Python运算符优先级（从高到低）

    precedence_examples = [

        ("()", "括号", "最高"),

        ("**", "幂运算", "右结合"),

        ("+x, -x, ~x", "一元加、减、按位取反", ""),

        ("*, /, //, %", "乘法、除法、整除、取余", ""),

        ("+, -", "加法、减法", ""),

        ("<<, >>", "位移运算", ""),

        ("&", "位与", ""),

        ("^", "位异或", ""),

        ("|", "位或", ""),

        ("in, not in, is, is not, <, <=, >, >=, !=, ==", "比较、成员、身份运算", ""),

        ("not", "逻辑非", ""),

        ("and", "逻辑与", ""),

        ("or", "逻辑或", "最低"),

        (":=", "海象运算符", "Python 3.8+"),

    ]

    

    for operators, description, note in precedence_examples:

        print(f"{operators:30} {description:20} {note}")

    

    print("\n=== 优先级示例 ===")

    

    # 示例1：算术运算优先级

    result1 = 2 + 3 * 4 ** 2

    # 计算顺序: 4**2=16 → 3*16=48 → 2+48=50

    print(f"2 + 3 * 4 ** 2 = {result1}")

    

    # 示例2：使用括号改变优先级

    result2 = (2 + 3) * 4 ** 2

    # 计算顺序: 2+3=5 → 4**2=16 → 5*16=80

    print(f"(2 + 3) * 4 ** 2 = {result2}")

    

    # 示例3：混合运算

    result3 = 10 + 20 * 30 / 5 - 2

    # 计算顺序: 20*30=600 → 600/5=120 → 10+120=130 → 130-2=128

    print(f"10 + 20 * 30 / 5 - 2 = {result3}")

    

    print("\n=== 逻辑运算优先级 ===")

    

    # 逻辑运算优先级

    x = 5

    y = 10

    z = 15

    

    # not 优先于 and 优先于 or

    result4 = not x > y and y < z or x == 5

    # 等价于: ((not (x > y)) and (y < z)) or (x == 5)

    print(f"not x > y and y < z or x == 5 = {result4}")

    

    # 使用括号使逻辑更清晰

    result5 = (not (x > y)) and (y < z) or (x == 5)

    print(f"(not (x > y)) and (y < z) or (x == 5) = {result5}")

    

    print("\n=== 综合表达式 ===")

    

    def calculate_bmi(weight, height):

        """计算BMI指数"""

        # BMI = 体重(kg) / 身高(m)^2

        return weight / (height ** 2)

    

    def analyze_bmi(bmi):

        """分析BMI结果"""

        if bmi < 18.5:

            return "体重过轻"

        elif 18.5 <= bmi < 24:

            return "正常范围"

        elif 24 <= bmi < 28:

            return "超重"

        else:

            return "肥胖"

    

    # 输入数据

    weight = 70  # 公斤

    height = 1.75  # 米

    

    # 计算并分析

    bmi = calculate_bmi(weight, height)

    status = analyze_bmi(bmi)

    

    print(f"体重: {weight}kg, 身高: {height}m")

    print(f"BMI指数: {bmi:.2f}")

    print(f"健康状况: {status}")

    

    print("\n=== 表达式优化技巧 ===")

    

    # 示例：简化条件表达式

    score = 85

    

    # 传统写法

    if score >= 60:

        result = "及格"

    else:

        result = "不及格"

    

    # 使用条件表达式（三元运算符）

    result = "及格" if score >= 60 else "不及格"

    print(f"分数 {score}: {result}")

    

    # 链式比较简化

    age = 25

    # 传统写法

    if age >= 18 and age <= 60:

        print(f"年龄 {age}: 适龄劳动力")

    

    # 链式比较

    if 18 <= age <= 60:

        print(f"年龄 {age}: 适龄劳动力（链式比较）")

    

    # 使用any和all函数简化逻辑表达式

    numbers = [1, 3, 5, 7, 9]

    

    # 检查是否都是奇数

    all_odd = all(n % 2 == 1 for n in numbers)

    print(f"列表 {numbers} 都是奇数: {all_odd}")

    

    # 检查是否有偶数

    has_even = any(n % 2 == 0 for n in numbers)

    print(f"列表 {numbers} 包含偶数: {has_even}")

# 运行运算符优先级演示

operator_precedence()

```

## 总结：运算符与变量的最佳实践

1. **变量命名规范**：

   - 使用有意义的名称，避免单字母变量（除循环变量外）

   - 遵循小写字母+下划线的命名约定

   - 常量使用全大写字母和下划线

2. **运算符使用要点**：

   - 理解运算符优先级，必要时使用括号

   - 利用Python的特色运算符（如链式比较、多重赋值）

   - 注意浮点数运算的精度问题

3. **类型处理技巧**：

   - 明确类型转换，避免隐式转换错误

   - 使用`is`比较对象身份，`==`比较值相等

   - 理解Python的动态类型特性

4. **代码可读性**：

   - 复杂的表达式拆分为多行

   - 使用括号明确运算顺序

   - 添加注释解释复杂逻辑

掌握变量和运算符是Python编程的基础，这些概念虽然简单，但正确的使用方式能显著提高代码质量和可维护性。通过不断实践，将这些基础知识内化为编程直觉，为进一步学习更复杂的Python概念打下坚实基础。