Python高阶语法完全教程01

📘 Python高阶语法完全教程

适用人群：已掌握Python基础，希望进阶到工程化、高并发、底层原理级别的开发者

模块一：面向对象入门

1.1 面向过程 vs 面向对象

对比维度 面向过程 面向对象
核心 函数（做什么） 对象（谁来做）
数据与操作 分离 封装在一起
代码复用 函数调用 继承+组合
扩展性 差 好 
# 面向过程风格
def add_student(students, name):
    students.append(name)

# 面向对象风格
class StudentManager:
    def __init__(self):
        self.students = []
    def add(self, name):
        self.students.append(name)

1.2 类与对象

  • 类：蓝图/模板
  • 对象：根据类创建的实例
class Dog:
    # 类属性（所有实例共享）
    species = "Canis familiaris"
    
    # 构造方法（初始化实例）
    def __init__(self, name, age):
        self.name = name    # 实例属性
        self.age = age
    
    # 实例方法
    def bark(self):
        return f"{self.name} says Woof!"
    
    # 魔法方法：字符串表示
    def __str__(self):
        return f"Dog({self.name}, {self.age})"
    
    # 魔法方法：开发者友好的表示
    def __repr__(self):
        return f"Dog('{self.name}', {self.age})"

# 创建对象
dog1 = Dog("旺财", 3)
print(dog1)          # Dog(旺财, 3)
print(dog1.bark())   # 旺财 says Woof!

1.3 常用魔法方法

魔法方法 触发时机
__init__ 对象创建时
__str__ print(obj) 或 str(obj)
__repr__ 交互式环境直接输入对象
__call__ 对象像函数一样调用 obj()
__len__ len(obj)
__getitem__ obj[key]
__setitem__ obj[key] = value 
class Student:
    def __init__(self, name, scores):
        self.name = name
        self.scores = scores
    
    def __call__(self, *args):
        print(f"调用学生 {self.name}，参数：{args}")
    
    def __len__(self):
        return len(self.scores)
    
    def __getitem__(self, index):
        return self.scores[index]

stu = Student("小明", [90, 85, 88])
print(len(stu))      # 3
print(stu[1])        # 85
stu(1, 2, 3)         # 调用学生 小明，参数：(1, 2, 3)

🎯 实战案例：学生信息管理系统（入门版）

class Student:
    def __init__(self, sid, name, age):
        self.sid = sid
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"{self.sid}\t{self.name}\t{self.age}"

class StudentSystem:
    def __init__(self):
        self.students = []
        self._id_counter = 1
    
    def add(self, name, age):
        stu = Student(self._id_counter, name, age)
        self.students.append(stu)
        self._id_counter += 1
        print(f"添加成功：{stu}")
    
    def delete(self, sid):
        for i, stu in enumerate(self.students):
            if stu.sid == sid:
                del self.students[i]
                print(f"删除学号 {sid} 成功")
                return
        print("未找到该学号")
    
    def find(self, sid):
        for stu in self.students:
            if stu.sid == sid:
                return stu
        return None
    
    def list_all(self):
        print("学号\t姓名\t年龄")
        print("-" * 30)
        for stu in self.students:
            print(stu)

# 测试
system = StudentSystem()
system.add("张三", 20)
system.add("李四", 21)
system.list_all()

模块二：面向对象进阶

2.1 继承

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        raise NotImplementedError("子类必须实现 speak()")

class Dog(Animal):
    def speak(self):
        return f"{self.name}汪汪叫"
    
    def wag_tail(self):
        return "摇尾巴"

class Cat(Animal):
    def speak(self):
        return f"{self.name}喵喵叫"

# 多继承
class Flyable:
    def fly(self):
        return "飞起来了"

class Bird(Animal, Flyable):
    def speak(self):
        return "叽叽喳喳"

# super() 调用父类
class Person:
    def __init__(self, name):
        self.name = name

class Student(Person):
    def __init__(self, name, grade):
        super().__init__(name)  # 调用父类构造
        self.grade = grade

2.2 私有权限

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner          # 公开
        self._bank = "ICBC"         # 受保护（约定）
        self.__balance = balance    # 私有（名称重整）
    
    def get_balance(self):
        """提供安全的访问方式"""
        return self.__balance
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return True
        return False
    
    # property 装饰器：将方法变成属性访问
    @property
    def balance(self):
        return self.__balance

