第 2 章：Python 基础语法

# Python: 直接赋值，无需声明关键字
name = "Alice"      # 字符串
age = 25            # 整数
height = 1.75       # 浮点数
is_student = True   # 布尔值

# 可以同时给多个变量赋值（解构类似 JS）
x, y, z = 1, 2, 3

# 交换变量值（无需临时变量）
a, b = 10, 20
a, b = b, a  # 现在 a=20, b=10

# 使用 type() 查看类型（类似 JS 的 typeof，但更精确）
print(type(42))        # 
print(type(3.14))      # 
print(type("hello"))   # 
print(type(True))      # 
print(type(None))      #  —— 类似 JS 的 null/undefined

# 类型转换
num_str = "100"
num = int(num_str)     # 类似 parseInt()
price = float("19.99") # 类似 parseFloat()
text = str(42)         # 类似 String(42)

# 字符串定义：单引号、双引号、三引号都可以
name = 'Alice'
message = "Hello"
paragraph = """多行
字符串"""

# f-string 格式化（推荐，类似 JS 模板字符串）
age = 25
print(f"我叫 {name}，今年 {age} 岁")

# 字符串方法（类似 JS String.prototype）
text = "  Hello World  "
print(text.strip())      # "Hello World" —— 类似 trim()
print(text.lower())      # "  hello world  " —— 类似 toLowerCase()
print(text.upper())      # "  HELLO WORLD  " —— 类似 toUpperCase()
print(text.replace("World", "Python"))  # "  Hello Python  "

# 分割与连接
words = "a,b,c".split(",")  # ['a', 'b', 'c'] —— 类似 split()
result = "-".join(words)     # "a-b-c" —— JS 中需用 Array.prototype.join()

# 数字千分位（类似 JS 的 toLocaleString()）
amount = 1234567.89
print(f"金额: {amount:,.2f}")  # 金额: 1,234,567.89
# JS: amount.toLocaleString('en-US', { minimumFractionDigits: 2 })

# 百分比
ratio = 0.856
print(f"完成率: {ratio:.1%}")   # 完成率: 85.6%

# 对齐与填充
name = "Python"
print(f"|{name:>15}|")   # |         Python| 右对齐
print(f"|{name:<15}|")   # |Python         | 左对齐
print(f"|{name:^15}|")   # |    Python     | 居中
print(f"|{name:*^15}|")  # |****Python*****| 用 * 填充

# 日期格式化
from datetime import datetime
now = datetime.now()
print(f"当前时间: {now:%Y-%m-%d %H:%M:%S}")
# 相当于 JS 的 dayjs().format('YYYY-MM-DD HH:mm:ss')

# 调用表达式（类似 JS 的 ${fn()}）
def greet(name):
    return f"Hello, {name}"

print(f"{greet('World')}")  # Hello, World

# = 说明符（Python 3.8+）：同时显示变量名和值（调试利器！）
x = 10
y = 20
print(f"{x + y = }")  # x + y = 30
# 相当于 console.log({x}, {y}, x + y)

# 创建列表（类似 JS 数组）
fruits = ["apple", "banana", "cherry"]
mixed = [1, "two", 3.0, True]  # 可以混合类型（但不推荐）

# 索引访问（与 JS 相同，从 0 开始）
print(fruits[0])   # "apple"
print(fruits[-1])  # "cherry" —— 负数索引从末尾开始，JS 中需用 at(-1)

# 切片操作（Python 特有，非常强大）
print(fruits[0:2])   # ["apple", "banana"] —— 索引 0 到 1（不含 2）
print(fruits[:2])    # ["apple", "banana"] —— 从头开始
print(fruits[1:])    # ["banana", "cherry"] —— 到末尾
print(fruits[::2])   # ["apple", "cherry"] —— 步长为 2
print(fruits[::-1])  # ["cherry", "banana", "apple"] —— 反转！

# 常用方法
fruits.append("orange")      # 末尾添加，类似 push()
fruits.insert(1, "mango")    # 指定位置插入，类似 splice()
fruits.remove("banana")      # 删除第一个匹配项（JS 需用 filter 或 splice）
popped = fruits.pop()        # 删除并返回末尾元素，类似 pop()
print(len(fruits))           # 获取长度，类似 .length

# 创建字典（类似 JS 对象字面量）
user = {
    "name": "Alice",
    "age": 25,
    "is_admin": False
}

