import math  # 导入Python标准库的数学模块（类比Java import java.lang.Math;）

# 使用模块内的属性/方法，需加“模块名.”前缀（模块导出的所有成员都可通过此方式访问）
print(math.pi)    # 输出圆周率：3.141592653589793（pi是math模块导出的常量）
print(math.sqrt(16))  # 计算平方根：4.0（sqrt是math模块导出的函数）

from math import pi, sqrt  # 只导入需要的成员，减少命名空间占用
# 等价于：从math模块中“导入”pi和sqrt两个导出成员

# 直接使用导入的成员，无需前缀
print(pi)       # 3.141592653589793
print(sqrt(16)) # 4.0

import datetime as dt  # 为长模块名起别名（类比Java import java.util.Date as MyDate;）
from math import pi as PI  # 为成员起别名，避免命名冲突

# 通过别名使用模块/成员
now = dt.datetime.now()  # 获取当前时间（dt是datetime模块的别名）
print(now)
print(PI)  # 3.141592653589793（PI是pi的别名）

from 模块名 import *  # 导入模块中“所有对外导出”的成员

from math import *  # 导入math模块的所有导出成员（pi、sqrt、sin、cos等）

# 直接使用所有导入的成员，无需前缀
print(pi)    # 3.141592653589793
print(sqrt(25))  # 5.0
print(sin(0))    # 0.0（sin是math模块的导出函数）

"""计算工具模块：演示导出控制"""

# 1. 公开成员（计划对外导出的）
def add(a, b):
    """加法函数：公开导出"""
    return a + b

def mul(a, b):
    """乘法函数：公开导出"""
    return a * b

PI = 3.1415926  # 常量：公开导出

# 2. 私有成员（仅模块内部使用，不建议对外导出）
# Python中以下划线_开头的成员，约定为“私有成员” [并非真的私有化，面向对象会讲解具体私有化]
def _check_number(num):
    """内部校验函数：私有，不对外导出"""
    return isinstance(num, (int, float))

# 3. 显式指定模块的导出列表（核心：控制*能导入的成员）
# __all__ 是模块的内置变量，定义了使用 from 模块 import * 时能导入的成员列表
__all__ = ["add", "mul", "PI"]

# 模块自测代码：仅直接运行本文件时执行
if __name__ == "__main__":
    print("自测加法：", add(1, 2))  # 输出 3
    print("自测乘法：", mul(3, 4))  # 输出 12
    print("内部校验：", _check_number(5))  # 输出 True（内部可使用私有函数）

# 方式1：批量导入（仅能导入__all__中定义的成员）
from calc_utils import *

# 可正常使用__all__中的成员
print("10 + 20 =", add(10, 20))  # 输出 30
print("3 × 5 =", mul(3, 5))      # 输出 15
print("圆周率：", PI)             # 输出 3.1415926

# 以下代码会报错：_check_number不在__all__中，无法通过*导入
# print(_check_number(10))  # NameError: name '_check_number' is not defined

# 方式2：强制导入私有成员（不推荐，破坏封装）
# 即使有__all__，仍可通过精准导入方式获取私有成员，但不符合Python规范
from calc_utils import _check_number
print("强制导入私有函数：", _check_number(10))  # 输出 True（不建议这么用）

import sys

# 打印所有模块搜索路径（优先级从高到低）
for idx, path in enumerate(sys.path):
    print(f"{idx+1}. {path}")

# json.py（本地错误文件）
print("这是我自己的 json.py 文件")

# main.py
import json

# 尝试使用 json 标准库的 dumps 方法
data = {"name": "Python", "version": 3.11}
print(json.dumps(data))

这是我自己的 json.py 文件
AttributeError: module 'json' has no attribute 'dumps'

import keyword
# 1. 打印Python所有关键字列表
print(keyword.kwlist)
# 2. 打印列表对象的所有可用方法/属性（和关键字无关，只是演示dir()用法）
print(dir(keyword.kwlist))

# 3. 演示Python数字的下划线分隔写法（提升可读性，不影响数值）
num1 = 1_000_000_000_000_00_0
print(num1)  # 输出：1000000000000000

# 4. 主程序入口判断
if __name__ == '__main__':
    print(num1 , end=" ")

python demo.py

# main.py
import demo  # 导入你的demo.py文件（此时demo的__name__ = 'demo'）

print("我是main.py的代码")

# demo.py
import keyword

# 供其他模块使用的变量/函数（对外暴露的内容）
num1 = 1_000_000_000_000_00_0

def print_keywords():
    """打印Python关键字列表（供其他模块调用）"""
    print(keyword.kwlist)

# 仅直接运行本脚本时才执行的代码（测试/演示逻辑）
if __name__ == '__main__':
    # 测试变量
    print(num1)  # 1000000000000000
    # 测试函数
    print_keywords()
    # 多次打印演示
    print(num1 , end=" ")

