变量和关键字

# Python 变量是"标签"的直观证明
x = 42       # 创建整数对象 42，把标签 x 贴上去
y = x        # 把标签 y 也贴到同一个对象 42 上
print(id(x) == id(y))  # True —— x 和 y 指向同一个对象

x = 99       # 把标签 x 撕下来，贴到新对象 99 上
print(y)     # 42 —— y 仍然指向原来的对象，不受影响

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

print("=== 基本变量赋值 ===")
# 合法的变量名
name = "Alice"
age = 30
user_id = 12345
total_amount = 100.50
is_student = True

# 以下代码会引发错误，所以已注释
# 1st_name = "Bob"        # 以数字开头
# if = 10                # 关键字
# user@name = "Charlie"   # 包含特殊字符

print(f"name: {name}, age: {age}, user_id: {user_id}")
print(f"total_amount: {total_amount}, is_student: {is_student}")

# 1. 基本赋值
name = "Alice"
age = 30

# 2. 链式赋值：将同一个值赋给多个变量
x = y = z = 100
print(f"链式赋值: x={x}, y={y}, z={z}")

# 3. 多重赋值（解包赋值）：同时为多个变量赋不同的值
a, b, c = 1, "hello", True
print(f"多重赋值: a={a}, b='{b}', c={c}")

# 4. 增强赋值：在原值基础上进行运算
count = 5
count += 2  # 等价于 count = count + 2
print(f"增强赋值后: count={count}")

# 5. 星号解包：用于处理不定数量的元素
numbers = [1, 2, 3, 4, 5]
first, *middle, last = numbers
print(f"星号解包: first={first}, middle={middle}, last={last}")

# 查看对象的三个核心属性
x = 42
print(f"id: {id(x)}")         # 例如 4306174848
print(f"type: {type(x)}")     # <class 'int'>
print(f"value: {x}")          # 42

# 小整数池演示
a = 256
b = 256
print(a is b)  # True —— 都指向缓存中的同一个对象

c = 257
d = 257
print(c is d)  # False —— 超出小整数池范围，各自创建新对象

# 字符串驻留演示
s1 = "hello"
s2 = "hello"
print(s1 is s2)  # True —— 短字符串被驻留，指向同一对象

# 包含特殊字符的字符串可能不被驻留
s3 = "hello world!"
s4 = "hello world!"
print(s3 is s4)  # 可能 False —— 含空格和感叹号，不一定驻留

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
is vs == 深度比较 —— 结合内存模型理解
"""

# --- 情况1：小整数池内的比较 ---
a = 256
b = 256
print(f"小整数池内: a is b = {a is b}")  # True —— 同一对象
print(f"小整数池内: a == b = {a == b}")  # True —— 值相等

# --- 情况2：超出小整数池 ---
c = 257
d = 257
print(f"超出小整数池: c is d = {c is d}")  # False —— 不同对象（各创建一份）
print(f"超出小整数池: c == d = {c == d}")  # True —— 值相等

# --- 情况3：列表比较（可变类型） ---
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(f"列表: list1 is list2 = {list1 is list2}")  # False —— 不同对象
print(f"列表: list1 == list2 = {list1 == list2}")  # True —— 值相等

# --- 情况4：None 的判断（is 的正确用法） ---
x = None
print(f"x is None = {x is None}")    # True —— 推荐写法
print(f"x == None = {x == None}")    # True —— 不推荐，某些自定义 __eq__ 可能出问题

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
可变 vs 不可变类型的赋值行为差异
"""

# --- 不可变类型：赋值后互不影响 ---
a = 100
b = a        # b 和 a 指向同一个对象 100
a = 200      # a 指向新对象 200，b 不受影响
print(f"不可变类型: a={a}, b={b}")  # a=200, b=100

# --- 可变类型：通过引用共享修改 ---
list_a = [1, 2, 3]
list_b = list_a       # list_b 和 list_a 指向同一个列表对象
list_a.append(4)      # 原地修改列表
print(f"可变类型: list_a={list_a}, list_b={list_b}")
# list_a=[1, 2, 3, 4], list_b=[1, 2, 3, 4] —— 两个变量都看到了修改

