【python - 代码框架 - 常用知识点】

1. init & _setup()

• __init__负责接收参数并做初步赋值；
• _setup() 负责在初步赋值基础上进行内部加工，得到最终可用的属性值；

class MyClass:
    def __init__(self, param1, param2="default"):
        # 1. 初步赋值（将用于 _setup 处理）
        self.param1 = str(param1)
        self.param2 = str(param2)
        
        # 2. 调用内部 setup，对 param1/param2 进行最终加工。【不能少】
        self._setup()   
        
    def _setup(self):
        """内部方法：在 __init__ 基础上进一步加工属性"""
        # 在已有值基础上追加字符
        self.param1 += "1"
        self.param2 += "2"
        # 注意：这里不返回值！只修改 self 的状态

    def public_method(self, arg1, arg2):  # 添加两个参数
        """公开方法：使用 _setup 处理后的最终属性值"""
        return self.param1 + self.param2 + str(arg1) + str(arg2)

    def close(self):
        print("所有的资源已经释放！！！")

    def __str__(self):
        return (f"MyClass(\n"
                f"  最终状态: param1={self.param1!r}, param2={self.param2!r}\n"
                f")")

# ===== 使用示例 =====
if __name__ == "__main__":
    # 创建对象：传入字符串 "hello" 和 "world"
    para_1 = "hello"
    para_2 = "world" 
    
    obj = MyClass(para_1)  # 在默认的情况下，可以只传递一个参数
    
    print("【对象初始化完成后的内部状态】")
    print(obj)
    
    print("\n【外部调用 public_method】")

    para_3 = "外部调用参数——1"
    para_4 = "外部调用参数——1"
    result = obj.public_method(para_3,para_4)
    print("结果:", result)  
    
    obj.close()
    
    
    
输出结果：
    
【对象初始化完成后的内部状态】
MyClass(
  最终状态: param1='hello1', param2='default2'  # 通过_setup进行了修改
)
【外部调用 public_method】
结果: hello1default2外部调用参数——1外部调用参数——1
所有的资源已经释放！！！

2. 继承-调用&重写父类方法

💡 设计精髓：
super()： 控制着是否调用父类
父类定义：“通用流程框架和规范”，子类填充： “具体实现行为”。
就像公司规定：所有员工都要打卡、开电脑、工作；但“工作内容”因岗位而异——开发写代码，销售打电话。实现了代码复用与行为多态的统一。

1. 【子类】super().init() → 让父类帮你做“所有员工都要做的事”（如登记姓名）。这些属性属于“员工”这一抽象概念，不是某个岗位特有，而是所有员工共有，因此由父类统一管理。
2. 【子类】init()→ 扩展子类特有属性。在父类基础上，再做“本岗位特有之事”（如设编程语言）。体现了“在通用基础上叠加特异性”的继承
3. do_work() 抽象方法 → 父类定义契约，子类实现行为。【父类通过 raise NotImplementedError 声明：“所有员工必须能工作”，但不规定具体怎么做。

子类通过重写，在父类授权的框架内，自主实现岗位专属行为。 super().init(name, employee_id)
这个指的是要继承父类的功能，姓名，ID，但不是子类特有。
通过 super().init() 复用共性，通过重写方法实现个性——父类搭台，子类唱戏。

from typing import Optional

class Employee:
    """员工基类（父类）—— 定义所有员工共有的属性和行为。"""

    def __init__(self, name: str, employee_id: str) -> None:
        """所有员工入职时都要登记姓名和工号。 """
        self.name = name
        self.employee_id = employee_id
        self.is_working = False
        print(f"📝 [{self.name}] 已入职，工号: {self.employee_id}")

    def clock_in(self) -> None:
        """通用上班打卡流程（父类提供基础逻辑）。"""
        print(f"⏰ [{self.name}] 打卡上班！")

        self.is_working = True  # 【重要，判断是否上班】
        # 所有员工上班第一件事：打开电脑（通用行为）
        self._turn_on_computer()

    def clock_out(self) -> None:
        """通用下班打卡流程。"""
        if self.is_working:
            print(f"🌙 [{self.name}] 下班打卡，今天辛苦了！")
            self.is_working = False
        else:
            print(f"⚠️ [{self.name}] 还没上班，不能下班！")

    def _turn_on_computer(self) -> None:
        """内部方法：所有员工上班都要开电脑（通用动作）。"""
        print(f"💻 [{self.name}] 上班第一件事，打开电脑，准备开始工作...")

    def do_work(self) -> None:
        """核心工作方法 —— 但每个岗位内容不同！父类只定义“必须有这个方法”，具体实现交给子类。
        """
        raise NotImplementedError("子类必须实现自己的 do_work 方法！")