project/
  ├── main.py          # 主程序（入口文件）
  └── mypkg/           # 自定义包
      ├── __init__.py  # 包初始化文件（必填）
      ├── tools.py     # 工具模块
      └── io_utils.py  # IO操作模块

project/
  ├── Main.java        # 主程序（入口类）
  └── com/
      └── company/
          └── mypkg/
              ├── Tools.java   # 工具类
              └── IOUtils.java # IO操作类

# 导入mypkg包下的tools模块
from mypkg import tools
# 调用模块中的函数
print(tools.some_func())

// 导入com.company.mypkg包下的Tools类
import com.company.mypkg.Tools;
// 调用类中的静态方法
System.out.println(Tools.someFunc());

# 直接导入io_utils模块的load_json函数
from mypkg.io_utils import load_json

data = load_json("data.json")

// 静态导入IOUtils类的loadJson方法
import static com.company.mypkg.IOUtils.loadJson;

String data = loadJson("data.json");

# 简化长模块名（常用技巧）
from mypkg import io_utils as io

data = io.load_json("data.json")

// Java无直接别名语法，间接简化
import com.company.mypkg.IOUtils;

IOUtils io = new IOUtils();
String data = io.loadJson("data.json");

# A模块导入B模块的函数（触发循环第一步）
from b import b_func

def a_func():
    return "A模块函数"

# 调用B模块函数
print(b_func())

# B模块导入A模块的函数（形成循环依赖）
from a import a_func

def b_func():
    return "B模块函数"

# 调用A模块函数
print(a_func())

graph TD
    A["with open(...)"] --> B["打开文件引用"]
    B --> C["读/写操作"]
    C --> D["离开 with 代码块"]
    D --> E["自动 close 释放资源"]

# 定义文件路径（相对路径：相对于当前程序运行的目录；绝对路径：完整路径，如 C:/data.txt）
path = "data.txt"

# with 语句：自动关闭文件
# 参数说明："r" = 只读模式；encoding="utf-8" = 指定字符编码，读写中文必须显式指定
with open(path, mode="r", encoding="utf-8") as f:
    # read()：一次性读取文件的全部内容
    full_text = f.read()

# 打印读取到的内容
print(full_text)

path = "data.txt"

with open(path, mode="r", encoding="utf-8") as f:
    # 直接遍历文件句柄 f，会自动按行读取
    for line in f:
        # 注意：每行的末尾会自带一个换行符 \n
        # rstrip("\n")：移除行尾的换行符，避免打印时出现多余的空行
        cleaned_line = line.rstrip("\n")
        print(cleaned_line)

path = "out.txt"

with open(path, mode="w", encoding="utf-8") as f:
    # write() 方法：写入字符串
    # 注意：write() 不会自动添加换行符，需要手动在字符串末尾加 \n
    f.write("Hello, Python!\n")
    f.write("文件操作的核心是 with 语句\n")

path = "out.txt"

with open(path, mode="a", encoding="utf-8") as f:
    # 追加一行内容到文件末尾
    f.write("这是追加的内容，不会覆盖原文件\n")

# 配置参数：文件路径 + 要统计的关键字
file_path = "data.txt"
target_keyword = "python"

# 初始化统计变量
total_lines = 0  # 总行数
total_keyword_hits = 0  # 关键字出现的总次数

# 按行读取文件，逐行处理
with open(file_path, mode="r", encoding="utf-8") as f:
    for line in f:
        total_lines += 1  # 每读取一行，行数加 1
        # 统一转换为小写：实现忽略大小写的统计（如 Python、PYTHON 都算）
        # count() 方法：统计子字符串在当前字符串中出现的次数
        keyword_count_in_line = line.lower().count(target_keyword.lower())
        total_keyword_hits += keyword_count_in_line  # 累加到总次数中

# 打印统计结果
print(f"文件总行数：{total_lines}")
print(f"关键字「{target_keyword}」出现的总次数：{total_keyword_hits}")

import json  # 导入Python内置的json标准库

# 1. 定义一个Python字典（待序列化的对象）
python_data = {
    "name": "Tom",
    "age": 18,
    "is_student": True,
    "tags": ["python", "oop", "json"],
    "score": {"math": 95, "english": 88}
}

# 2. 序列化：Python对象 → JSON字符串
# 关键参数：ensure_ascii=False → 保留中文等非ASCII字符（不转成\uXXXX编码）
json_str = json.dumps(python_data, ensure_ascii=False)
print("JSON字符串：")
print(json_str)
print("数据类型：", type(json_str))  # 输出：<class 'str'>

# 3. 反序列化：JSON字符串 → Python对象
python_obj = json.loads(json_str)
print("\n反序列化后的Python对象：")
print(python_obj)
print("获取tags字段：", python_obj["tags"])  # 输出：['python', 'oop', 'json']
print("数据类型：", type(python_obj))  # 输出：<class 'dict'>

import json

# 1. 定义要写入文件的Python数据（列表+字典）
user_list = [
    {"name": "Tom", "age": 18, "city": "北京"},
    {"name": "Jerry", "age": 20, "city": "上海"},
    {"name": "Alice", "age": 19, "city": "广州"}
]

