入门初学者短期内快速掌握Python的经典全面教程（专家学习笔记）

x = 10  # 整数变量
name = "Alice"  # 字符串变量
pi = 3.14159  # 浮点数变量
is_python_fun = True  # 布尔变量

valid_name = "OK"  # 正确
_valid_123 = 42  # 正确
2nd_value = "wrong"  # ❌ 错误：不能以数字开头
user-name = "error"  # ❌ 错误：不能包含 `-`

x = 42
print(type(x))  # 输出：<class 'int'>

age = "25"  
age = int(age)  # 将字符串转换为整数
pi = 3.14
pi_str = str(pi)  # 将浮点数转换为字符串

name = input("请输入你的名字: ")
print("你好,", name)

age = int(input("请输入你的年龄: "))  # 输入默认是字符串，需要转换成整数
print("你明年就", age + 1, "岁了！")

name = "Alice"
age = 25
print("姓名:", name, "年龄:", age)  # 多个参数用逗号分隔

print(f"姓名: {name}, 年龄: {age}") # 推荐的写法

True  # 代表 "真"
False  # 代表 "假"

True == 1  # 结果为 True
False == 0  # 结果为 True

is_python_fun = True
is_raining = False

print(is_python_fun)  # 输出：True
print(type(is_python_fun))  # 输出：<class 'bool'>

a = 10
b = 5

print(a > b)   # True
print(a == b)  # False
print(a != b)  # True

x = 5
y = 10
print(x > 0 and y > 5)  # True，因为两个条件都成立
print(x > 0 and y < 5)  # False，因第二个条件不成立

x = 5
y = 10
print(x > 0 or y < 5)  # True，只要有一个条件为 True 即可
print(x < 0 or y < 5)  # False，两个条件都为 False

is_python_fun = True
print(not is_python_fun)  # False，因为取反了

print(True or False and False)  
# 等价于 True or (False and False) → True or False → True

print(not True or False)  
# 等价于 (not True) or False → False or False → False

print(bool(0))       # False
print(bool(""))      # False
print(bool([]))      # False
print(bool(42))      # True
print(bool("hello")) # True

name = "Alice"

if name:  # 相当于 if bool(name) == True
    print("名字有效")  
else:
    print("名字为空")

名字有效

# 提示：使用 input() 和 if 语句

if 条件:
    语句块

age = 20

if age >= 18:
    print("你已经成年了")

你已经成年了

if 条件:
    语句块1
else:
    语句块2

temperature = 15

if temperature > 20:
    print("北京天气今天很暖和")
else:
    print("北京天气今天有点冷")

北京天气今天有点冷

if 条件1:
    语句块1
elif 条件2:
    语句块2
elif 条件3:
    语句块3
else:
    默认语句块

score = 85

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

良好

age = 25
is_student = True

if age < 30:
    if is_student:
        print("你是年轻的学生")
    else:
        print("你是年轻的上班族")

你是年轻的学生

变量 = 值1 if 条件 else 值2

age = 16
status = "成年" if age >= 18 else "未成年"
print(status)

未成年

while 条件表达式:
    循环体

i = 1
while i <= 5:
    print(i)
    i += 1

i = 1
while True:
    print(i)
    if i == 3:
        break
    i += 1

i = 0
while i < 5:
    i += 1
    if i == 3:
        continue
    print(i)

for 变量 in 可迭代对象:
    循环体

for ch in "hello":
    print(ch)

fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
    print(fruit)

info = {"name": "Tom", "age": 20}
for key in info:
    print(key, "=>", info[key])

for key, value in info.items():
    print(f"{key}: {value}")

s = {"apple", "banana", "cherry"}
for item in s:
    print(item)

for i in range(1, 6):
    print(i)

colors = ['red', 'green', 'blue']
for index, color in enumerate(colors):
    print(f"{index}: {color}")

for i in range(1, 10):
    if i == 5:
        break
    print(i)

for i in range(1, 6):
    if i % 2 == 0:
        continue
    print(i)  # 输出 1 3 5（跳过偶数）

def function_name(parameters):
    # 函数体
    return result

def add(a, b):
    return a + b

# 调用函数
result = add(3, 5)
print(result)  # 输出: 8