# --- 如何避免共享修改？使用拷贝 ---
list_c = list_a.copy()   # 浅拷贝，创建新列表对象
list_a.append(5)
print(f"拷贝后: list_a={list_a}, list_c={list_c}")
# list_c 不受 list_a 后续修改的影响

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
三种变量交换方式对比
"""

a, b = 10, 20

# ---- 方式1：临时变量（经典方法，所有语言通用） ----
temp = a    # 把 a 的值暂存到 temp
a = b       # 把 b 的值赋给 a
b = temp    # 把 temp 中保存的原 a 值赋给 b
print(f"临时变量交换后: a={a}, b={b}")  # a=20, b=10

# 恢复
a, b = 10, 20

# ---- 方式2：元组解包（Pythonic，推荐） ----
a, b = b, a   # 右边先打包成元组 (20, 10)，再解包赋值给 a, b
print(f"元组解包交换后: a={a}, b={b}")  # a=20, b=10

# 恢复
a, b = 10, 20

# ---- 方式3：异或交换（仅限整数，展示原理） ----
a = a ^ b    # 异或运算：a 变成 a⊕b
b = a ^ b    # b 变成 (a⊕b)⊕b = a
a = a ^ b    # a 变成 (a⊕b)⊕a = b
print(f"异或交换后: a={a}, b={b}")      # a=20, b=10

name: str = "Alice"
age: int = 30
height: float = 5.5
is_student: bool = False

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# 动态类型演示
dynamic_var = 10         # 整数
print(f"dynamic_var is {type(dynamic_var)}: {dynamic_var}")
# dynamic_var is <class 'int'>: 10

dynamic_var = "Hello"    # 字符串
print(f"dynamic_var is {type(dynamic_var)}: {dynamic_var}")
# dynamic_var is <class 'str'>: Hello

dynamic_var = 3.14       # 浮点数
print(f"dynamic_var is {type(dynamic_var)}: {dynamic_var}")
# dynamic_var is <class 'float'>: 3.14

# 类型注解示例
name: str = "Alice"
age: int = 30
height: float = 5.5
is_student: bool = False

print(f"\n带类型注解的变量:")
print(f"name: {name} (类型: {type(name).__name__})") # name: Alice (类型: str)
print(f"age: {age} (类型: {type(age).__name__})") # age: 30 (类型: int)
print(f"height: {height} (类型: {type(height).__name__})") # height: 5.5 (类型: float)
print(f"is_student: {is_student} (类型: {type(is_student).__name__})") # is_student: False (类型: bool)

count = 0

def increment():
    global count
    count += 1

def outer():
    x = "local"
    def inner():
        nonlocal x
        x = "nonlocal"
    inner()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

x = [1, 2, 3]  # 创建一个列表对象，并由变量 x 引用
x = None       # 变量 x 不再引用该列表，Python 将在适当的时候回收内存

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
del 语句行为详解
"""

import sys

# --- del 删除变量引用 ---
my_list = [10, 20, 30]
print(f"my_list 存在: {'my_list' in locals()}")  # True
print(f"引用计数: {sys.getrefcount(my_list) - 1}")  # 1（减去 getrefcount 自身的临时引用）

another_ref = my_list  # 再添加一个引用
print(f"添加引用后: {sys.getrefcount(my_list) - 1}")  # 2

del my_list  # 删除变量 my_list，引用计数减 1
print(f"del 后 my_list 存在: {'my_list' in locals()}")  # False

# 对象本身仍然存在，因为 another_ref 还在引用它
print(f"another_ref = {another_ref}")  # [10, 20, 30]

# --- del 删除列表元素（注意：这是删除元素，不是删除变量） ---
nums = [1, 2, 3, 4, 5]
del nums[2]   # 删除索引 2 的元素（值为 3）
print(f"删除元素后: {nums}")  # [1, 2, 4, 5]

# --- del 删除字典键 ---
info = {"name": "Alice", "age": 30, "temp": "delete me"}
del info["temp"]
print(f"删除键后: {info}")  # {'name': 'Alice', 'age': 30}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

name = input("请输入你的名字: ")
age = int(input("请输入你的年龄: "))  # 将输入的字符串转换为整数
print(f"你好, {name}! 你今年 {age} 岁。")

import keyword

name = "count"
print(type(name))
print(keyword.iskeyword(name))

PYTHONHASHSEED=0 PYTHONWARNINGS=default python demo.py

a = 5
b = 10
a, b = b, a
print(a)  # 输出: 10
print(b)  # 输出: 5

x = y = z = 0
a, b = 1, 2