# 2. 序列化并写入JSON文件
file_path = "users.json"
with open(file_path, "w", encoding="utf-8") as f:
    # 关键参数：
    # - ensure_ascii=False：保留中文
    # - indent=2：格式化输出（缩进2个空格），便于阅读/调试（生产环境可省略，减少文件体积）
    json.dump(user_list, f, ensure_ascii=False, indent=2)

# 3. 从JSON文件读取并反序列化
with open(file_path, "r", encoding="utf-8") as f:
    loaded_data = json.load(f)

print("从文件读取的Python对象：")
print(loaded_data)
print("第一个用户的姓名：", loaded_data[0]["name"])  # 输出：Tom
print("数据类型：", type(loaded_data))  # 输出：<class 'list'>

import json
from datetime import datetime  # 导入Python的日期时间类型

# 定义包含非JSON内置类型的数据（datetime不是JSON支持的类型）
data = {
    "name": "Tom",
    "register_time": datetime.now()  # datetime对象
}

try:
    # 直接序列化会触发TypeError
    json_str = json.dumps(data, ensure_ascii=False)
except TypeError as e:
    print("JSON序列化失败：", e)
    # 输出：JSON序列化失败：Object of type datetime is not JSON serializable

# 解决方案：自定义序列化函数（入门版）
def json_serialize(obj):
    # 如果是datetime对象，转换为字符串
    if isinstance(obj, datetime):
        return obj.strftime("%Y-%m-%d %H:%M:%S")
    # 其他类型抛出原异常
    raise TypeError(f"类型 {type(obj)} 不支持JSON序列化")

# 使用default参数指定自定义序列化函数
json_str = json.dumps(data, ensure_ascii=False, default=json_serialize)
print("\n自定义序列化后的JSON字符串：")
print(json_str)
# 输出示例：{"name":"Tom","register_time":"2026-01-06 15:30:00"}

try:
    # 可能出错的代码放在 try 里
    x = int("123")
except ValueError:
    # 只处理你“预期会发生”的异常
    print("转换失败：不是合法数字")
else:
    # 没异常才会执行
    print("转换成功：", x)
finally:
    # 无论是否异常都会执行（常用于资源清理）
    print("不管成功失败都会执行到这里")

try:
    a = int("1")
    b = 10 / 0
except (ValueError, ZeroDivisionError) as e:
    print("发生错误：", e)

try:
    # 步骤1：读文件
    with open("data.txt", "r") as f:
        content = f.read()
    # 步骤2：转数字（假设文件内容是字符串）
    num = int(content)
    # 步骤3：这里故意写错变量名（你没预料到的错误）
    print(numm)  # 变量名错了，会触发 NameError
except FileNotFoundError:
    # 只捕获“文件不存在”的异常
    print("错误：文件找不到")
except ValueError:
    # 只捕获“转换数字失败”的异常
    print("错误：文件内容不是合法数字")

NameError: name 'numm' is not defined

try:
    with open("data.txt", "r") as f:
        content = f.read()
    num = int(content)
    print(numm)  # 变量名错误
except:  # 裸 except：捕捉所有异常
    print("出错了，但不知道为啥")

出错了，但不知道为啥

def withdraw(balance, amount):
    if amount <= 0:
        raise ValueError("取款金额必须大于 0")
    if amount > balance:
        raise ValueError("余额不足")
    return balance - amount

print(withdraw(100, 30))

# 1. 定义自定义异常类（继承 Exception）
class LoginError(Exception):
    """
    自定义登录异常类
    用于表达所有登录相关的业务错误（用户名不存在、密码错误、验证码过期等）
    """
    # pass 表示暂时无自定义逻辑，仅继承父类功能
    pass

# 2. 业务函数中抛出自定义异常
def login(username, password):
    """模拟登录校验"""
    # 模拟数据库中的正确账号密码
    valid_username = "admin"
    valid_password = "123456"
    
    # 校验失败时，主动抛出 LoginError
    if username != valid_username or password != valid_password:
        # raise + 异常类实例（括号内是错误提示信息）
        raise LoginError("用户名或密码错误")
    # 校验通过，返回登录成功
    return True

# 3. 捕获并处理自定义异常
try:
    # 调用登录函数（传入错误的账号密码）
    login("tom", "111")
except LoginError as e:
    # e 是异常实例，直接打印会输出错误提示信息
    print("登录失败：", e)  # 输出：登录失败：用户名或密码错误

class LoginError(Exception):
    """
    增强版登录异常类
    :param message: 错误提示信息
    :param error_code: 自定义错误码（如1001=用户名错，1002=密码错）
    :param detail: 错误详情（可选，如请求ID、时间戳）
    """
    def __init__(self, message, error_code, detail=None):
        # 调用父类 __init__ 方法，保证基础异常功能
        super().__init__(message)
        # 新增自定义属性
        self.error_code = error_code
        self.detail = detail