def greet(name):
    return f"Hello, {name}!"

message = greet("Alice")
print(message)  # 输出: Hello, Alice!

# 使用 print()
def greet_print(name):
    print(f"Hello, {name}!")

greet_print("Alice")  # 输出: Hello, Alice!

# 使用 return
def greet_return(name):
    return f"Hello, {name}!"

message = greet_return("Alice")
print(message)  # 输出: Hello, Alice!

def add(a, b):
    return a + b

result = add(3, 5)  # 位置参数：3 被赋值给 a，5 被赋值给 b
print(result)  # 输出: 8

def greet(name, age):
    return f"Hello, {name}! You are {age} years old."

message = greet(age=25, name="Alice")  # 参数顺序不重要
print(message)  # 输出: Hello, Alice! You are 25 years old.

def greet(name, age=18):  # age 有默认值
    return f"Hello, {name}! You are {age} years old."

message1 = greet("Alice")  # 调用时没有提供 age，使用默认值
message2 = greet("Bob", 30)  # 调用时提供了 age，覆盖默认值

print(message1)  # 输出: Hello, Alice! You are 18 years old.
print(message2)  # 输出: Hello, Bob! You are 30 years old.

def example(*args, **kwargs):
    print("args:", args)
    print("kwargs:", kwargs)

# 调用函数时传入不同数量的参数
example(1, 2, 3, name="Alice", age=25)

# 输出:
# args: (1, 2, 3)
# kwargs: {'name': 'Alice', 'age': 25}

def function(a, b=2, *args, c, **kwargs):
    print(a, b, args, c, kwargs)

# 调用时，按照顺序传递参数
function(1, c=3, d=4, e=5)
# 输出: 1 2 () 3 {'d': 4, 'e': 5}

def function_name(...):
    ...
    return result

def square(x):
    return x * x

result = square(5)
print(result)  # 输出: 25

def get_name_and_age():
    name = "Alice"
    age = 30
    return name, age

n, a = get_name_and_age()
print(n)  # Alice
print(a)  # 30

def say_hello():
    print("Hello!")

result = say_hello()
print(result)  # 输出: None

def divide(a, b):
    if b == 0:
        return "除数不能为 0"
    return a / b

print(divide(10, 0))  # 输出: 除数不能为 0
print(divide(10, 2))  # 输出: 5.0

def add(a, b):
    return a + b

print(add(2, 3) * 10)  # 输出: 50

def add(a: int, b: int) -> int:
    return a + b

def add(a: int, b: int) -> int:
    return "not a number"

def foo() -> dict[str, int]:
    return {"a": 1}

result = foo()
result["a"].

def get_age() -> int:
    return "18"

from typing import Union

def parse(s: str) -> Union[int, None]:
    if s.isdigit():
        return int(s)
    return None

def parse(s: str) -> int | None:
    ...

def get_names() -> list[str]:
    return ["Alice", "Bob"]

def get_scores() -> dict[str, int]:
    return {"math": 90}

class User:
    ...

def get_user() -> User:
    return User()

# 单引号
s1 = 'hello'

# 双引号
s2 = "world"

# 三引号（支持多行）
s3 = '''This is
a multi-line
string.'''

s = "hello"
# s[0] = 'H'  # ❌ 错误！字符串不能直接修改
s = "Hello"   # ✅ 只能重新赋值

s = "Python"

# 索引（从 0 开始）
print(s[0])   # P
print(s[-1])  # n（最后一个字符）

# 切片 [start:end:step]
print(s[0:2])     # Py（不包括 end）
print(s[::2])     # Pto（每隔1个）
print(s[::-1])    # nohytP（反转字符串）

# 拼接字符串
a = "Hello"
b = "World"
c = a + " " + b
print(c)  # Hello World

# 重复字符串
print("ha" * 3)   # hahaha

s = "python"
print("p" in s)      # True
print("z" not in s)  # True

num = 123
text = str(num)  # 数字转字符串
print("数字是：" + text)

# 也可以使用 f-string（推荐）
print(f"数字是：{num}")

s = "hello World"
print(s.lower())       # hello world
print(s.upper())       # HELLO WORLD
print(s.capitalize())  # Hello world
print(s.title())       # Hello World
print(s.swapcase())    # HELLO wORLD