# 访问值
print(user["name"])        # "Alice"
print(user.get("email"))   # None —— 安全访问，不会报错
print(user.get("email", "default@example.com"))  # 提供默认值

# 添加 / 修改
user["email"] = "alice@example.com"
user["age"] = 26

# 删除
del user["is_admin"]       # 类似 delete user.isAdmin

# 遍历（类似 Object.entries()）
for key, value in user.items():
    print(f"{key}: {value}")

# 仅遍历键或值
for key in user.keys():      # 类似 Object.keys()
    print(key)
for value in user.values():  # 类似 Object.values()
    print(value)

# 元组使用圆括号定义，创建后不可修改
point = (10, 20)
coordinates = (1, 2, 3)

# 单元素元组需要逗号！
single = (42,)  # 注意逗号
not_tuple = (42)  # 这只是整数 42

# 元组解包（ unpacking，类似 JS 解构）
x, y = point
print(x, y)  # 10 20

# 函数返回多个值时，实际返回的是元组
def get_min_max(numbers):
    return min(numbers), max(numbers)

minimum, maximum = get_min_max([3, 1, 4, 1, 5])
print(minimum, maximum)  # 1 5

# 创建集合（自动去重，无序）
numbers = {1, 2, 3, 3, 3}
print(numbers)  # {1, 2, 3}

# 从列表创建集合（快速去重）
items = ["a", "b", "a", "c", "b"]
unique = set(items)
print(unique)  # {'a', 'b', 'c'}

# 集合运算（数学集合操作）
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a | b)   # {1, 2, 3, 4, 5, 6} —— 并集（类似 JS Set union）
print(a & b)   # {3, 4} —— 交集
print(a - b)   # {1, 2} —— 差集
print(a ^ b)   # {1, 2, 5, 6} —— 对称差集

# 传统方式（类似 JS 的 for...of + push）
squares = []
for x in range(10):
    squares.append(x ** 2)

# 列表推导式（一行搞定）
squares = [x ** 2 for x in range(10)]

# 带条件的列表推导式（类似 filter + map）
evens = [x for x in range(20) if x % 2 == 0]

# JS 对比:
// const evens = Array.from({length: 20}, (_, i) => i).filter(x => x % 2 === 0);

# 字典推导式
word_lengths = {word: len(word) for word in ["apple", "banana", "cherry"]}
# {'apple': 5, 'banana': 6, 'cherry': 6}

# 集合推导式
square_set = {x ** 2 for x in range(100)}  # 自动去重

from collections import defaultdict, Counter, deque

# 1. defaultdict —— 带默认值的字典
# 不需要先检查 key 是否存在再初始化，类似 JS Map 的 getOrDefault
word_count = defaultdict(int)
sentence = "hello world hello python".split()
for word in sentence:
    word_count[word] += 1  # 不存在时自动初始化为 0
print(dict(word_count))  # {'hello': 2, 'world': 1, 'python': 1}

# 按分类收集数据
users_by_role = defaultdict(list)
users = [("Alice", "admin"), ("Bob", "user"), ("Charlie", "admin")]
for name, role in users:
    users_by_role[role].append(name)
print(dict(users_by_role))
# {'admin': ['Alice', 'Charlie'], 'user': ['Bob']}

# 2. Counter —— 计数器（统计频率的利器）
colors = ["red", "blue", "red", "green", "blue", "red"]
cnt = Counter(colors)
print(cnt)              # Counter({'red': 3, 'blue': 2, 'green': 1})
print(cnt.most_common(2))  # [('red', 3), ('blue', 2)] —— 前 N 名

# 支持数学运算
cnt2 = Counter(["red", "green"])
print(cnt + cnt2)       # Counter({'red': 4, 'blue': 2, 'green': 2})
print(cnt - cnt2)       # Counter({'red': 2, 'blue': 2})

# 3. deque —— 双端队列（高性能的头部操作）
# list 在头部插入/删除是 O(n)，deque 是 O(1)
history = deque(maxlen=5)  # 最多保留 5 条记录
for i in range(10):
    history.append(i)
print(history)  # deque([5, 6, 7, 8, 9], maxlen=5)

# 灵活的双端操作
d = deque(["a", "b", "c"])
d.appendleft("x")        # 左侧追加
d.append("y")            # 右侧追加
print(d)  # deque(['x', 'a', 'b', 'c', 'y'])