# 业务函数中按不同错误类型抛异常
def login(username, password):
    valid_username = "admin"
    valid_password = "123456"
    
    if username != valid_username:
        # 用户名错误：错误码1001，附带详情
        raise LoginError(
            message="用户名不存在",
            error_code=1001,
            detail=f"尝试登录的用户名：{username}"
        )
    if password != valid_password:
        # 密码错误：错误码1002
        raise LoginError(
            message="密码错误",
            error_code=1002,
            detail=f"用户名 {username} 输入了错误密码"
        )
    return True

# 捕获异常时，获取自定义属性
try:
    login("tom", "111")  # 用户名错误
except LoginError as e:
    print(f"登录失败：{e}")          # 输出：登录失败：用户名不存在
    print(f"错误码：{e.error_code}") # 输出：错误码：1001
    print(f"错误详情：{e.detail}")   # 输出：错误详情：尝试登录的用户名：tom

try:
    login("admin", "654321")  # 密码错误
except LoginError as e:
    print(f"登录失败：{e}")          # 输出：登录失败：密码错误
    print(f"错误码：{e.error_code}") # 输出：错误码：1002

BaseException（顶层）
├── Exception（业务异常的父类）
│   ├── ValueError/TypeError/IndexError（基础错误）
│   ├── FileNotFoundError/IOError（IO错误）
│   ├── 自定义异常（继承Exception）
├── KeyboardInterrupt（用户中断）
├── SystemExit（程序退出）

# 面向过程：拆解为独立步骤函数
def buy():
    """购买食材"""
    print("去超市购买食材。")

def wash():
    """清洗食材"""
    print("清洗蔬菜。")

def cut():
    """切菜"""
    print("切菜。")

def cook():
    """烹饪"""
    print("开始烹饪。")

def serve():
    """上菜"""
    print("上菜啦！")

# 按顺序执行步骤
buy()
wash()
cut()
cook()
serve()

"""
面向对象实现做饭功能：封装+继承+多态
"""
# 父类：菜品模板（抽象共性）
class Dish:
    def __init__(self, name):
        self.name = name  # 实例属性：菜品名称
    
    def prepare(self):
        """准备菜品（子类重写实现具体逻辑）"""
        pass

# 子类1：沙拉（继承Dish，重写prepare）
class Salad(Dish):
    def prepare(self):
        print(f"1. 为【{self.name}】购买蔬菜")
        print(f"2. 清洗【{self.name}】的蔬菜")
        print(f"3. 切【{self.name}】的蔬菜")
        print(f"4. 将【{self.name}】装盘")

# 子类2：炖肉（继承Dish，重写prepare）
class Stew(Dish):
    def prepare(self):
        print(f"1. 为【{self.name}】购买肉类")
        print(f"2. 清洗【{self.name}】的肉")
        print(f"3. 切【{self.name}】的肉")
        print(f"4. 烹饪【{self.name}】")
        print(f"5. 将【{self.name}】装盘")

# 子类3：汤品（继承Dish，重写prepare）
class Soup(Dish):
    def prepare(self):
        print(f"1. 为【{self.name}】购买食材")
        print(f"2. 煮【{self.name}】")

# 实例化并调用（多态：不同子类调用同一方法，表现不同行为）
salad = Salad("蔬菜沙拉")
stew = Stew("土豆炖肉")
soup = Soup("紫菜鸡蛋汤")

salad.prepare()
print()  # 空行分隔
stew.prepare()
print()
soup.prepare()

class 类名:  # 类名用大驼峰命名法（如 Person、Student）
    """类说明文档（可选）"""
    # 类体：类属性、方法、实例属性等

class Person:
    """人的类：演示类属性、实例属性、方法"""
    # 类属性（所有实例共享）
    home = "earth"

    # 初始化方法：创建对象时自动调用，初始化实例属性
    def __init__(self):
        self.age = 0  # 实例属性（每个实例独立）

    # 实例方法：操作实例数据
    def eat(self):
        print("eating...")

    def drink(self):
        print("drinking...")

# 访问类属性
print(Person.home)  # 输出：earth
# 访问类方法（返回函数对象）
print(Person.eat)   # 输出：<function Person.eat at 0x...>
# 访问类说明文档
print(Person.__doc__)  # 输出：人的类：演示类属性、实例属性、方法

# 实例化 Person 类
p = Person()

# 访问实例属性/类属性
print(p.age)   # 实例属性，输出：0
print(p.home)  # 类属性，输出：earth

# 调用实例方法
p.eat()   # 输出：eating...
p.drink() # 输出：drinking...

class Person:
    """人的类：带参数的构造方法"""
    def __init__(self, name, age):
        """
        构造方法：初始化姓名和年龄
        :param name: 姓名（字符串）
        :param age: 年龄（整数）
        """
        self.name = name  # 实例属性：姓名
        self.age = age    # 实例属性：年龄

    def print_info(self):
        """打印实例信息"""
        print(f"姓名：{self.name}，年龄：{self.age}")