s = "hello python"
print(s.find("py"))       # 6
print(s.startswith("he")) # True
print(s.endswith("on"))   # True
print("py" in s)          # True

s = "  hello world  "
print(s.strip())     # "hello world"

s2 = "python,java,c"
print(s2.replace(",", " | "))  # python | java | c

print("hi".center(10, "-"))  # ----hi----
print("hi".ljust(10, "."))   # hi........
print("hi".rjust(10, "*"))   # ********hi
print("42".zfill(5))         # 00042

s = "apple,banana,grape"
print(s.split(","))         # ['apple', 'banana', 'grape']

lines = "line1\nline2\nline3"
print(lines.splitlines())   # ['line1', 'line2', 'line3']

words = ['one', 'two', 'three']
print("-".join(words))      # one-two-three

print("abc".isalpha())     # True
print("123".isdigit())     # True
print("abc123".isalnum())  # True
print("   ".isspace())     # True

name = "Alice"
age = 30

# 推荐方式：f-string（Python 3.6+）
print(f"{name} is {age} years old.")  # Alice is 30 years old

# 老式：format()
print("{} is {} years old.".format(name, age))

# 占位对齐控制
print(f"|{name:^10}|{age:>3}|")  # 居中+右对齐：|  Alice   | 30|

print("hello\nworld")     # 换行
print(r"c:\new\folder")   # c:\new\folder

s = "python"
print(s[0])  # p
print(s[1])  # y
print(s[5])  # n

s = "python"
print(s[-1])  # n
print(s[-2])  # o
print(s[-6])  # p

s[start : stop : step]

s = "Hello, Python!"

print(s[0:5])   # Hello
print(s[7:13])  # Python
print(s[:5])    # Hello（从头开始）
print(s[7:])    # Python!（直到结尾）

s = "abcdefg"
print(s[-4:-1])  # def
print(s[-7:-4])  # abc

s = "0123456789"
print(s[::2])     # 02468（每两个字符取一个）
print(s[1::3])    # 147（从索引 1 开始，每隔 3 个取）

s = "abcdef"
print(s[::-1])   # fedcba（字符串反转）
print(s[-1:-7:-1]) # fedcba（等同上行）

s = "hello"
for c in s:
    print(c)

h
e
l
l
o

s = "hello"
for index, char in enumerate(s):
    print(f"{index} -> {char}")

0 -> h
1 -> e
2 -> l
3 -> l
4 -> o

name = "Alice"
age = 25
print("My name is %s and I am %d years old." % (name, age))

name = "Alice"
age = 25
print("My name is {} and I am {} years old.".format(name, age))

print("Hello, {0}. You are {1}.".format("Bob", 30))
print("Hello, {name}. You are {age}.".format(name="Bob", age=30))

pi = 3.1415926
print("Pi is {:.2f}".format(pi))  # Pi is 3.14

name = "Alice"
age = 25
print(f"My name is {name} and I am {age} years old.")

a = 5
b = 3
print(f"{a} + {b} = {a + b}")

pi = 3.1415926
print(f"Pi rounded to 2 digits: {pi:.2f}")

user = {"name": "Bob", "score": 88}
print(f"{user['name']} scored {user['score']}")

name = "张彦峰"

name1 = "卢政伯" name2 = "吕鸿昌" name3 = "秦学磊"

names = ["张彦峰","卢政伯","吕鸿昌","秦学磊"]

user = {
    "name": "张彦峰",
    "age": 18,
    "email": "zyf@alibaba.com"
}

users = [
    {"name": "张彦峰", "age": 18},
    {"name": "张琴", "age": 18}
]

# 示例：包含整数的列表
numbers = [1, 2, 3, 4, 5]

# 示例：包含不同数据类型的列表
info = ["Alice", 18, True, 3.14, ["nested", "list"]]

# 空列表
empty_list = []

# 含有多个整数的列表
numbers = [1, 2, 3, 4, 5]

# 含有不同类型的元素的列表
mixed = [1, "Alice", True, 3.14]

numbers = [10, 20, 30, 40]

# 正向索引
print(numbers[0])  # 10
print(numbers[3])  # 40

# 负向索引
print(numbers[-1])  # 40
print(numbers[-2])  # 30