acc = BankAccount("张三", 1000)
# print(acc.__balance)  # 报错：AttributeError
print(acc.get_balance()) # 1000
print(acc.balance)       # 1000（通过property）

2.3 类属性 vs 对象属性

class Counter:
    count = 0  # 类属性，所有实例共享
    
    def __init__(self):
        Counter.count += 1
        self.instance_id = Counter.count  # 对象属性

c1 = Counter()
c2 = Counter()
print(Counter.count)  # 2
print(c1.instance_id) # 1
print(c2.instance_id) # 2

2.4 类方法与静态方法

class DateUtil:
    @classmethod
    def from_string(cls, date_str):
        """类方法：创建类的实例"""
        year, month, day = map(int, date_str.split('-'))
        return cls(year, month, day)
    
    @staticmethod
    def is_valid(date_str):
        """静态方法：工具函数，不需要类或实例"""
        try:
            year, month, day = map(int, date_str.split('-'))
            return 1 <= month <= 12 and 1 <= day <= 31
        except:
            return False

class MyDate(DateUtil):
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

# 使用类方法创建对象
d = MyDate.from_string("2026-07-17")
print(d.year)  # 2026

# 使用静态方法
print(DateUtil.is_valid("2026-13-01"))  # False

🎯 实战案例：学生管理系统（进阶版）

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"{self.name}({self.age}岁)"

class Student(Person):
    _total_students = 0  # 类属性：总人数
    
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.__grade = grade  # 私有
        Student._total_students += 1
        self.sid = Student._total_students
    
    @property
    def grade(self):
        return self.__grade
    
    @grade.setter
    def grade(self, value):
        if 0 <= value <= 100:
            self.__grade = value
        else:
            raise ValueError("成绩必须在0-100之间")
    
    @classmethod
    def get_total(cls):
        return cls._total_students
    
    @staticmethod
    def is_valid_name(name):
        return len(name) >= 2
    
    def __str__(self):
        return f"学号:{self.sid} {self.name} 成绩:{self.__grade}"

# 测试
stu1 = Student("张三", 18, 90)
stu2 = Student("李四", 19, 85)
print(Student.get_total())  # 2
print(stu1.grade)           # 90
stu1.grade = 95
print(stu1)

模块三：闭包 + 装饰器

3.1 深拷贝 vs 浅拷贝

import copy

# 浅拷贝：只拷贝外层，内层共享
original = [[1, 2], [3, 4]]
shallow = copy.copy(original)
deep = copy.deepcopy(original)

original[0][0] = 99
print(shallow[0][0])  # 99（浅拷贝受影响）
print(deep[0][0])     # 1（深拷贝不受影响）

# 自定义对象的拷贝
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(1, 2)
p_copy = copy.copy(p)  # 对于简单对象，浅拷贝足够

3.2 闭包详解

闭包三要素：

  1. 嵌套函数
  2. 内部函数引用外部变量
  3. 外部函数返回内部函数
def make_counter():
    count = 0  # 自由变量
    
    def counter():
        nonlocal count  # 声明修改外部变量
        count += 1
        return count
    
    return counter

# 创建两个独立的计数器
c1 = make_counter()
c2 = make_counter()

print(c1())  # 1
print(c1())  # 2
print(c2())  # 1（独立状态）

# 闭包存储的数据
print(c1.__closure__[0].cell_contents)  # 2

3.3 装饰器详解

基础装饰器

def timer(func):
    """计算函数执行时间"""
    import time
    from functools import wraps
    
    @wraps(func)  # 保留原函数元数据
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__} 耗时: {end - start:.4f}秒")
        return result
    return wrapper

@timer
def slow_function():
    import time
    time.sleep(1)
    return "完成"

slow_function()

带参数的装饰器

def retry(max_retries=3, delay=1):
    """重试装饰器"""
    import time
    
    def decorator(func):
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_retries - 1:
                        raise
                    print(f"第{attempt+1}次失败，{delay}秒后重试...")
                    time.sleep(delay)
        return wrapper
    return decorator

@retry(max_retries=5, delay=0.5)
def unstable_network_call():
    import random
    if random.random() < 0.7:
        raise ConnectionError("网络超时")
    return "成功"

类装饰器

class Logged:
    def __init__(self, func):
        self.func = func
    
    def __call__(self, *args, **kwargs):
        print(f"调用 {self.func.__name__}，参数: {args}")
        return self.func(*args, **kwargs)

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