score = 85

if score >= 90:
    grade = "A"
elif score >= 80:      # elif = else if，注意不是 "else if"
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "D"

print(f"成绩等级: {grade}")

# 三元表达式（类似 JS 的条件运算符）
status = "及格" if score >= 60 else "不及格"
# JS: const status = score >= 60 ? "及格" : "不及格";

# Python 的 for 循环直接遍历元素（类似 JS 的 for...of）
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# 如果需要索引，使用 enumerate()（类似 JS 的 entries()）
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")
# 0: apple
# 1: banana
# 2: cherry

# 遍历字典
user = {"name": "Alice", "age": 25}
for key, value in user.items():
    print(f"{key} = {value}")

# range() 生成数字序列（类似 JS 的 for (let i = 0; i < n; i++)）
for i in range(5):       # 0, 1, 2, 3, 4
    print(i)

for i in range(2, 10, 2):  # 2, 4, 6, 8（起始, 结束, 步长）
    print(i)

# while 循环（与 JS 语法相同）
count = 0
while count < 5:
    print(count)
    count += 1  # Python 没有 count++ 语法！

# break 和 continue（与 JS 完全相同）
for num in range(10):
    if num == 3:
        continue    # 跳过当前迭代
    if num == 7:
        break       # 终止循环
    print(num)
# 输出: 0, 1, 2, 4, 5, 6

# else 子句（Python 特有！循环正常结束时执行）
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            break
    else:  # 注意缩进！没有触发 break 时执行
        print(f"{n} 是质数")
# 输出: 2, 3, 5, 7 是质数

# 基础函数（类似 JS 的 function 声明）
def greet(name):
    """函数的文档字符串（docstring），说明函数用途"""
    return f"Hello, {name}!"

print(greet("Alice"))  # Hello, Alice!

# 多返回值（实际是返回元组）
def get_stats(numbers):
    return min(numbers), max(numbers), sum(numbers) / len(numbers)

min_val, max_val, avg = get_stats([1, 2, 3, 4, 5])
print(min_val, max_val, avg)  # 1 5 3.0

# 1. 位置参数（默认方式）
def power(base, exponent):
    return base ** exponent

print(power(2, 3))  # 8

# 2. 默认参数（类似 JS 的默认参数）
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Alice"))           # Hello, Alice!
print(greet("Bob", "Hi"))       # Hi, Bob!

# ⚠️ 默认参数不要使用可变对象！
def bad_append(item, items=[]):  # 错误！
    items.append(item)
    return items

def good_append(item, items=None):  # 正确做法
    if items is None:
        items = []
    items.append(item)
    return items

# 3. *args —— 接收任意数量的位置参数（类似 JS 的 ...args）
def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3, 4))  # 10
# args 是一个元组: (1, 2, 3, 4)

# 4. **kwargs —— 接收任意数量的关键字参数（类似 JS 的对象解构剩余属性）
def create_user(**kwargs):
    return {
        "name": kwargs.get("name", "Anonymous"),
        "age": kwargs.get("age", 0),
        **kwargs  # 展开其他属性
    }

user = create_user(name="Alice", age=25, email="alice@example.com")

# 5. 组合使用（顺序: 位置参数, 默认参数, *args, **kwargs）
def func(a, b=2, *args, **kwargs):
    print(f"a={a}, b={b}, args={args}, kwargs={kwargs}")

func(1, 3, 4, 5, x=10, y=20)
# a=1, b=3, args=(4, 5), kwargs={'x': 10, 'y': 20}

# lambda 语法（只能写单行表达式）
square = lambda x: x ** 2
print(square(5))  # 25

# 常用于排序和过滤（类似 JS 的箭头函数）
users = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
    {"name": "Charlie", "age": 35}
]

# 按年龄排序
users_sorted = sorted(users, key=lambda u: u["age"])

# JS 对比:
// const usersSorted = users.sort((a, b) => a.age - b.age);

# === 生成器函数：使用 yield 逐值返回 ===
def fibonacci(n):
    """生成前 n 个斐波那契数（惰性生成，不占内存）"""
    a, b = 0, 1
    for _ in range(n):
        yield a  # yield 类似 return，但函数不会退出
        a, b = b, a + b