# 实例化（传入构造方法参数）
person = Person("张三", 18)
person.print_info()  # 输出：姓名：张三，年龄：18

class Person:
    home = "earth"

    def __init__(self, name):
        self.name = name  # 实例属性

    def eat(self):
        print(f"{self.name} is eating...")

    def drink(self):
        print(f"{self.name} is drinking...")

    def eat_and_drink(self):
        # 内部调用实例方法（通过self）
        self.eat()
        self.drink()

# 实例化
p = Person("张三")

# 两种调用方式（效果一致）
p.eat()  # 推荐：自动传入self
Person.eat(p)  # 等效：手动传入实例对象

# 调用组合方法
p.eat_and_drink()

class Person:
    home = "earth"  # 类属性

# 访问类属性
print(Person.home)  # 输出：earth
p1 = Person()
p2 = Person()
print(p1.home, p2.home)  # 输出：earth earth

# 修改类属性（所有实例同步变化）
Person.home = "mars"
print(Person.home, p1.home, p2.home)  # 输出：mars mars mars

# 实例“修改”类属性（实际新增实例属性）
p1.home = "venus"
print(Person.home)  # 类属性不变：mars
print(p1.home)      # 实例属性：venus
print(p2.home)      # 其他实例仍用类属性：mars

class Person:
    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age    # 实例属性

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

# 访问实例属性
print(p1.name, p1.age)  # 输出：张三 18
print(p2.name, p2.age)  # 输出：李四 20

# 修改实例属性（互不影响）
p1.age = 19
print(p1.age)  # 输出：19
print(p2.age)  # 输出：20

# print(Person.name)  # 报错：类无法访问实例属性

class Person:
    home = "earth"  # 类属性

    def __init__(self, name):
        self.name = name  # 实例属性

    @classmethod
    def print_home(cls):
        """类方法：访问类属性"""
        print(f"家庭住址：{cls.home}")
        # print(self.name)  # 报错：类方法无法访问实例属性

# 调用类方法
Person.print_home()  # 推荐：输出“家庭住址：earth”
p = Person("张三")
p.print_home()       # 不推荐，但允许

class Person:
    home = "earth"  # 类属性

    def __init__(self, name):
        self.name = name  # 实例属性

    @classmethod
    def print_home(cls):
        print(f"家庭住址：{cls.home}")

    def eat(self):
        """实例方法：访问类属性+实例属性"""
        print(f"{self.name} is eating in {Person.home}")

    def print_info(self):
        """实例方法：调用其他方法"""
        self.eat()          # 调用实例方法
        Person.print_home() # 调用类方法

# 实例化并调用
p = Person("张三")
p.print_info()
# 等效调用：Person.print_info(p)

class Person:
    home = "earth"

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

    @staticmethod
    def say(word):
        """静态方法：无类/实例依赖"""
        print(f"说：{word}")
        # 不推荐：静态方法中访问类属性
        # print(Person.home)

# 调用静态方法
Person.say("hello")  # 推荐：输出“说：hello”
p = Person("张三")
p.say("hi")          # 允许：输出“说：hi”

class DemoClass:
    def __new__(cls, name):
        """1. 创建实例（第一个调用）"""
        print(f"调用 __new__ 创建 {cls.__name__} 实例")
        instance = super().__new__(cls)
        return instance

    def __init__(self, name):
        """2. 初始化实例"""
        print("调用 __init__ 初始化属性")
        self.name = name

    def __str__(self):
        """3. 调用 str(实例) 时执行"""
        return f"DemoClass: name={self.name}"

    def __del__(self):
        """4. 实例销毁时执行"""
        print(f"调用 __del__ 销毁 {self.name} 实例")

# 演示流程
obj = DemoClass("test")  # 触发 __new__ + __init__
print(str(obj))          # 触发 __str__
del obj                  # 触发 __del__（引用计数为0时）

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

# 动态添加类属性
Person.home = "earth"
# 动态添加类方法
@classmethod
def come_from(cls):
    print(f"I come from {cls.home}")
Person.come_from = come_from

# 验证
print(Person.home)      # 输出：earth
Person.come_from()      # 输出：I come from earth

import types

# 实例化
p1 = Person("张三")
# 动态添加实例属性
p1.age = 18
# 动态添加实例方法
def eat(self):
    print(f"{self.name} 在吃饭")
p1.eat = types.MethodType(eat, p1)

# 验证
print(p1.age)  # 输出：18
p1.eat()       # 输出：张三 在吃饭

class Person:
    __slots__ = ("name", "age")  # 仅允许添加这两个实例属性

p = Person()
p.name = "张三"  # 允许
p.age = 18       # 允许
# p.weight = 60  # 报错：weight 不在 __slots__ 中