class Developer(Employee):
    """开发工程师（子类）—— 继承自 Employee。重写 do_work，实现自己的工作内容。
    """

    def __init__(self, name: str, employee_id: str, programming_language: str) -> None:
        # 调用父类的 __init__，完成通用初始化（姓名、工号）
        super().__init__(name, employee_id)
        
        self.language = programming_language
        print(f"👨‍💻 [{self.name}] 是一名 {self.language} 开发工程师")

    def do_work(self) -> None:
        """✅ 重写父类的 do_work 方法！实现开发工程师特有的工作内容。
        """
        if not self.is_working:
            print(f"❌ [{self.name}] 还没打卡上班，不能工作！")
            return

        # 先调用父类的通用行为（可选）
        print("\n【重要！！】： 这里可以直接调用父类的 _turn_on_computer 方法:")
        super()._turn_on_computer()
        # 开始工作
        print(f"⌨️ [{self.name}] 正在用 {self.language} 写代码...")
        print(f"🚀 [{self.name}] 提交代码到 Git，完成今日任务！")

class Salesperson(Employee):
    """销售人员（子类）—— 也继承自 Employee。"""

    def __init__(self, name: str, employee_id: str, target: int) -> None:
        # 调用父类的 __init__，完成通用初始化（姓名、工号）
        super().__init__(name, employee_id)
        
        self.sales_target = target
        print(f"💼 [{self.name}] 本月销售目标：{self.sales_target} 万元")

    def do_work(self) -> None:
        """
        ✅ 重写父类的 do_work 方法！
        """
        if not self.is_working:
            print(f"❌ [{self.name}] 还没打卡上班，不能工作！")
            return

        print(f"📞 [{self.name}] 正在拨打客户电话...")
        print(f"📈 [{self.name}] 成功签约一单！离目标更近了")

    # # ✅ 重写父类的 clock_out 方法， 调用父类，并输出子类自己的内容
    # def clock_out(self) -> None:
    #     """销售人员下班时，先执行通用下班流程，再汇报销售情况。"""
    #     # 先调用父类的 clock_out（处理 is_working 等通用逻辑）
    #     super().clock_out() # 【控制着是否调用父类】
        
    #     # 如果成功下班（即原本在上班），才汇报
    #     if not self.is_working:  # 注意：父类已将 is_working 设为 False
    #         print(f"📊 [{self.name}] 向老板汇报：今日完成销售额 {self.sales_target} 万元！")

   # ✅ 完全重写 clock_out：不调用父类，只输出子类自己的内容
    def clock_out(self) -> None:
        """销售人员专属下班流程：不显示父类消息，只汇报销售"""
        if self.is_working:
            # 先设置状态为下班（保持状态一致性）
            self.is_working = False
            # 只输出销售汇报，不输出父类的“下班打卡”语句
            print(f"📊 [{self.name}] 向老板汇报：今日完成销售额 {self.sales_target} 万元！")
        else:
            print(f"⚠️ [{self.name}] 还没上班，不能下班汇报！")

# ==================== 使用示例：公司一天的工作流程 ====================

if __name__ == "__main__":
    print("🏢 公司早上 9:00，员工陆续上班...\n")

    # 创建不同岗位的员工
    dev = Developer("小李", "DEV001", "Python")
    dev.clock_in() # 继承父类的通用上班
    dev.do_work() # 执行开发工程师特有的工作内容
    print("\n继承父类的下班通用行为:")
    dev.clock_out()
    

    print("\n" + "="*50 + "\n")

    sales = Salesperson("小王", "SALE002", 50)
    # 上班打卡
    sales.clock_in()
    # 开始工作（各自执行不同的 do_work）
    sales.do_work()
    # 下班
    print("\n 不继承父类，使用自己专有的下班行为：")
    sales.clock_out()  # 不继承父类的下班，有属于自己的下班情况

