# 1. 单行注释：以#开头，#后建议加空格
print("hello world")  # 行尾注释

# 2. 多行注释：三对单引号/双引号包裹（本质是未赋值的字符串常量）
'''
这是多行注释
第二行注释
'''
"""
这也是多行注释
常用于函数/类的文档说明
"""

# 3. 文档字符串docstring：函数/类/模块的首行三引号注释，可通过__doc__属性访问
def add(a, b):
    """两个数字相加，返回求和结果"""
    return a + b
print(add.__doc__)  # 输出文档字符串

# 1. 整数int：正负整数，无大小限制
a = 10
b = -5
c = 0x10  # 十六进制
d = 0o10  # 八进制
e = 0b10  # 二进制

# 2. 浮点数float：双精度小数，支持科学计数法
f = 3.14
g = -2.5
h = 1e3  # 1000.0

# 3. 布尔值bool：int的子类，True=1，False=0
i = True
j = False
print(True + 1)  # 输出2

# 4. 复数complex：实部+虚部，虚部用j表示
k = 3 + 4j
print(k.real)  # 实部3.0
print(k.imag)  # 虚部4.0

# 算术运算
print(10 + 3)   # 加 13
print(10 - 3)   # 减 7
print(10 * 3)   # 乘 30
print(10 / 3)   # 除 3.333...（永远返回浮点数）
print(10 // 3)  # 整除 3（向下取整）
print(10 % 3)   # 取模 1（余数）
print(10 ** 3)  # 幂运算 1000

# 赋值运算
a = 10
a += 5  # 等价于a = a + 5，同理-=、*=、/=、//=、%=、**=

# 比较运算：返回True/False
print(10 > 3)
print(10 < 3)
print(10 >= 3)
print(10 <= 3)
print(10 == 3)  # 等于
print(10 != 3)  # 不等于

# 逻辑运算
print(True and False)  # 与：全True才返回True
print(True or False)   # 或：有一个True就返回True
print(not True)        # 非：取反

# 位运算（针对二进制）
print(10 & 3)  # 按位与
print(10 | 3)  # 按位或
print(10 ^ 3)  # 按位异或
print(~10)     # 按位取反
print(10 << 2) # 左移2位
print(10 >> 2) # 右移2位

d = {"name":"张三", "age":20}

# 查
print(d["name"])  # 按键取值，key不存在会报错KeyError
print(d.get("age"))  # 推荐，key不存在返回None，不会报错
print(d.get("height", 180))  # key不存在返回默认值180
print(d.keys())  # 获取所有key
print(d.values())  # 获取所有value
print(d.items())  # 获取所有(key, value)键值对，常用于for循环

# 增/改
d["age"] = 21  # key存在则修改，不存在则新增
d["height"] = 180  # 新增键值对
d.update({"gender":"男", "weight":65})  # 批量新增/修改

# 删
d.pop("age")  # 删除指定key的键值对，返回value
d.popitem()  # Python3.7+删除最后插入的键值对
del d["name"]  # 删除指定key的键值对
d.clear()  # 清空字典

# 基础语法
age = 20
if age < 18:
    print("未成年")
elif age < 60:
    print("成年")
else:
    print("老年")

# 三元表达式（简化单if-else，一行完成）
# 语法：结果1 if 条件 else 结果2
is_adult = "成年" if age >= 18 else "未成年"
print(is_adult)

# 多条件判断
score = 85
if score >= 90 and score <= 100:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

# 基础语法
i = 0
while i < 5:
    print(i)
    i += 1

# while-else结构：else代码块在循环正常结束（非break跳出）时执行
i = 0
while i < 5:
    print(i)
    i += 1
else:
    print("循环正常结束")

# 基础遍历
li = [1,2,3,4,5]
for num in li:
    print(num)

# 遍历字符串
for char in "python":
    print(char)

# 遍历字典
d = {"name":"张三", "age":20}
for key in d:  # 遍历key
    print(key, d[key])
for k, v in d.items():  # 遍历键值对（推荐）
    print(k, v)

# range()函数：生成整数序列，语法range(start, end, step)，左闭右开
for i in range(5):  # 0-4
    print(i)
for i in range(1, 10, 2):  # 1,3,5,7,9
    print(i)

# for-else结构：和while-else一致，循环正常结束执行else
for i in range(5):
    print(i)
else:
    print("循环正常结束")

# break示例
for i in range(5):
    if i == 3:
        break
    print(i)  # 输出0,1,2

# continue示例
for i in range(5):
    if i == 3:
        continue
    print(i)  # 输出0,1,2,4

# pass示例
for i in range(5):
    if i == 3:
        pass  # 暂不实现逻辑，先占位，避免语法报错
    print(i)

# 函数定义
def add(a, b):
    """两个数字相加，返回求和结果"""
    result = a + b
    return result

# 函数调用
sum_result = add(10, 20)
print(sum_result)  # 30

# 无返回值函数
def say_hello():
    print("hello world")

say_hello()  # 调用

# 1. 位置参数
def func1(a, b, c):
    print(a, b, c)
func1(1, 2, 3)  # 按顺序传递

# 2. 关键字参数
func1(a=1, c=3, b=2)  # 顺序可乱
func1(1, c=3, b=2)  # 位置参数在前，关键字参数在后

# 3. 默认参数
def func2(a, b=10, c=20):
    print(a, b, c)
func2(5)  # 输出5 10 20，b和c用默认值
func2(5, 15)  # 输出5 15 20，c用默认值
func2(5, c=25)  # 输出5 10 25，b用默认值

# 注意：默认参数不能用可变类型（列表/字典），否则会有累积问题
# 错误示例
def func_bad(a, li=[]):
    li.append(a)
    print(li)
func_bad(1)  # [1]
func_bad(2)  # [1,2]（默认列表被复用，出现累积）
# 正确示例
def func_good(a, li=None):
    if li is None:
        li = []
    li.append(a)
    print(li)

# 4. 可变位置参数*args
def func3(a, *args):
    print("a:", a)
    print("args:", args)  # 元组类型
func3(1, 2, 3, 4, 5)  # a=1，args=(2,3,4,5)

# 5. 强制关键字参数
def func4(a, *, b, c):
    print(a, b, c)
func4(1, b=2, c=3)  # 正确，b和c必须用关键字传递
# func4(1, 2, 3)  # 报错，位置参数无法传递*之后的参数

# 6. 可变关键字参数**kwargs
def func5(a, **kwargs):
    print("a:", a)
    print("kwargs:", kwargs)  # 字典类型
func5(1, name="张三", age=20, gender="男")

# 完整参数组合示例
def func_all(a, b=10, *args, c, d=20, **kwargs):
    print(a, b, args, c, d, kwargs)

# 全局变量
g_num = 100

def func():
    # 局部变量
    l_num = 200
    print(g_num)  # 可访问全局变量
    print(l_num)

func()
# print(l_num)  # 报错，外部无法访问局部变量

# global关键字：函数内修改全局变量必须声明global
def func2():
    global g_num
    g_num = 200  # 修改全局变量，而非创建局部变量

func2()
print(g_num)  # 200

# nonlocal关键字：闭包内修改外层函数的变量，必须声明nonlocal
def outer():
    num = 10
    def inner():
        nonlocal num
        num = 20
        print(num)
    inner()
    print(num)

outer()  # 输出20 20

def outer(num1):
    # 内层函数
    def inner(num2):
        # 引用外层函数的num1
        return num1 + num2
    # 返回内层函数
    return inner

# 调用外层函数，得到内层函数的引用，保留num1=10的状态
add_10 = outer(10)
print(add_10(5))   # 15
print(add_10(20))  # 30

add_20 = outer(20)
print(add_20(5))   # 25

# 基础装饰器
def decorator(func):
    def wrapper(*args, **kwargs):
        # 额外功能：执行前
        print("函数开始执行")
        # 执行原函数
        result = func(*args, **kwargs)
        # 额外功能：执行后
        print("函数执行结束")
        return result
    return wrapper

# 用@语法糖应用装饰器
@decorator
def add(a, b):
    print(f"执行add函数，参数{a}, {b}")
    return a + b

# 调用原函数，自动触发装饰器功能
res = add(10, 20)
print(res)

# 生成器函数：生成0-n的数字
def gen_num(n):
    for i in range(n):
        yield i

# 得到生成器对象
gen = gen_num(5)
print(gen)  # <generator object gen_num at 0x...>

# 迭代生成器
print(next(gen))  # 0
print(next(gen))  # 1
for num in gen:
    print(num)  # 2,3,4

# 定义类
class Person:
    # 类属性：所有实例共享，定义在方法外
    species = "人类"

    # 构造方法：实例化时自动调用，用于初始化实例属性
    def __init__(self, name, age):
        # 实例属性：每个实例独有，self代表当前实例
        self.name = name
        self.age = age

    # 实例方法：第一个参数必须是self
    def say_hello(self):
        print(f"大家好，我是{self.name}，今年{self.age}岁")

# 实例化对象
p1 = Person("张三", 20)
p2 = Person("李四", 22)

# 访问属性和方法
print(p1.name)  # 张三
print(p1.species)  # 人类
p1.say_hello()  # 调用方法

# 修改属性
p1.age = 21
p1.say_hello()

class Person:
    species = "人类"

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

    # 实例方法
    def say_name(self):
        print(f"姓名：{self.name}")

    # 类方法
    @classmethod
    def get_species(cls):
        print(f"物种：{cls.species}")

    # 静态方法
    @staticmethod
    def breathe():
        print("人类需要呼吸")

# 调用
Person.get_species()  # 类调用类方法
Person.breathe()      # 类调用静态方法

p = Person("张三")
p.say_name()    # 实例调用实例方法
p.get_species() # 实例调用类方法
p.breathe()     # 实例调用静态方法

class Person:
    def __init__(self, name, age, gender):
        self.name = name  # 公有
        self._age = age    # 受保护
        self.__gender = gender  # 私有

    # 公有方法，访问私有属性
    def get_gender(self):
        return self.__gender

p = Person("张三", 20, "男")
print(p.name)  # 正常访问
print(p._age)  # 可访问，但不建议
# print(p.__gender)  # 报错，外部无法直接访问私有属性
print(p.get_gender())  # 通过内部方法访问，正常

# 父类（基类）
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print(f"我是{self.name}，今年{self.age}岁")

# 子类（派生类），继承Person
class Student(Person):
    def __init__(self, name, age, student_id):
        # 调用父类的构造方法
        super().__init__(name, age)
        # 子类独有属性
        self.student_id = student_id

    # 重写父类方法
    def say_hello(self):
        print(f"我是{self.name}，学号{self.student_id}，今年{self.age}岁")

    # 子类独有方法
    def study(self):
        print(f"{self.name}正在学习")

# 实例化子类
s = Student("张三", 20, "2024001")
s.say_hello()  # 调用重写后的方法
s.study()      # 调用子类独有方法

class Cat:
    def speak(self):
        print("喵喵喵")

class Dog:
    def speak(self):
        print("汪汪汪")

class Duck:
    def speak(self):
        print("嘎嘎嘎")

# 多态：统一的调用接口，不同的执行结果
def animal_speak(animal):
    animal.speak()

# 传入不同对象，执行不同方法
animal_speak(Cat())
animal_speak(Dog())
animal_speak(Duck())

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 打印对象时触发
    def __str__(self):
        return f"Person(name={self.name}, age={self.age})"

    # 对象可调用时触发
    def __call__(self):
        print(f"{self.name}被调用了")

p = Person("张三", 20)
print(p)  # 触发__str__，输出Person(name=张三, age=20)
p()       # 触发__call__，输出张三被调用了

# 1. 导入整个模块
import math
print(math.pi)  # 调用模块内的属性/函数，需加模块名前缀

# 2. 导入模块并起别名
import numpy as np
print(np.array([1,2,3]))

# 3. 从模块中导入指定的函数/类/变量
from math import pi, sqrt
print(pi)
print(sqrt(4))  # 无需加模块名前缀

# 4. 从模块中导入所有内容（不推荐，易造成命名冲突）
from math import *

try:
    # 可能出现异常的代码
    num1 = int(input("请输入第一个数字："))
    num2 = int(input("请输入第二个数字："))
    result = num1 / num2
except ValueError:
    # 捕获指定异常，处理逻辑
    print("输入的不是有效数字！")
except ZeroDivisionError:
    # 捕获多个异常分支
    print("除数不能为0！")
except Exception as e:
    # 捕获所有异常，e为异常对象，获取异常信息
    print(f"发生未知错误：{e}")
else:
    # try代码块无异常时执行
    print(f"计算结果：{result}")
finally:
    # 无论是否发生异常，都会执行，常用于资源释放
    print("程序执行结束")

# 自定义异常
class AgeError(Exception):
    """年龄输入错误异常"""
    pass

def set_age(age):
    if age < 0 or age > 150:
        raise AgeError(f"年龄{age}不合法，必须在0-150之间")
    print(f"年龄设置为{age}")

try:
    set_age(200)
except AgeError as e:
    print(e)

# 语法：open(file, mode='r', encoding=None)
# file：文件路径，mode：打开模式，encoding：编码格式（文本文件推荐utf-8）

# 1. 传统方式：手动关闭
f = open("test.txt", "r", encoding="utf-8")
content = f.read()
f.close()  # 必须关闭，否则会占用资源

# 2. 推荐方式：with语句，自动关闭
with open("test.txt", "r", encoding="utf-8") as f:
    content = f.read()
# 跳出with代码块，文件自动关闭

# os模块常用操作
import os

print(os.getcwd())  # 获取当前工作目录
os.mkdir("test_dir")  # 创建单级目录
os.makedirs("a/b/c")  # 创建多级目录
os.rmdir("test_dir")  # 删除空目录
os.removedirs("a/b/c") # 删除多级空目录
print(os.listdir())  # 列出当前目录下的所有文件和目录
os.rename("old.txt", "new.txt")  # 重命名文件/目录
print(os.path.exists("test.txt"))  # 判断文件/目录是否存在
print(os.path.isfile("test.txt"))  # 判断是否是文件
print(os.path.isdir("test_dir"))   # 判断是否是目录
print(os.path.join("/home/user", "test.txt"))  # 拼接路径

# pathlib模块（推荐）
from pathlib import Path

path = Path("/home/user/test.txt")
print(path.exists())  # 判断是否存在
print(path.is_file()) # 判断是否是文件
print(path.parent)    # 获取父目录
print(path.name)      # 获取文件名
print(path.suffix)    # 获取文件后缀
new_path = path.parent / "new.txt"  # 路径拼接，用/运算符

# 1. 列表推导式：[表达式 for 变量 in 可迭代对象 if 条件]
# 生成0-9的偶数的平方
li = [i**2 for i in range(10) if i % 2 == 0]
print(li)  # [0, 4, 16, 36, 64]

# 2. 字典推导式：{key表达式: value表达式 for 变量 in 可迭代对象 if 条件}
# 生成数字到平方的映射
d = {i: i**2 for i in range(5)}
print(d)  # {0:0, 1:1, 2:4, 3:9, 4:16}

# 3. 集合推导式：{表达式 for 变量 in 可迭代对象 if 条件}
# 去重并生成偶数集合
s = {i for i in [1,2,2,3,3,4,5] if i % 2 == 0}
print(s)  # {2,4}

# 4. 生成器表达式：(表达式 for 变量 in 可迭代对象 if 条件)
# 惰性计算，返回生成器，节省内存
gen = (i**2 for i in range(10) if i % 2 == 0)
print(gen)  # <generator object <genexpr> at 0x...>
for num in gen:
    print(num)

from collections.abc import Iterable, Iterator

li = [1,2,3]
print(isinstance(li, Iterable))  # True，列表是可迭代对象
print(isinstance(li, Iterator))  # False，列表不是迭代器

# iter()将可迭代对象转为迭代器
it = iter(li)
print(isinstance(it, Iterator))  # True
print(next(it))  # 1
print(next(it))  # 2
print(next(it))  # 3
# next(it)  # 无元素，抛出StopIteration

# 1. 变量解包
a, b, c = [1,2,3]
print(a, b, c)  # 1 2 3

# 2. 多变量解包，*接收剩余元素
a, *b, c = [1,2,3,4,5]
print(a)  # 1
print(b)  # [2,3,4]
print(c)  # 5

# 3. 函数参数解包
def add(a, b, c):
    return a + b + c

li = [1,2,3]
print(add(*li))  # 等价于add(1,2,3)

d = {"a":1, "b":2, "c":3}
print(add(**d))  # 等价于add(a=1, b=2, c=3)

# 4. 容器合并
li1 = [1,2,3]
li2 = [4,5,6]
li3 = [*li1, *li2]  # [1,2,3,4,5,6]

d1 = {"a":1, "b":2}
d2 = {"c":3, "d":4}
d3 = {**d1, **d2}  # {'a':1, 'b':2, 'c':3, 'd':4}

import copy

# 1. 赋值：仅传递引用，指向同一个内存地址，修改一个另一个必变
li1 = [1,2, [3,4]]
li2 = li1
li2[0] = 100
li2[2][0] = 300
print(li1)  # [100, 2, [300, 4]]，原列表被修改

# 2. 浅拷贝copy.copy()：拷贝外层对象，内层嵌套的可变对象仍共享引用
li1 = [1,2, [3,4]]
li2 = copy.copy(li1)
li2[0] = 100  # 外层修改，原列表不变
li2[2][0] = 300  # 内层修改，原列表同步变化
print(li1)  # [1, 2, [300, 4]]

# 3. 深拷贝copy.deepcopy()：完全拷贝，内外层所有对象都独立，修改互不影响
li1 = [1,2, [3,4]]
li2 = copy.deepcopy(li1)
li2[0] = 100
li2[2][0] = 300
print(li1)  # [1, 2, [3, 4]]，原列表完全不受影响

from typing import List, Dict, Tuple, Optional, Any

# 1. 变量类型注解
name: str = "张三"
age: int = 20
height: Optional[float] = None  # 可选类型，可为float或None

# 2. 函数类型注解
def add(a: int, b: int) -> int:
    """两个int相加，返回int"""
    return a + b

# 复杂类型注解
def get_user_info(user_id: int) -> Dict[str, Any]:
    """根据用户ID获取用户信息，返回字典"""
    return {"user_id": user_id, "name": "张三", "age": 20}

def get_numbers() -> Tuple[int, str, float]:
    """返回元组"""
    return 1, "hello", 3.14

def process_list(li: List[int]) -> List[int]:
    """处理int列表，返回int列表"""
    return [i*2 for i in li]

# 自定义上下文管理器
class MyContext:
    def __enter__(self):
        # 进入with代码块时执行，返回值赋值给as后的变量
        print("资源获取")
        return "资源对象"

    def __exit__(self, exc_type, exc_val, exc_tb):
        # 退出with代码块时执行，无论是否异常都会执行
        # exc_type/exc_val/exc_tb为异常信息，无异常则为None
        print("资源释放")
        return True  # 返回True可抑制异常向外抛出

# 使用
with MyContext() as res:
    print(res)
    print("业务逻辑执行")

from contextlib import contextmanager

@contextmanager
def my_context():
    # __enter__部分：yield之前的代码
    print("资源获取")
    res = "资源对象"
    try:
        yield res  # 暂停，执行with内的代码，返回值给as后的变量
    finally:
        # __exit__部分：yield之后的代码，无论是否异常都会执行
        print("资源释放")

# 使用
with my_context() as res:
    print(res)
    print("业务逻辑执行")