# 使用生成器
for num in fibonacci(10):
    print(num, end=" ")  # 0 1 1 2 3 5 8 13 21 34

# 转为列表（惰性 -> 立即求值）
fib_list = list(fibonacci(10))
print(fib_list)  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# === 生成器表达式（类似列表推导式，但用小括号）===
# 列表推导式：一次性创建所有元素（占内存）
squares_list = [x**2 for x in range(10**6)]  # 100万个元素的列表

# 生成器表达式：按需生成（几乎不占内存）
squares_gen = (x**2 for x in range(10**6))   # 生成器对象

print(squares_gen)  # 
print(next(squares_gen))  # 0（取第一个值）
print(next(squares_gen))  # 1（取第二个值）

# === 实战：逐行读取大文件（不会撑爆内存）===
def read_large_file(filepath):
    """逐行读取文件，适合 GB 级别的大文件"""
    with open(filepath, "r", encoding="utf-8") as f:
        for line in f:
            yield line.strip()

# 处理大文件
for line in read_large_file("big_data.log"):
    if "ERROR" in line:
        print(line)

class User:
    # 类属性（类似 JS 的静态属性，所有实例共享）
    species = "Homo sapiens"

    # __init__ 是构造方法（类似 JS 的 constructor）
    def __init__(self, name, age):
        # self 相当于 JS 的 this，但必须显式作为第一个参数
        self.name = name      # 实例属性
        self._age = age       # 单下划线表示"私有"（约定，非强制）

    # 实例方法
    def greet(self):
        return f"Hello, I'm {self.name}"

    # 类方法（类似 JS 的 static 方法，但接收 cls）
    @classmethod
    def create_anonymous(cls):
        return cls("Anonymous", 0)

    # 静态方法（类似 JS 的 static 方法，不接收 self/cls）
    @staticmethod
    def is_adult(age):
        return age >= 18

# 创建实例（不需要 new 关键字！）
alice = User("Alice", 25)
print(alice.greet())  # Hello, I'm Alice

# 访问类属性
print(User.species)   # Homo sapiens

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("子类必须实现此方法")

class Dog(Animal):  # 继承语法: class 子类(父类)
    def __init__(self, name, breed):
        super().__init__(name)  # 调用父类构造（类似 super()）
        self.breed = breed

    def speak(self):
        return f"{self.name} says: Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says: Meow!"

dog = Dog("Buddy", "Golden Retriever")
cat = Cat("Whiskers")

print(dog.speak())  # Buddy says: Woof!
print(cat.speak())  # Whiskers says: Meow!

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 字符串表示（类似 JS 的 toString()）
    def __str__(self):
        return f"Vector({self.x}, {self.y})"

    # 开发者友好的表示（类似 JS 的 inspect 或 toJSON）
    def __repr__(self):
        return f"Vector(x={self.x}, y={self.y})"

    # 加法运算符重载（JS 中需用 Symbol.toPrimitive 或 valueOf）
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    # 相等比较（类似 JS 的 == 或 Object.is）
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

    # 长度（类似 JS 的 valueOf 或自定义属性）
    def __len__(self):
        return int((self.x ** 2 + self.y ** 2) ** 0.5)

v1 = Vector(2, 3)
v2 = Vector(4, 5)

print(str(v1))       # Vector(2, 3)
print(repr(v1))      # Vector(x=2, y=3)
print(v1 + v2)       # Vector(6, 8)
print(v1 == Vector(2, 3))  # True
print(len(v1))       # 3

# 基础异常处理
def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("错误：不能除以零！")
        return None
    except TypeError as e:
        print(f"类型错误: {e}")
        return None
    else:
        # try 成功执行且没有异常时运行
        print("计算成功！")
        return result
    finally:
        # 无论是否异常都会执行（常用于清理资源）
        print("计算结束")

print(divide(10, 2))   # 计算成功！ 计算结束 5.0
print(divide(10, 0))   # 错误：不能除以零！ 计算结束 None

# 继承 Exception 创建自定义异常（类似 JS 的 class extends Error）
class ValidationError(Exception):
    """数据验证失败时抛出"""
    def __init__(self, field, message):
        self.field = field
        self.message = message
        super().__init__(f"[{field}] {message}")

class User:
    def __init__(self, name, age):
        if not name or len(name) < 2:
            raise ValidationError("name", "姓名至少需要 2 个字符")
        if age < 0 or age > 150:
            raise ValidationError("age", "年龄必须在 0-150 之间")
        self.name = name
        self.age = age