输出结果：
🏢 公司早上 9:00，员工陆续上班…
📝 [小李] 已入职，工号: DEV001
👨‍💻 [小李] 是一名 Python 开发工程师
⏰ [小李] 打卡上班！
💻 [小李] 上班第一件事，打开电脑，准备开始工作…
【重要！！】： 这里可以直接调用父类的 _turn_on_computer 方法:
💻 [小李] 上班第一件事，打开电脑，准备开始工作…
⌨️ [小李] 正在用 Python 写代码…
🚀 [小李] 提交代码到 Git，完成今日任务！
继承父类的下班通用行为:
🌙 [小李] 下班打卡，今天辛苦了！
==================================================
📝 [小王] 已入职，工号: SALE002
💼 [小王] 本月销售目标：50 万元
⏰ [小王] 打卡上班！
💻 [小王] 上班第一件事，打开电脑，准备开始工作…
📞 [小王] 正在拨打客户电话…
📈 [小王] 成功签约一单！离目标更近了
不继承父类，使用自己专有的下班行为：
📊 [小王] 向老板汇报：今日完成销售额 50 万元！

3. python基础核心

3.1 变量与数据类型

# 基本类型
name: str = "小李"          # 字符串（带类型注解）
age: int = 25               # 整数
salary: float = 15000.5     # 浮点数
is_working: bool = True     # 布尔值

# 容器类型
skills: list = ["Python", "SQL", "Git"]        # 列表：可增删改 【有序、可变】
info: tuple = ("DEV001", "Backend")            # 元组：常用于固定结构 【有序、不可变】
profile: dict = {"name": "小李", "role": "Developer"}  # 字典：键值映射
unique_tags: set = {"Python", "OOP", "Python"}  # 集合：自动去重 → {"Python", "OOP"}【无序、不重复】

# 类型检查
print(type(skills))         # <class 'list'>

3.2 控制流

• if / elif / else：条件分支
• for：遍历序列（列表、字典、字符串等）
• while：条件循环
• break：跳出循环，continue：跳过本次循环

# while 循环（计数器）
count = 0
while count < 3:
    print(f"🔁 第 {count + 1} 次循环")
    count += 1

"""
🔁 第 1 次循环
🔁 第 2 次循环
🔁 第 3 次循环
"""


# break 和 continue
for i in range(5):
    if i == 2:
        continue  # 跳过 i=2
    if i == 4:
        break     # 在 i=4 前停止
    print(f"数字: {i}")  # 输出: 0, 1, 3

3.3 函数

def func_name(param: Type) -> ReturnType:
param: Type：表示参数 param 的预期类型是 Type
ReturnType： 表示函数返回值的类型是 ReturnType
字典 dict（或更具体的 dict[str, int]）
列表 list（或 list[str]）
元组 tuple（或 tuple[str, int]、tuple[str, …]）
集合 set
无返回值 None

from typing import Optional
【Optional[T]  等价于  Union[T, None]，表示“这个值要么是类型 T，要么是 None”】

def find_user(id: int) -> Optional[dict]:
    # 返回 dict 或 None
    ...   
exp：
def get_full_name(emp: dict) -> Optional[tuple[str, str]]:
    """
    从员工字典中提取 (first_name, last_name)
    如果缺少字段，返回 None
    """
    first = emp.get("first_name")
    last = emp.get("last_name")
    if first and last:
        return (str(first), str(last))
    return None
    
# 联合类型（多种可能）
def parse_value(s: str) -> int | float | str:  # 使用 | 表示联合类型
    ...
    
    
# 任何类型
from typing import Any
def debug(x: Any) -> None:
    print(x)

3.4 字符串操作

【日志、输出、处理文本必备】

#  去除空白字符 【.strip()】
text = "  Hello, World!  \n"
cleaned = text.strip()  # 去除首尾空白（包括换行）
print(f"Cleaned: '{cleaned}'")