add(3, 5)  # 调用 add，参数: (3, 5)

🎯 实战案例：综合装饰器系统

import time
import functools
from datetime import datetime

class Logger:
    """日志装饰器系统"""
    
    @staticmethod
    def log(level="INFO"):
        def decorator(func):
            @functools.wraps(func)
            def wrapper(*args, **kwargs):
                timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                print(f"[{timestamp}] [{level}] 执行 {func.__name__}")
                try:
                    result = func(*args, **kwargs)
                    print(f"[{timestamp}] [{level}] {func.__name__} 执行成功")
                    return result
                except Exception as e:
                    print(f"[{timestamp}] [ERROR] {func.__name__} 异常: {e}")
                    raise
            return wrapper
        return decorator
    
    @staticmethod
    def cache(func):
        """缓存装饰器（LRU思想）"""
        cache_data = {}
        
        @functools.wraps(func)
        def wrapper(*args):
            if args in cache_data:
                print(f"从缓存命中: {args}")
                return cache_data[args]
            result = func(*args)
            cache_data[args] = result
            return result
        return wrapper

# 使用示例
@Logger.log(level="DEBUG")
def complex_calc(x, y):
    time.sleep(0.5)
    return x ** y

@Logger.cache
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

complex_calc(2, 10)
print(fibonacci(35))  # 第二次调用会很快

模块四：网络编程 + 多进程

4.1 网络编程基础（Socket）

TCP 服务器端

import socket
import threading

def handle_client(conn, addr):
    print(f"客户端 {addr} 连接")
    while True:
        data = conn.recv(1024)
        if not data:
            break
        conn.sendall(data.upper())  # 回显大写
    conn.close()
    print(f"客户端 {addr} 断开")

def start_server(host='127.0.0.1', port=8888):
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server.bind((host, port))
    server.listen(5)
    print(f"服务器启动在 {host}:{port}")
    
    while True:
        conn, addr = server.accept()
        thread = threading.Thread(target=handle_client, args=(conn, addr))
        thread.start()

# start_server()

TCP 客户端

import socket

def start_client(host='127.0.0.1', port=8888):
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect((host, port))
    
    try:
        while True:
            msg = input("请输入消息 (输入 'quit' 退出): ")
            if msg.lower() == 'quit':
                break
            client.sendall(msg.encode('utf-8'))
            response = client.recv(1024)
            print(f"服务器回复: {response.decode('utf-8')}")
    finally:
        client.close()

# start_client()

4.2 并行 vs 并发

概念 含义 适用场景
并发 宏观同时，微观交替（单核） I/O密集型
并行 真正同时执行（多核） CPU密集型

4.3 多进程

from multiprocessing import Process, Pool, Queue, Manager
import os
import time

# 基础多进程
def worker(name):
    print(f"进程 {name}，PID: {os.getpid()}")
    time.sleep(1)
    return f"{name}完成"

if __name__ == "__main__":
    processes = []
    for i in range(4):
        p = Process(target=worker, args=(i,))
        p.start()
        processes.append(p)
    
    for p in processes:
        p.join()
    print("所有进程完成")

进程池

def cpu_intensive(n):
    """CPU密集型任务"""
    total = 0
    for i in range(n):
        total += i ** 2
    return total

if __name__ == "__main__":
    # 使用进程池
    with Pool(processes=4) as pool:
        results = pool.map(cpu_intensive, [10**7, 10**7, 10**7, 10**7])
        print(results)

进程间通信（Queue）

def producer(queue):
    for i in range(5):
        queue.put(f"数据{i}")
        print(f"生产: 数据{i}")
        time.sleep(0.5)