# 切片示例
print(numbers[1:3])  # [20, 30]
print(numbers[:2])   # [10, 20]
print(numbers[2:])   # [30, 40]

# 示例：添加元素
nums = [1, 2, 3]
nums.append(4)  # 在末尾添加元素
nums.insert(1, 1.5)  # 在索引 1 处插入元素
nums.extend([3, 4])   # [1, 2, 3, 4]

print(nums)  # 输出: [1, 1.5, 2, 3, 4, 3, 4]

# 示例：删除元素
nums.remove(1.5)  # 删除元素 1.5
popped_element = nums.pop()  # 删除并返回最后一个元素
del nums[0]  # 删除索引 0 处的元素

print(nums)  # 输出: [2, 3, 4, 3]

nums[0] = 10  # 将索引 0 处的元素修改为 10
print(nums)    # 输出: [10, 3]

# 直接遍历元素
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)  # 输出每个水果

# 使用索引遍历
for i in range(len(fruits)):
    print(i, fruits[i])  # 输出索引和值

# 使用 enumerate 获取索引和值
for idx, fruit in enumerate(fruits):
    print(idx, fruit)  # 输出索引和值

nums = [4, 2, 7, 1]

print(len(nums))     # 输出: 4
print(2 in nums)     # 输出: True
print(nums.count(2)) # 输出: 1
print(nums.index(7)) # 输出: 2

nums.sort()          # 原地排序
sorted_nums = sorted(nums)  # 返回新列表
nums.reverse()       # 原地反转

# 基本语法：生成平方数列表
squares = [x**2 for x in range(5)]
print(squares)  # 输出: [0, 1, 4, 9, 16]

# 带条件的推导式：生成偶数的平方数列表
even_squares = [x**2 for x in range(5) if x % 2 == 0]
print(even_squares)  # 输出: [0, 4, 16]

a = [1, 2, 3]
b = a

a[0] = 100
print(b)  # [100, 2, 3]

b = a.copy()
b = a[:]
b = list(a)

a = [[1, 2], [3, 4]]
b = a.copy()

a ──▶ list ──▶ [ L1 , L2 ]
b ──▶ list ──▶ [ L1 , L2 ]

a = [[1, 2], [3, 4]]
b = a.copy()

b[0][0] = 100
print(a)  # [[100, 2], [3, 4]]

a = [1, 2, 3, "abc"]
b = a.copy()

b[0] = 100  # 不影响 a

print(a) # [1, 2, 3, 'abc']
print(b) # [100, 2, 3, 'abc']

import copy

b = copy.deepcopy(a)

a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)

a ──▶ list ──▶ [ L1 , L2 ]
b ──▶ list ──▶ [ L1' , L2' ]

a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)

b[0][0] = 100
print(a)  # [[1, 2], [3, 4]]

a = [[0]] * 3

sub = [0]
a = [sub, sub, sub]

a[0][0] = 1
print(a)  # [[1], [1], [1]]

a = [[0] for _ in range(3)]

a = [[1, 2]] * 3
a[0][0] = 100
print(a)  # 输出: [[100, 2], [100, 2], [100, 2]]

nums = [1, 2, 3, 4]
for n in nums:
    if n % 2 == 0:
        nums.remove(n)  # 删除偶数元素
print(nums)  # 输出: [1, 3]

# 解决方法：遍历副本
for n in nums[:]:
    if n % 2 == 0:
        nums.remove(n)

# 使用列表表示用户信息（语义不清晰）
user_list = ["Alice", 18, "alice@example.com"]

# 使用字典表示用户信息（结构清晰）
user_dict = {
    "name": "Alice",
    "age": 18,
    "email": "alice@example.com"
}

# 使用花括号（最常见）
user = {"name": "Alice", "age": 18}

# 使用 dict 构造函数
user2 = dict(name="Bob", age=20)

# 从键值对列表创建
pairs = [("name", "Charlie"), ("age", 22)]
user3 = dict(pairs)

print(user["name"])        # Alice
print(user.get("age"))     # 18

# 合法
d = {(1, 2): "ok"}

# 非法（会抛出 TypeError）
d = {[1, 2]: "error"}