# 输出 ：Cleaned: 'Hello, World!'

---------------------------------------------------------------

#  分割字符串（常用于解析日志行）【.split(" - ")】以 - 作为分割，转化为列表[str,str]。
log_line = "2024-06-01 10:30:45 - INFO - User login successful"
parts = log_line.split(" - ")
print("Log parts:", parts)

# 输出 ：Log parts: ['2024-06-01 10:30:45', 'INFO', 'User login successful']

---------------------------------------------------------------

# 替换子字符串. 【.replace】
error_msg = "Error: File not found"
fixed_msg = error_msg.replace("not found", "missing")

---------------------------------------------------------------

#  大小写转换
text = "Hello World"
print(text.upper())    # HELLO WORLD
print(text.lower())    # hello world

---------------------------------------------------------------

# 检查字符串内容
line = "DEBUG: Memory usage high"
if line.startswith("DEBUG"):      【前缀】
    print("This is a debug message")
if "high" in line:                【存在】
    print("Warning: high usage detected")

3.5 列表推导式 & 字典推导式

列表推导式：
[expression for item in iterable if condition]

logs = [
    "INFO: User login",
    "ERROR: DB timeout",
    "DEBUG: Cache hit",
    "ERROR: File missing"
]
errors = [log for log in logs if "ERROR" in log]
print(errors)  # ['ERROR: DB timeout', 'ERROR: File missing']

字典推导式：
{key_expr: value_expr for item in iterable if condition}

config = {
    "HOST": "localhost",
    "PORT": "5432",
    "DEBUG": "",        # 空值
    "SECRET": None,     # None 值
    "TIMEOUT": "30"
}
# 保留非空值
valid_config = {k: v for k, v in config.items() if v}
print(valid_config)  
# {'HOST': 'localhost', 'PORT': '5432', 'TIMEOUT': '30'}

3.6 异常处理

import logging

# 可选：配置日志（简单场景可省略，用 print 代替）
logging.basicConfig(level=logging.INFO)

def your_function():
    try:
        # 👇 在这里写可能出错的代码（尽量少！）
        risky_code()
        
    except SpecificException as e:          # ← 替换为具体异常类型
        # ✅ 可恢复错误：记录 + 默认处理
        logging.warning(f"可忽略错误: {e}")
        return default_value                # ← 返回默认值/空值/重试等
        
    except Exception as e:
        # ❗ 严重错误：记录完整堆栈 + 重新抛出
        logging.exception("严重错误")
        raise  # 让上层处理

3.7 日志代替 print

import logging

# 1️⃣ 配置日志（只需一次）
logging.basicConfig(
    level=logging.INFO,  # 显示 INFO 及以上级别的日志
    format='%(asctime)s - %(levelname)s - %(message)s'
)

# 2️⃣ 用 logging 代替 print
def divide(a, b):
    logging.info(f"开始计算: {a} / {b}")
    
    if b == 0:
        logging.error("错误：除数不能为零！")
        return None
    
    result = a / b
    
    logging.info(f"计算结果: {result}")
    return result

# 3️⃣ 测试
if __name__ == "__main__":
    divide(10, 2)   # 正常
    divide(10, 0)   # 错误
    
    
2024-06-01 12:00:00,123 - INFO - 开始计算: 10 / 2
2024-06-01 12:00:00,124 - INFO - 计算结果: 5.0
2024-06-01 12:00:00,125 - INFO - 开始计算: 10 / 0
2024-06-01 12:00:00,126 - ERROR - 错误：除数不能为零！

3.7 上下文管理器（with）

只要操作文件、锁、网络连接等资源，就用 with！
“”"
“w” 写入（覆盖） ✅ 会清空
“a” 追加（在末尾加） ❌ 保留原文
“”"

filename = "message.txt"

# 写入
with open(filename, "w", encoding="utf-8") as f:  
    f.write("今天天气真好！")

# 读取
with open(filename, "r", encoding="utf-8") as f:
    print(f.read())

4. 常用标准库

4.1 pathlib文件路径操作

from pathlib import Path

# 当前目录
here = Path(".")
project_root = Path(__file__).parent  # 当前脚本所在目录
print(project_root)