"""
演示私有属性/方法的定义与访问规则
核心：双下划线成员会被名称改写，类外需通过 _类名__成员名 访问（不推荐）
"""
class Person:
    # 私有类属性：自动改写为 _Person__home
    __home = "earth"

    def __init__(self, name):
        self.__name = name  # 私有实例属性：_Person__name
        self.__age = 0      # 私有实例属性：_Person__age
        self._sex = "male"  # 单下划线：约定非公开，无强制限制

    # 私有方法：自动改写为 _Person__check_age
    def __check_age(self, age):
        print(f"检查年龄{age}的合法性...")
        if age < 0 or age > 100:
            raise ValueError("年龄超出0-100范围")

    # 公开接口：获取私有属性
    def get_name(self):
        return self.__name

    # 公开接口：设置私有属性（带校验逻辑）
    def set_age(self, age):
        self.__check_age(age)  # 类内可直接调用私有方法
        self.__age = age

    # 公开接口：获取私有属性
    def get_age(self):
        return self.__age

# 实例化测试
p = Person("张三")

# 1. 单下划线成员：可外部访问（仅为约定）
print(f"单下划线成员访问：p._sex = {p._sex}")  # 输出：male

# 2. 双下划线成员：直接访问报错，需通过改写后的名称（不推荐）
# print(p.__name)  # 报错：AttributeError
print(f"私有属性改写后访问：p._Person__name = {p._Person__name}")  # 输出：张三
print(f"通过公开接口访问：p.get_name() = {p.get_name()}")          # 推荐方式：输出张三

# 3. 私有方法/属性的合法操作
p.set_age(18)  # 通过公开接口设置私有属性（自动触发校验）
print(f"私有属性age：p.get_age() = {p.get_age()}")                # 输出：18
# p.__check_age(20)  # 报错：AttributeError
p._Person__check_age(20)  # 强制访问改写后的私有方法（不推荐）

"""
@property 核心场景：封装私有属性的读写逻辑
"""
class Person:
    def __init__(self, name=None):
        self.__name = name  # 私有属性

    # 1. 无返回值的属性方法（仅执行逻辑）
    @property
    def eat(self):
        print(f"{self.__name} is eating")

    # 2. getter方法：读取私有属性
    @property
    def name(self):
        return self.__name

    # 3. setter方法：修改私有属性（需与getter方法名一致）
    @name.setter
    def name(self, new_name):
        if not isinstance(new_name, str):
            raise TypeError("姓名必须是字符串")
        self.__name = new_name

# 测试
p = Person("张三")
p.eat  # 属性式调用：无需加()，输出“张三 is eating”
p.name = "李四"  # 调用setter方法，修改私有属性
print(p.name)    # 调用getter方法，输出“李四”

# 错误示例：递归调用（注释掉避免报错）
# @property
# def age(self):
#     return self.age  # 无限递归：self.age 会再次调用 @property 装饰的age方法

class 子类名(父类名):
    子类体  # 可新增属性/方法，或重写父类方法

"""
单继承核心：
1. 子类通过 super() 调用父类构造方法；
2. 子类无法直接访问父类私有成员（可改写名称访问，不推荐）；
"""
# 父类：通用的Person类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # 私有属性：_Person__age
        print("父类Person构造方法执行")

    def eat(self):
        print(f"{self.name} 吃东西....")

# 子类1：Student（继承Person，新增score属性）
class Student(Person):
    def __init__(self, name, age, score):
        # 调用父类构造方法（初始化name/__age）
        super().__init__(name, age)
        self.score = score  # 子类特有属性
        print("子类Student构造方法执行")

    def study(self):
        # 不推荐：通过改写名称访问父类私有属性
        print(f"{self.name} 学习，年龄：{self._Person__age}，分数：{self.score}")

# 子类2：Teacher（继承Person，新增title属性）
class Teacher(Person):
    def __init__(self, name, age, title):
        super().__init__(name, age)
        self.title = title  # 子类特有属性
        print("子类Teacher构造方法执行")

    def teach(self):
        print(f"{self.name} 老师，教授 {self.title}")

# 测试
s = Student("张三", 18, 90)
s.eat()   # 复用父类方法
s.study() # 子类特有方法

t = Teacher("王五", 28, "Python编程")
t.eat()   # 复用父类方法
t.teach() # 子类特有方法

"""
Mixin模式核心：
1. 每个Mixin类封装单一功能（如飞行、游泳），不单独实例化；
2. 主类通过多继承组合多个Mixin的功能，实现“能力复用”；
"""
# Mixin类1：飞行能力
class Flyable:
    def fly(self):
        print(f"{self.name} 正在飞行")

# Mixin类2：游泳能力
class Swimming:
    def swim(self):
        print(f"{self.name} 正在游泳")

# Mixin类3：行走能力
class Walkable:
    def walk(self):
        print(f"{self.name} 正在行走")

# 基础类：鸟类（提供核心属性）
class Bird:
    def __init__(self, name):
        self.name = name  # 所有Mixin类依赖的核心属性

    def make_sound(self):
        print(f"{self.name} 在鸣叫")

# 子类：鸭子（组合基础类+多个Mixin）
class Duck(Bird, Flyable, Swimming, Walkable):
    def __init__(self, name):
        super().__init__(name)  # 初始化基础类属性

    # 子类特有方法
    def catch_fish(self):
        print(f"{self.name} 正在抓鱼")