# 列表解包
numbers = [1, 2, 3]
first, second, third = numbers

# 字典解包（Python 3.5+）
person = {'name': 'Alice', 'age': 30}
name, age = person.values()

x, _, z = (10, 20, 30)
first, *_, last = range(10)

PI = 3.14159
GRAVITY = 9.81

class = "Math"

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Python关键字演示

import keyword

print("Python的所有关键字:")
print(keyword.kwlist)
print(f"总共有 {len(keyword.kwlist)} 个关键字") # 总共有 35 个关键字

# 检查一个词是否是关键字
test_words = ["if", "else", "while", "for", "def", "class", "variable", "name"]
for word in test_words:
    is_keyword = keyword.iskeyword(word)
    print(f"'{word}': {'是关键字' if is_keyword else '不是关键字'}")

# 输出
# 'if': 是关键字
# 'else': 是关键字
# 'while': 是关键字
# 'for': 是关键字
# 'def': 是关键字
# 'class': 是关键字
# 'variable': 不是关键字
# 'name': 不是关键字

from pprint import pprint

data = {"users": [{"name": "Alice"}, {"name": "Bob"}]}
pprint(data, width=40)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
可变默认参数陷阱
"""

# ---- 错误写法 ----
def append_item(item, lst=[]):  # 默认列表在函数定义时创建，所有调用共享同一个列表！
    lst.append(item)
    return lst

print(append_item(1))   # [1]
print(append_item(2))   # [1, 2] —— 意料之外！前一次调用的结果被保留了
print(append_item(3))   # [1, 2, 3] —— 越来越长！

# ---- 正确写法：用 None 作为默认值 ----
def append_item_fixed(item, lst=None):
    if lst is None:
        lst = []         # 每次调用都创建新的列表
    lst.append(item)
    return lst

print(append_item_fixed(1))  # [1]
print(append_item_fixed(2))  # [2] —— 符合预期

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
for 循环变量泄漏
"""

# 循环结束后，变量 i 仍然存在
for i in range(5):
    pass

print(f"循环结束后 i = {i}")  # i = 4 —— 循环变量的最后一个值

# 如果之前有同名变量，会被覆盖
i = "我是原来的值"
for i in range(3):
    pass
print(f"i 被覆盖了: {i}")  # i = 2，原来的字符串值丢了

# 常见陷阱：在列表推导式中意外引用循环变量
funcs = [lambda: i for i in range(3)]
print([f() for f in funcs])  # [2, 2, 2] —— 都是 2！不是 [0, 1, 2]

# 修复：使用默认参数捕获当前值
funcs = [lambda i=i: i for i in range(3)]
print([f() for f in funcs])  # [0, 1, 2] —— 符合预期

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
is vs == 混淆的常见错误
"""

# 错误：用 is 比较值的相等性
a = [1, 2, 3]
b = [1, 2, 3]
if a is b:           # False —— 两个不同的列表对象
    print("相同对象")
else:
    print("不同对象，但值相等")  # 这行会被执行

# 错误：用 == 判断 None
x = 0
if x == None:        # 不好！0 == None 是 False，但语义不清晰
    pass
if x is None:        # 正确！PEP 8 推荐
    pass

# 误以为 is 比较值
# 在交互式环境中，小整数和短字符串的 is 比较可能"碰巧"正确
# 但这依赖实现细节，不应依赖
a = 256
b = 256
print(f"256: a is b = {a is b}")  # True（小整数池）

a = 257
b = 257
print(f"257: a is b = {a is b}")  # 可能 False（超出小整数池）

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
UnboundLocalError 陷阱
"""

x = 10  # 全局变量

def trouble():
    # Python 编译器看到 x += 1 中的赋值，将 x 标记为局部变量
    # 但执行到 print 时，局部变量 x 还未被赋值
    # print(x)       # UnboundLocalError: cannot access local variable 'x' ...
    x += 1           # 这行赋值导致 x 被视为局部变量
    return x

# 修复方法：使用 global 声明
def fixed():
    global x
    x += 1
    return x

print(f"修复后: {fixed()}")  # 11

# 类似问题：+= 等增强赋值也会触发
items = []

def add_item():
    # items += ["new"]  # UnboundLocalError! += 对列表隐含赋值
    items.append("new")  # 正确：append 不赋值，只做方法调用

add_item()
print(f"items: {items}")  # ['new']