user["email"] = "alice@example.com"  # 新增
user["age"] = 19                       # 修改

# 删除指定 key
del user["email"]

# 删除并返回 value
age = user.pop("age")

# 指定默认值，避免 KeyError
age = user.pop("age", None)

user["name"]                 # 不存在会抛 KeyError
user.get("email")             # 不存在返回 None
user.get("email", "N/A")     # 返回默认值

"name" in user      # True / False
"email" not in user # True / False

for key in user:
    print(key, user[key])

for value in user.values():
    print(value)

for key, value in user.items():
    print(key, value)

user.keys()        # 所有 key（视图对象）
user.values()      # 所有 value
user.items()       # (key, value) 对
user.clear()       # 清空字典
user.copy()        # 浅拷贝

user.setdefault("age", 18)

if "age" not in user:
    user["age"] = 18

user.update({"email": "alice@example.com", "age": 20})

words = ["apple", "banana", "apple", "cherry"]
counter = {}

for word in words:
    counter[word] = counter.get(word, 0) + 1

print(counter)

students = [
    ("Alice", "A"),
    ("Bob", "B"),
    ("Charlie", "A")
]

groups = {}
for name, grade in students:
    groups.setdefault(grade, []).append(name)

print(groups) #{'A': ['Alice', 'Charlie'], 'B': ['Bob']}

d1 = {"a": [1, 2]}
d2 = d1.copy()

d2["a"].append(3)
print(d1)  # {'a': [1, 2, 3]}

import copy

d1 = {"a": [1, 2]}
d2 = copy.deepcopy(d1)

d2["a"].append(3)
print(d1)  # {'a': [1, 2]}

users = [
    {"name": "Alice", "age": 18},
    {"name": "Bob", "age": 20}
]

for user in users:
    print(user["name"], user["age"])

grades = {
    "Alice": [90, 95, 88],
    "Bob": [75, 80, 82]
}

for name, scores in grades.items():
    avg = sum(scores) / len(scores)
    print(name, avg)

users = {
    "Alice": {"age": 18, "email": "alice@example.com"},
    "Bob": {"age": 20, "email": "bob@example.com"}
}

print(users["Alice"]["email"])

# 使用大括号创建集合
fruits = {"apple", "banana", "cherry"}
print(fruits)
# 输出顺序不固定，例如：{'banana', 'apple', 'cherry'}

# 使用 set() 构造函数
nums = set([1, 2, 3, 2, 1])
print(nums)  # {1, 2, 3}，自动去重

s = {(1, 2), "abc", 10}   # 合法
# s = {[1, 2], 3}         # TypeError: unhashable type: 'list'

# 空集合（注意不能用 {}）
empty_set = set()

# 从列表 / 元组 / 字符串创建
set([1, 2, 2, 3])
set(("a", "b", "a"))
set("hello")   # {'h', 'e', 'l', 'o'}

nums = {1, 2, 3}
nums.add(4)
print(nums)  # {1, 2, 3, 4}

nums.remove(2)    # 元素不存在会抛 KeyError
nums.discard(5)   # 元素不存在不会报错
popped = nums.pop()  # 随机删除并返回一个元素
nums.clear()      # 清空集合

nums = {1, 2, 3}
print(2 in nums)       # True
print(5 not in nums)  # True

a = {1, 2, 3}
b = {3, 4, 5}

print(a | b)
print(a.union(b))
# {1, 2, 3, 4, 5}

print(a & b)
print(a.intersection(b))
# {3}

print(a - b)
print(a.difference(b))
# {1, 2}

print(a ^ b)
print(a.symmetric_difference(b))
# {1, 2, 4, 5}

a = {1, 2}
b = {1, 2, 3}

print(a.issubset(b))      # True  子集
print(b.issuperset(a))   # True  超集
print(a.isdisjoint({4})) # True  是否无交集

fs = frozenset([1, 2, 3])

nums = [1, 2, 2, 3, 4, 4]
unique_nums = list(set(nums))

user_roles = {"admin", "editor"}
required_roles = {"editor", "viewer"}

if user_roles & required_roles:
    print("有权限")

team_a = {"Alice", "Bob", "Charlie"}
team_b = {"Bob", "David"}

common = team_a & team_b