# 测试：鸭子拥有所有组合能力
duck = Duck("小黄鸭")
duck.fly()         # 来自Flyable
duck.swim()        # 来自Swimming
duck.walk()        # 来自Walkable
duck.make_sound()  # 来自Bird
duck.catch_fish()  # 子类特有

"""
子类复用/重写父类方法
核心：super() 自动适配继承关系，推荐优先使用
"""
class Person:
    def __init__(self, name):
        self.name = name
        print("父类构造方法执行")

    def __str__(self):
        return f"{self.name} 是一个人"

    def eat(self):
        print(f"{self.name} 吃东西....")

# 子类：Student
class Student(Person):
    # 重写父类构造方法
    def __init__(self, name, score):
        super().__init__(name)  # 复用父类构造方法
        self.score = score
        print("子类构造方法执行")

    # 复用父类方法
    def show(self):
        # 方式1：super()（推荐，适配多继承）
        super().eat()
        # 方式2：父类名.方法名（需手动传self）
        # Person.eat(self)

    # 重写父类__str__方法
    def __str__(self):
        # 复用父类__str__结果 + 子类扩展
        return super().__str__() + f"，也是学生，分数：{self.score}"

# 测试
s = Student("张三", 90)
s.show()       # 复用父类eat方法
print(s)       # 调用重写后的__str__：输出“张三是一个人，也是学生，分数：90”

"""
MRO核心演示：
1. 查看类的继承链；
2. super() 按MRO顺序调用父类方法；
"""
# 顶层父类：Animal
class Animal:
    def __init__(self, name, **kwargs):
        self.name = name
        print("Animal 构造方法执行")

    def eat(self):
        print("Animal 吃东西...")

# 父类1：Fish（继承Animal）
class Fish(Animal):
    def __init__(self, name=None, **kwargs):
        print("Fish 构造方法执行")
        super().__init__(name, **kwargs)  # 传递剩余参数给MRO下一个类

    def eat(self):
        print("Fish 吃东西...")
        super().eat()  # 调用MRO下一个类的eat方法

# 父类2：Person（继承Animal）
class Person(Animal):
    def __init__(self, name=None, gender=None, **kwargs):
        print("Person 构造方法执行")
        self.gender = gender
        super().__init__(name, **kwargs)

    def eat(self):
        print("Person 吃东西...")
        super().eat()

# 子类：美人鱼（多继承 Fish, Person）
class Mermaids(Fish, Person):
    def __init__(self, name, gender, age):
        print("Mermaids 子类构造方法执行")
        # 仅调用一次super()，MRO自动处理所有父类初始化
        super().__init__(name=name, gender=gender, age=age)

    def eat(self):
        print("Mermaids 吃东西...")
        super().eat()  # 按MRO调用Fish的eat

# 1. 查看MRO列表
print("Mermaids MRO:", Mermaids.__mro__)
# 输出：(Mermaids, Fish, Person, Animal, object)

# 2. 实例化测试（按MRO顺序执行构造方法）
m = Mermaids("小海燕", "女", 500)
# 输出顺序：Mermaids → Fish → Person → Animal

# 3. 调用eat方法（按MRO顺序执行）
m.eat()
# 输出：Mermaids吃东西... → Fish吃东西... → Person吃东西... → Animal吃东西...

"""
多态核心：
1. 父类定义统一接口（如go方法）；
2. 子类重写接口实现不同逻辑；
3. 外部调用时，仅需传入子类实例，自动执行对应逻辑；
"""
# 父类：定义统一接口
class Animal:
    def go(self):
        """所有动物的移动行为（父类统一接口）"""
        pass

# 子类1：狗（重写go方法）
class Dog(Animal):
    def go(self):
        print("狗：四条腿跑")

# 子类2：鱼（重写go方法）
class Fish(Animal):
    def go(self):
        print("鱼：在水里游")

# 子类3：鸟（重写go方法）
class Bird(Animal):
    def go(self):
        print("鸟：张开翅膀飞")

# 通用调用函数（无需关注具体子类）
def move(animal):
    """接收Animal子类实例，调用统一接口"""
    animal.go()

# 测试：传入不同子类，执行不同行为
dog = Dog()
fish = Fish()
bird = Bird()

move(dog)   # 输出：狗：四条腿跑
move(fish)  # 输出：鱼：在水里游
move(bird)  # 输出：鸟：张开翅膀飞

[
  {"name": "Tom", "phone": "13800000000"},
  {"name": "Jerry", "phone": "13900000000"}
]

import json