try:
    user = User("A", 200)
except ValidationError as e:
    print(f"验证失败: {e}")
    # 输出: 验证失败: [name] 姓名至少需要 2 个字符

# 写入文件（类似 fs.writeFileSync）
with open("hello.txt", "w", encoding="utf-8") as f:
    f.write("Hello, Python!\n")
    f.write("第二行内容\n")
# with 语句自动关闭文件，无需手动 f.close()

# 读取文件（类似 fs.readFileSync）
with open("hello.txt", "r", encoding="utf-8") as f:
    content = f.read()       # 读取全部内容
    print(content)

# 逐行读取（类似 readline 接口）
with open("hello.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())  # strip() 去除换行符

# 读取为列表
with open("hello.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()    # ['Hello, Python!\n', '第二行内容\n']

# with 语句确保资源正确释放（类似 JS 的 try...finally）
# 即使发生异常，文件也会被关闭

# 传统写法（不推荐）
f = open("file.txt", "r")
try:
    data = f.read()
finally:
    f.close()  # 必须手动关闭

# with 写法（推荐）
with open("file.txt", "r") as f:
    data = f.read()
# 自动关闭，即使出错

# 自定义上下文管理器
from contextlib import contextmanager

@contextmanager
def managed_resource(name):
    print(f"获取资源: {name}")
    yield name  # yield 之前的代码是 __enter__，之后是 __exit__
    print(f"释放资源: {name}")

with managed_resource("数据库连接") as res:
    print(f"使用资源: {res}")
# 输出:
# 获取资源: 数据库连接
# 使用资源: 数据库连接
# 释放资源: 数据库连接

from pathlib import Path

# 创建路径对象（自动处理 Windows/Unix 路径差异）
project_dir = Path("/home/user/project")
data_file = project_dir / "data" / "users.json"  # 使用 / 拼接路径！

print(data_file)           # /home/user/project/data/users.json
print(data_file.name)      # users.json（文件名）
print(data_file.stem)      # users（不含扩展名）
print(data_file.suffix)    # .json（扩展名）
print(data_file.parent)    # /home/user/project/data（父目录）

# 路径检查
print(data_file.exists())       # False（检查是否存在）
print(data_file.is_file())      # False
print(data_file.is_dir())       # False

# 创建目录（类似 mkdir -p）
output_dir = Path("output")
output_dir.mkdir(parents=True, exist_ok=True)

# 遍历目录（类似 fs.readdir）
for file in Path(".").glob("*.py"):  # 匹配当前目录的 .py 文件
    print(file)

# 递归遍历
for file in Path(".").rglob("*.txt"):  # 递归查找所有 .txt
    print(file)

# 1. 导入整个模块（类似 import * as os from 'os'）
import os
print(os.getcwd())  # 获取当前工作目录

# 2. 从模块导入特定内容（类似 import { pi, sin } from 'math'）
from math import pi, sqrt
print(pi)
print(sqrt(16))  # 4.0

# 3. 导入并重命名（类似 import * as m from 'math'）
import datetime as dt
now = dt.datetime.now()

# 4. 导入所有（不推荐，会污染命名空间）
from math import *
print(sin(pi / 2))  # 1.0

# 5. 相对导入（包内部使用）
# from . import module      # 同级目录
# from .. import parent     # 上级目录
# from .utils import helper # 子模块

# utils.py
def helper():
    return "I'm a helper"

# 当直接运行 python utils.py 时，__name__ 是 '__main__'
# 当从其他文件 import utils 时，__name__ 是 'utils'
if __name__ == "__main__":
    # 这部分代码只在直接运行时执行
    print("测试 helper 函数:")
    print(helper())

# JS 类比:
// if (require.main === module) { ... }
// 或 ES Module 的 import.meta.main

# 常用标准库示例
import json
from datetime import datetime, timedelta

# JSON 处理（与 JS 几乎相同）
data = {"name": "Alice", "age": 25}
json_str = json.dumps(data, ensure_ascii=False, indent=2)
parsed = json.loads(json_str)

# 日期时间（类似 dayjs/moment）
now = datetime.now()
future = now + timedelta(days=7)
print(future.strftime("%Y-%m-%d"))  # 格式化输出