old_users = {1, 2, 3}
new_users = {2, 3, 4}

lost = old_users - new_users   # 流失用户
added = new_users - old_users  # 新增用户

point = (10, 20)
info = ("Alice", 18, True, ["Python", "Go"])

print(point[0])   # 10
print(info[1])    # 18
print(info[-1])   # ['Python', 'Go']

t = (1, 2, 3)

t = 1, 2, 3

single = (5,)     # 正确
single2 = (5)     # 错误，这是整数

nums = [1, 2, 3]
chars = "abc"

print(tuple(nums))   # (1, 2, 3)
print(tuple(chars))  # ('a', 'b', 'c')

t = (10, 20, 30, 40)

print(t[0])    # 10
print(t[-1])   # 40

print(t[1:3])  # (20, 30)
print(t[:2])   # (10, 20)

for item in t:
    print(item)

t = (1, 2, 3)

# t[0] = 10        # TypeError
# t.append(4)     # AttributeError
# del t[1]         # TypeError

t = (1, [2, 3])
t[1].append(4)

print(t)  # (1, [2, 3, 4])

point = (10, 20)
x, y = point

print(x, y)  # 10 20

def get_min_max(nums):
    return min(nums), max(nums)

min_val, max_val = get_min_max([3, 7, 1, 9])
print(min_val, max_val) # 1 9

a, *b = (1, 2, 3, 4)
print(a)  # 1
print(b)  # [2, 3, 4]

location = {}
location[(10, 20)] = "Home"

print(location)

def user_info():
    return "Alice", 18, True

name, age, active = user_info()

HOST = "localhost"
PORT = 8080
CONFIG = (HOST, PORT)

t = (1, 2, 2, 3)

print(t.count(2))   # 2
print(t.index(3))   # 3

len(t)
max(t)
min(t)
sum(t)

user = {
    "id": 1001,
    "name": "Alice",
    "profile": {
        "age": 28,
        "email": "alice@example.com",
        "address": {
            "city": "Beijing",
            "zipcode": "100000"
        }
    }
}

city = user["profile"]["address"]["city"]

order = {
    "order_id": "ORD-001",
    "user_id": 1001,
    "items": [
        {"sku": "SKU-1", "price": 100, "quantity": 2},
        {"sku": "SKU-2", "price": 50, "quantity": 1}
    ]
}

total_amount = 0
for item in order["items"]:
    total_amount += item["price"] * item["quantity"]

users = [
    {"id": 1, "name": "Alice", "active": True},
    {"id": 2, "name": "Bob", "active": False},
    {"id": 3, "name": "Charlie", "active": True}
]

active_users = []
for user in users:
    if user["active"]:
        active_users.append(user)

response = {
    "code": 0,
    "data": {
        "user": {
            "id": 1001,
            "orders": [
                {
                    "order_id": "ORD-001",
                    "items": [
                        {"sku": "SKU-1", "price": 100}
                    ]
                }
            ]
        }
    }
}

sku = response["data"]["user"]["orders"][0]["items"][0]["sku"]

user = response.get("data", {}).get("user", {})
orders = user.get("orders", [])

if orders:
    first_order = orders[0]

data["a"]["b"][0]["c"]["d"]

import json

json_str = '''
{
    "id": 1001,
    "name": "Alice",
    "active": true,
    "roles": ["admin", "editor"]
}
'''

data = json.loads(json_str)

name = data["name"]
roles = data["roles"]

import json

with open("config.json", "r", encoding="utf-8") as f:
    config = json.load(f)

response = {
    "code": 0,
    "message": "success",
    "data": {
        "user": {
            "id": 1001,
            "name": "Alice",
            "orders": [
                {
                    "order_id": "ORD-001",
                    "items": [
                        {"sku": "SKU-1", "price": 100, "quantity": 2}
                    ]
                }
            ]
        }
    }
}

orders = response["data"]["user"]["orders"]
first_item_price = orders[0]["items"][0]["price"]

data = response.get("data", {})
user = data.get("user", {})
orders = user.get("orders", [])

if orders:
    order_id = orders[0].get("order_id")

order_data = {
    "order_id": "ORD-001",
    "price": "100",
    "quantity": 2
}

total_amount = int(order_data["price"]) * order_data["quantity"]