def consumer(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print(f"消费: {item}")
        time.sleep(1)

if __name__ == "__main__":
    q = Queue()
    p1 = Process(target=producer, args=(q,))
    p2 = Process(target=consumer, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    q.put(None)  # 结束信号
    p2.join()

🎯 实战案例：文件传输系统

# server.py - 文件接收端
import socket
import os
import struct

def receive_file(conn, save_path):
    """接收文件"""
    # 接收文件名长度
    name_len = struct.unpack('I', conn.recv(4))[0]
    # 接收文件名
    filename = conn.recv(name_len).decode('utf-8')
    # 接收文件大小
    file_size = struct.unpack('Q', conn.recv(8))[0]
    
    save_file = os.path.join(save_path, filename)
    received = 0
    
    with open(save_file, 'wb') as f:
        while received < file_size:
            data = conn.recv(4096)
            if not data:
                break
            f.write(data)
            received += len(data)
            progress = (received / file_size) * 100
            print(f"\r接收进度: {progress:.2f}%", end='')
    
    print(f"\n文件 {filename} 接收完成")
    return save_file

def start_server():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind(('127.0.0.1', 9999))
    server.listen(1)
    print("文件服务器启动，等待连接...")
    
    conn, addr = server.accept()
    print(f"客户端 {addr} 已连接")
    receive_file(conn, './downloads')
    conn.close()
    server.close()

# client.py - 文件发送端
def send_file(file_path, host='127.0.0.1', port=9999):
    if not os.path.exists(file_path):
        print("文件不存在")
        return
    
    filename = os.path.basename(file_path)
    file_size = os.path.getsize(file_path)
    
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect((host, port))
    
    # 发送文件名长度和文件名
    name_bytes = filename.encode('utf-8')
    client.send(struct.pack('I', len(name_bytes)))
    client.send(name_bytes)
    
    # 发送文件大小
    client.send(struct.pack('Q', file_size))
    
    # 发送文件内容
    with open(file_path, 'rb') as f:
        sent = 0
        while sent < file_size:
            data = f.read(4096)
            client.send(data)
            sent += len(data)
            progress = (sent / file_size) * 100
            print(f"\r发送进度: {progress:.2f}%", end='')
    
    print("\n文件发送完成")
    client.close()

模块五：多线程详解

5.1 多线程基础

import threading
import time

def task(name, delay):
    print(f"线程 {name} 开始")
    time.sleep(delay)
    print(f"线程 {name} 结束")

# 创建线程
threads = []
for i in range(3):
    t = threading.Thread(target=task, args=(f"T{i}", i+1))
    threads.append(t)
    t.start()

# 等待所有线程完成
for t in threads:
    t.join()
print("所有线程完成")

5.2 守护线程

def background_task():
    while True:
        print("后台任务运行中...")
        time.sleep(1)

# 主线程结束时，守护线程自动退出
t = threading.Thread(target=background_task, daemon=True)
t.start()
time.sleep(3)
print("主线程结束，守护线程被强制终止")

5.3 互斥锁详解

import threading

class Counter:
    def __init__(self):
        self.value = 0
        self.lock = threading.Lock()
    
    def increment(self):
        with self.lock:  # 自动获取和释放锁
            current = self.value
            # 模拟耗时操作
            time.sleep(0.0001)
            self.value = current + 1
    
    def increment_manual(self):
        self.lock.acquire()
        try:
            self.value += 1
        finally:
            self.lock.release()

counter = Counter()
threads = []

for _ in range(100):
    t = threading.Thread(target=counter.increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"最终值: {counter.value}")  # 正确值应为100

5.4 线程同步

import threading
import time

# Event：线程间信号传递
def waiter(event):
    print("等待事件...")
    event.wait()
    print("事件触发，继续执行")

def setter(event):
    time.sleep(2)
    print("触发事件")
    event.set()

event = threading.Event()
threading.Thread(target=waiter, args=(event,)).start()
threading.Thread(target=setter, args=(event,)).start()

# Condition：更复杂的同步
class BoundedBuffer:
    def __init__(self, capacity):
        self.buffer = []
        self.capacity = capacity
        self.cond = threading.Condition()
    
    def put(self, item):
        with self.cond:
            while len(self.buffer) >= self.capacity:
                self.cond.wait()
            self.buffer.append(item)
            self.cond.notify()
    
    def get(self):
        with self.cond:
            while len(self.buffer) == 0:
                self.cond.wait()
            item = self.buffer.pop(0)
            self.cond.notify()
            return item

5.5 上下文管理器

# 自定义上下文管理器（类方式）
class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None
    
    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            self.file.close()
        if exc_type:
            print(f"异常: {exc_val}")
        return True  # 抑制异常

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

@contextmanager
def timer(name):
    import time
    start = time.perf_counter()
    try:
        yield
    finally:
        end = time.perf_counter()
        print(f"{name} 耗时: {end - start:.4f}秒")

# 使用
with FileManager('test.txt', 'w') as f:
    f.write('Hello, World!')

with timer("计算"):
    sum(range(10**7))

🎯 实战案例：JSON数据批量处理

import json
import threading
import time
from queue import Queue

class JSONProcessor:
    def __init__(self, num_workers=4):
        self.input_queue = Queue()
        self.output_queue = Queue()
        self.num_workers = num_workers
        self.results = []
    
    def worker(self):
        """工作线程：从输入队列取数据，处理后放入输出队列"""
        while True:
            item = self.input_queue.get()
            if item is None:  # 终止信号
                self.input_queue.task_done()
                break
            
            try:
                # 模拟JSON处理
                processed = self._process_json(item)
                self.output_queue.put(processed)
            except Exception as e:
                print(f"处理失败: {e}")
            finally:
                self.input_queue.task_done()
    
    def _process_json(self, data):
        """处理单个JSON数据"""
        # 示例：给每个用户增加一个processed字段
        if isinstance(data, dict):
            data['processed'] = True
            data['processed_at'] = time.time()
            # 模拟耗时操作
            time.sleep(0.01)
        return data
    
    def process_batch(self, json_list):
        """批量处理JSON数据"""
        # 启动工作线程
        workers = []
        for _ in range(self.num_workers):
            t = threading.Thread(target=self.worker)
            t.start()
            workers.append(t)
        
        # 放入任务
        for item in json_list:
            self.input_queue.put(item)
        
        # 发送终止信号
        for _ in range(self.num_workers):
            self.input_queue.put(None)
        
        # 等待所有任务完成
        self.input_queue.join()
        
        # 收集结果
        results = []
        while not self.output_queue.empty():
            results.append(self.output_queue.get())
        
        # 等待所有线程结束
        for t in workers:
            t.join()
        
        return results

# 示例数据
sample_data = [
    {"id": i, "name": f"user_{i}", "score": i * 10}
    for i in range(100)
]

processor = JSONProcessor(num_workers=8)
start = time.time()
results = processor.process_batch(sample_data)
print(f"处理完成，共 {len(results)} 条数据")
print(f"耗时: {time.time() - start:.2f}秒")
print(f"样例结果: {results[0]}")

模块六：生成器 / 迭代器 / 正则

6.1 迭代器

# 可迭代对象 vs 迭代器
from collections.abc import Iterator, Iterable

# 自定义迭代器
class Fibonacci:
    def __init__(self, max_count):
        self.max_count = max_count
        self.count = 0
        self.a, self.b = 0, 1
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.count >= self.max_count:
            raise StopIteration
        self.count += 1
        if self.count == 1:
            return 0
        if self.count == 2:
            return 1
        result = self.a + self.b
        self.a, self.b = self.b, result
        return result

fib = Fibonacci(10)
print(list(fib))  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

6.2 生成器

# 生成器函数（使用 yield）
def fibonacci_generator(max_count):
    count = 0
    a, b = 0, 1
    while count < max_count:
        if count == 0:
            yield 0
        elif count == 1:
            yield 1
        else:
            yield a + b
            a, b = b, a + b
        count += 1

# 生成器表达式
squares = (x**2 for x in range(10**6))  # 惰性求值

# 生成器的 send() 方法
def coroutine():
    value = yield "开始"
    while True:
        value = yield f"收到: {value}"

gen = coroutine()
print(next(gen))      # 开始
print(gen.send(10))   # 收到: 10
print(gen.send(20))   # 收到: 20

6.3 正则表达式详解

import re

text = """
联系方式：
张三: zhangsan@email.com, 电话: 138-1234-5678
李四: lisi@mail.com, 电话: 15987654321
网址: https://www.example.com/path?query=1
日期: 2026-07-17, 2026/07/17
IP地址: 192.168.1.1
"""

# 1. 常用方法
print(re.search(r'\d{3}-\d{4}-\d{4}', text))  # 查找第一个
print(re.findall(r'\w+@\w+\.\w+', text))      # 查找所有
print(re.split(r'\s+', text))                 # 分割

# 2. 分组
pattern = re.compile(r'(\d{4})-(\d{2})-(\d{2})')
match = pattern.search(text)
if match:
    print(f"年: {match.group(1)}, 月: {match.group(2)}, 日: {match.group(3)}")

# 3. 命名分组
pattern = re.compile(r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})')
match = pattern.search(text)
if match:
    print(match.groupdict())  # {'year': '2026', 'month': '07', 'day': '17'}

# 4. 替换
cleaned = re.sub(r'\d{3}-\d{4}-\d{4}', '[电话已隐藏]', text)
print(cleaned)

# 5. 预编译（性能优化）
phone_pattern = re.compile(r'1[3-9]\d{9}')  # 手机号
print(phone_pattern.findall(text))

🎯 实战案例：日志分析器

import re
from collections import Counter
from datetime import datetime

class LogAnalyzer:
    def __init__(self):
        # 常用日志正则
        self.patterns = {
            'ip': re.compile(r'\b(?:\d{1,3}\.){3}\d{1,3}\b'),
            'timestamp': re.compile(r'\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}'),
            'level': re.compile(r'\[(DEBUG|INFO|WARNING|ERROR|CRITICAL)\]'),
            'email': re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'),
            'url': re.compile(r'https?://[^\s]+'),
            'status_code': re.compile(r'\s(200|201|301|302|400|401|403|404|500)\s'),
        }
    
    def analyze_log(self, log_content):
        """分析日志内容"""
        results = {
            'ips': Counter(),
            'levels': Counter(),
            'emails': [],
            'urls': [],
            'status_codes': Counter(),
        }
        
        for line in log_content.split('\n'):
            # 提取IP
            ips = self.patterns['ip'].findall(line)
            for ip in ips:
                results['ips'][ip] += 1
            
            # 提取日志级别
            level_match = self.patterns['level'].search(line)
            if level_match:
                results['levels'][level_match.group(1)] += 1
            
            # 提取邮箱
            emails = self.patterns['email'].findall(line)
            results['emails'].extend(emails)
            
            # 提取URL
            urls = self.patterns['url'].findall(line)
            results['urls'].extend(urls)
            
            # 提取状态码
            status = self.patterns['status_code'].search(line)
            if status:
                results['status_codes'][status.group(1)] += 1
        
        return results
    
    def generate_report(self, results):
        """生成分析报告"""
        report = []
        report.append("=" * 50)
        report.append("日志分析报告")
        report.append("=" * 50)
        
        report.append("\n📊 IP访问统计（Top 10）:")
        for ip, count in results['ips'].most_common(10):
            report.append(f"  {ip}: {count}次")
        
        report.append("\n📊 日志级别统计:")
        for level, count in results['levels'].items():
            report.append(f"  {level}: {count}条")
        
        report.append(f"\n📧 发现的邮箱: {results['emails']}")
        report.append(f"\n🔗 发现的URL: {results['urls'][:5]}")
        
        report.append("\n📊 状态码统计:")
        for code, count in results['status_codes'].items():
            report.append(f"  {code}: {count}次")
        
        return '\n'.join(report)

# 使用示例
log_sample = """
2026-07-17 10:23:45 [INFO] 192.168.1.100 - 用户 admin@example.com 登录成功
2026-07-17 10:24:12 [ERROR] 10.0.0.5 - 请求失败 404 /api/data
2026-07-17 10:25:01 [WARNING] 192.168.1.101 - 访问 https://example.com 被限流
2026-07-17 10:26:33 [INFO] 172.16.0.10 - 用户 test@gmail.com 执行操作
2026-07-17 10:27:55 [ERROR] 192.168.1.100 - 数据库连接超时 500
"""

analyzer = LogAnalyzer()
results = analyzer.analyze_log(log_sample)
report = analyzer.generate_report(results)
print(report)

📚 总结与进阶建议

知识体系图

Python高阶语法
├── 面向对象（代码组织）
│   ├── 三大特性：封装、继承、多态
│   └── 设计模式基础（单例、工厂等）
├── 函数式编程（代码复用）
│   ├── 闭包 + 装饰器
│   └── 高阶函数（map/filter/reduce）
├── 并发编程（性能提升）
│   ├── 多进程（CPU密集）
│   ├── 多线程（I/O密集）
│   └── 协程（异步I/O）
└── 数据处理（工具技能）
    ├── 正则表达式
    └── 生成器/迭代器

下一步学习方向

  1. 异步编程：asyncio、aiohttp
  2. 设计模式：单例、工厂、观察者等
  3. 性能优化：cProfile、line_profiler
  4. 并发框架：concurrent.futures、Celery
  5. 数据处理：pandas、numpy（结合生成器）

这份教程涵盖了所有大纲知识点，并提供了完整可运行的示例代码。建议你按照模块顺序学习，每个实战案例都要亲手敲一遍并理解其原理。如果有任何模块需要我展开讲解或补充更多示例，随时告诉我！

posted @ 2026-07-17 20:01  yuangu  阅读(2)  评论(0)    收藏  举报