# 创建多层目录（如 logs/2024/06/）
log_dir = Path("logs/2024/06")
log_dir.mkdir(parents=True, exist_ok=True)  # 安全创建
log_dir = Path(__file__).parent  # 当前脚本所在目录
print(log_dir)


from pathlib import Path
# 定义文件路径
filename = Path("message.txt")
# 写入文件（自动处理编码）
filename.write_text("今天天气真好！", encoding="utf-8")
# 读取文件
content = filename.read_text(encoding="utf-8")
print(content)

# 追加写入
with filename.open("a", encoding="utf-8") as f:
    f.write("\n今天天气真好！")

4.2 json 读写 JSON 文件

json.loads() —— JSON 字符串【str】 → Python 对象【dict】
✅ 使用场景： - 解析 API 返回的 JSON 字符串
json.dumps() —— Python 对象 → JSON 字符串

# 【JSON 字符串 → Python 对象】
import json
# 一个 JSON 格式的字符串
json_str = '{"name": "Alice", "age": 30, "active": true}'
print(type(json_str)) # class 'str'>

# 解析为 Python 字典
data = json.loads(json_str)
print(data)          # {'name': 'Alice', 'age': 30, 'active': True}
print(type(data))    # <class 'dict'>

# 【Python 对象 → JSON 字符串】
import json

# Python 字典
user = {"name": "Bob", "age": 25, "scores": [90, 85, 95]}
print(type(user))  # <class 'dict'>

# 转为 JSON 字符串
json_str = json.dumps(user, ensure_ascii=False, indent=2)
print(json_str)
print(type(json_str)) # <class 'str'>

# 【JSON 字符串 → Python 对象】
class 'str'>
{'name': 'Alice', 'age': 30, 'active': True}
<class 'dict'>

------------------------------------------------------

# 【Python 对象 → JSON 字符串】
<class 'dict'>
{
  "name": "Bob",
  "age": 25,
  "scores": [
    90,
    85,
    95
  ]
}
<class 'str'>

4.3 datetime 处理日期时间

%Y：四位年（2024）
%m：月（01-12）
%d：日（01-31）
%H：小时（00-23）
%M：分钟（00-59）
%S：秒（00-59）

from datetime import datetime

# 当前本地时间
now = datetime.now()
print(now)  # 2024-06-01 14:30:45.123456

# 常见格式
print(now.strftime("%Y-%m-%d %H:%M:%S"))      # 2024-06-01 14:30:45
print(now.strftime("%Y年%m月%d日"))           # 2024年06月01日
print(now.strftime("%Y%m%d"))                 # 20240601 （日志/文件名常用）
print(now.strftime("%A, %B %d, %Y"))          # Saturday, June 01, 2024

4.4 re 正则表达式（文本匹配）

数字 \d+，
单词 \w+，
开头 ^，
结尾 $，
分组 () 提数据，
原始字符串 r"" 别忘记！

import re
log = "2024-06-01T10:30:45 ERROR Database connection failed"
match = re.search(r'(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})\s+(\w+)\s+(.+)', log)
if match:
    date, time, level, msg = match.groups()
    print(f"Date: {date}, Time: {time}, Level: {level}, Message: {msg}")

# 输出  
Date: 2024-06-01, Time: 10:30:45, Level: ERROR, Message: Database connection failed

正则表达式片段	含义说明	是否捕获	备注
(\d{4}-\d{2}-\d{2})	匹配日期格式（如 2024-05-20）	✅ 是（第 1 个捕获组）	\d{4} 匹配年份，\d{2} 匹配月和日，整体用括号捕获
T	匹配字母 T	❌ 否	仅用于匹配，未用括号包裹，不捕获
\s+	匹配一个或多个空白字符（空格、制表符等）	❌ 否	用于跳过字段间的空白，如时间与日志级别之间的空格
\w+	匹配一个或多个字母、数字或下划线	❌ 否	通常用于匹配日志级别（如 ERROR），未捕获
(.+)	匹配剩余任意字符（除换行符）一次或多次	✅ 是（第 2 个捕获组）	用于捕获日志消息内容