class Order:
    def __init__(self, order_id, price, quantity):
        self.order_id = order_id
        self.price = int(price)
        self.quantity = int(quantity)

order = Order("ORD-001", "100", 2)

total = order.price * order.quantity

class Order:
    def __init__(self, order_id, price, quantity):
        self.order_id = order_id
        self.price = int(price)
        self.quantity = int(quantity)

    def total_amount(self):
        return self.price * self.quantity

total = order.total_amount()

raw_data = {
    "order_id": "ORD-001",
    "price": None,
    "quantity": "2"
}

class Order:
    def __init__(self, data: dict):
        self.order_id = data.get("order_id")
        self.price = self._to_int(data.get("price"), default=0)
        self.quantity = self._to_int(data.get("quantity"), default=1)

    def _to_int(self, value, default=0):
        try:
            return int(value)
        except (TypeError, ValueError):
            return default

order = Order(raw_data)
total = order.total_amount()

# ❌ 不推荐
total = int(raw_data["price"]) * int(raw_data["quantity"])

raw_order = {
    "order_id": "ORD-001",
    "items": [
        {"sku": "SKU-1", "price": "100"},
        {"sku": "SKU-2", "price": "50"}
    ]
}

total = 0
for item in raw_order["items"]:
    total += int(item["price"])

class OrderItem:
    def __init__(self, data):
        self.sku = data.get("sku")
        self.price = int(data.get("price", 0))

class Order:
    def __init__(self, data):
        self.order_id = data.get("order_id")
        self.items = [OrderItem(item) for item in data.get("items", [])]

    def total_amount(self):
        return sum(item.price for item in self.items)

raw_order = {
    "order_id": "ORD-9001",
    "user": {
        "id": "U-1001",
        "profile": {
            "name": "Alice",
            "level": "VIP"
        }
    },
    "items": [
        {
            "sku": "SKU-1",
            "pricing": {
                "unit_price": "100",
                "currency": "CNY"
            },
            "quantity": 2,
            "discounts": [
                {"type": "PROMOTION", "amount": "10"},
                {"type": "VIP", "amount": "5"}
            ]
        }
    ],
    "payment": {
        "method": "CREDIT_CARD",
        "transactions": [
            {"tx_id": "TX-1", "amount": "185"},
            {"tx_id": "TX-2", "amount": "10"}
        ]
    }
}

class Discount:
    def __init__(self, data):
        self.type = data.get("type")
        self.amount = int(data.get("amount", 0))

class Pricing:
    def __init__(self, data):
        self.unit_price = int(data.get("unit_price", 0))
        self.currency = data.get("currency")

    def total(self, quantity):
        return self.unit_price * quantity

class OrderItem:
    def __init__(self, data):
        self.sku = data.get("sku")
        self.quantity = int(data.get("quantity", 1))

        self.pricing = Pricing(data.get("pricing", {}))
        self.discounts = [
            Discount(d) for d in data.get("discounts", [])
        ]

    def discount_amount(self):
        return sum(d.amount for d in self.discounts)

    def subtotal(self):
        return self.pricing.total(self.quantity) - self.discount_amount()

class UserProfile:
    def __init__(self, data):
        self.name = data.get("name")
        self.level = data.get("level")

    def is_vip(self):
        return self.level == "VIP"


class User:
    def __init__(self, data):
        self.user_id = data.get("id")
        self.profile = UserProfile(data.get("profile", {}))

class PaymentTransaction:
    def __init__(self, data):
        self.tx_id = data.get("tx_id")
        self.amount = int(data.get("amount", 0))

class Payment:
    def __init__(self, data):
        self.method = data.get("method")
        self.transactions = [
            PaymentTransaction(tx)
            for tx in data.get("transactions", [])
        ]

    def paid_amount(self):
        return sum(tx.amount for tx in self.transactions)

class Order:
    def __init__(self, data):
        self.order_id = data.get("order_id")

        self.user = User(data.get("user", {}))
        self.items = [OrderItem(i) for i in data.get("items", [])]
        self.payment = Payment(data.get("payment", {}))

    def order_amount(self):
        return sum(item.subtotal() for item in self.items)

    def is_fully_paid(self):
        return self.payment.paid_amount() >= self.order_amount()