class ContactBook:
    """
    通讯录管理器类
    核心功能：加载/保存数据、新增/查询/列出/删除联系人
    """
    def __init__(self, file_path="contacts.json"):
        """
        初始化通讯录
        :param file_path: 数据文件路径，默认 contacts.json
        """
        self.file_path = file_path  # 数据文件路径
        self.contacts = []          # 内存中的联系人列表（list[dict]）

    def load(self):
        """
        从 JSON 文件加载联系人数据
        异常处理：文件不存在/JSON 格式错误时，初始化空列表
        :return: 联系人列表（list[dict]）
        """
        try:
            with open(self.file_path, "r", encoding="utf-8") as f:
                self.contacts = json.load(f)  # 反序列化 JSON 到列表
        except (FileNotFoundError, json.JSONDecodeError):
            # FileNotFoundError：首次运行无文件；JSONDecodeError：文件内容损坏/空文件
            self.contacts = []
        return self.contacts

    def save(self):
        """
        将内存中的联系人数据保存到 JSON 文件
        注意：ensure_ascii=False 支持中文，indent=2 格式化输出
        """
        with open(self.file_path, "w", encoding="utf-8") as f:
            json.dump(self.contacts, f, ensure_ascii=False, indent=2)

    def _validate_phone(self, phone):
        """
        私有方法：校验手机号格式（11位纯数字）
        :param phone: 待校验的手机号
        :raise ValueError: 格式不合法时抛出异常
        """
        if not (len(phone) == 11 and phone.isdigit()):
            raise ValueError("手机号必须是11位纯数字")

    def add(self, name, phone):
        """
        新增联系人（带参数校验）
        :param name: 联系人姓名（非空）
        :param phone: 联系人手机号（11位纯数字）
        :raise ValueError: 姓名/手机号为空、联系人已存在、手机号格式错误
        """
        # 基础非空校验
        if not name.strip():
            raise ValueError("联系人姓名不能为空")
        if not phone.strip():
            raise ValueError("联系人手机号不能为空")
        
        # 手机号格式校验
        self._validate_phone(phone.strip())
        
        # 重复校验（大小写不敏感）
        if self.find(name):
            raise ValueError(f"联系人【{name}】已存在，无法重复添加")
        
        # 新增联系人（去除首尾空格，保证数据整洁）
        self.contacts.append({
            "name": name.strip(),
            "phone": phone.strip()
        })

    def find(self, name):
        """
        查询联系人（大小写不敏感）
        :param name: 要查询的姓名（支持模糊匹配，如 tom → Tom）
        :return: 找到则返回联系人字典，未找到返回 None
        """
        target_name = name.strip().lower()  # 统一转为小写，实现大小写不敏感
        for contact in self.contacts:
            if contact["name"].lower() == target_name:
                return contact
        return None

    def remove(self, name):
        """
        删除联系人（大小写不敏感）
        :param name: 要删除的姓名
        :raise ValueError: 联系人不存在时抛出异常
        """
        contact = self.find(name)
        if not contact:
            raise ValueError(f"联系人【{name}】不存在，无法删除")
        self.contacts.remove(contact)

    def all(self):
        """
        获取所有联系人（返回列表副本，避免外部修改内部数据）
        :return: 联系人列表副本（list[dict]）
        """
        return list(self.contacts)

"""
通讯录交互入口
依赖 contact_book.py 中的 ContactBook 类
"""
from contact_book import ContactBook

def main():
    """主函数：演示通讯录基本操作"""
    # 1. 初始化通讯录并加载数据
    book = ContactBook("contacts.json")
    book.load()
    print("=== 初始化通讯录，加载已有数据 ===")
    print(f"当前联系人列表：{book.all()}\n")

    try:
        # 2. 新增联系人（带校验）
        book.add("Tom", "13800000000")
        book.add("Jerry", "13900000000")
        book.add("张三", "13712345678")  # 测试中文
        print("=== 新增联系人后 ===")
        print(f"当前联系人列表：{book.all()}\n")

        # 3. 查询联系人（大小写不敏感）
        print("=== 查询联系人 ===")
        print(f"查询 Tom：{book.find('tom')}")       # 小写匹配
        print(f"查询 李四：{book.find('李四')}\n")   # 未找到返回 None

        # 4. 删除联系人
        book.remove("Jerry")
        print("=== 删除 Jerry 后 ===")
        print(f"当前联系人列表：{book.all()}\n")

        # 5. 保存修改到文件
        book.save()
        print("=== 所有修改已保存到 contacts.json ===")

    except ValueError as e:
        # 捕获参数校验/业务逻辑异常，友好提示
        print(f"操作失败：{e}")

if __name__ == "__main__":
    main()

=== 初始化通讯录，加载已有数据 ===
当前联系人列表：[]

=== 新增联系人后 ===
当前联系人列表：[{'name': 'Tom', 'phone': '13800000000'}, {'name': 'Jerry', 'phone': '13900000000'}, {'name': '张三', 'phone': '13712345678'}]

=== 查询联系人 ===
查询 Tom：{'name': 'Tom', 'phone': '13800000000'}
查询 李四：None

=== 删除 Jerry 后 ===
当前联系人列表：[{'name': 'Tom', 'phone': '13800000000'}, {'name': '张三', 'phone': '13712345678'}]

=== 所有修改已保存到 contacts.json ===