json.dumps(order.__dict__)

{
  "order_id": "ORD-9001",
  "user_id": "U-1001",
  "items": [
    {
      "sku": "SKU-1",
      "unit_price": "100",
      "quantity": 2
    }
  ]
}

class OrderCreateDTO:
    def __init__(self, data):
        self.order_id = data.get("order_id")
        self.user_id = data.get("user_id")
        self.items = data.get("items", [])

class OrderFactory:
    @staticmethod
    def from_create_dto(dto: OrderCreateDTO):
        raw = {
            "order_id": dto.order_id,
            "user": {"id": dto.user_id},
            "items": [
                {
                    "sku": item["sku"],
                    "pricing": {"unit_price": item["unit_price"]},
                    "quantity": item["quantity"],
                    "discounts": []
                }
                for item in dto.items
            ]
        }
        return Order(raw)

class OrderResponseDTO:
    def __init__(self, order: Order):
        self.order_id = order.order_id
        self.total_amount = order.order_amount()
        self.paid = order.is_fully_paid()

response = json.dumps(order_response_dto.__dict__)

class BigDTO:
    ...

class Discount:
    def __init__(self, data):
        self.type = data.get("type")
        self.amount = int(data.get("amount", 0))

from dataclasses import dataclass

@dataclass
class Discount:
    type: str
    amount: int

from dataclasses import dataclass

@dataclass
class Discount:
    type: str
    amount: int

    def __post_init__(self):
        self.amount = int(self.amount)

from dataclasses import dataclass

@dataclass
class Pricing:
    unit_price: int
    currency: str = "CNY"

    def total(self, quantity: int) -> int:
        return self.unit_price * quantity

from dataclasses import dataclass, field
from typing import List

@dataclass
class OrderItem:
    sku: str
    pricing: Pricing
    quantity: int = 1
    discounts: List[Discount] = field(default_factory=list)

    def subtotal(self) -> int:
        discount = sum(d.amount for d in self.discounts)
        return self.pricing.total(self.quantity) - discount

def calculate_total(items: List[OrderItem]) -> int:
    ...

@dataclass(frozen=True)
class PaymentTransaction:
    tx_id: str
    amount: int

class Order(Base):
    __tablename__ = "orders"

    id = Column(String, primary_key=True)
    total_amount = Column(Integer)

class OrderORM(Base):
    __tablename__ = "orders"

    order_id = Column(String, primary_key=True)
    total_amount = Column(Integer)

class OrderRepository:
    def save(self, order: Order):
        raise NotImplementedError

    def get(self, order_id: str) -> Order:
        raise NotImplementedError

class OrderRepositoryImpl(OrderRepository):
    def get(self, order_id: str) -> Order:
        orm = self.session.query(OrderORM).get(order_id)

        raw = {
            "order_id": orm.order_id,
            "items": self._load_items(orm),
            "payment": self._load_payment(orm)
        }

        return Order(raw)

def save(self, order: Order):
    orm = OrderORM(
        order_id=order.order_id,
        total_amount=order.order_amount()
    )
    self.session.add(orm)

if price <= 0:
    return None

try:
    ...
except Exception:
    pass

class DomainError(Exception):
    pass

class InvalidPriceError(DomainError):
    pass

class PaymentAmountError(DomainError):
    pass

class OrderStateError(DomainError):
    pass

from dataclasses import dataclass

@dataclass
class OrderItem:
    sku: str
    quantity: int

    def __post_init__(self):
        if self.quantity <= 0:
            raise InvalidPriceError("quantity must be positive")

class Order:
    ...

    def pay(self, amount: int):
        if amount <= 0:
            raise PaymentAmountError("payment must be positive")

        if self.is_fully_paid():
            raise OrderStateError("order already paid")

        self.payment.add_transaction(amount)

class OrderStatus:
    CREATED = "CREATED"
    PAID = "PAID"
    CANCELED = "CANCELED"


class Order:
    ...

    def cancel(self):
        if self.status == OrderStatus.PAID:
            raise OrderStateError("paid order cannot be canceled")

        self.status = OrderStatus.CANCELED

try:
    order.pay(amount)
except DomainError as e:
    return error_response(str(e))