import copy

a = [[1, 2], [3, 4]]

b = copy.copy(a)        # 浅拷贝

print(a is b)           # False（外层容器不同）

print(a[0] is b[0])     # True！（内层子对象相同）

# 修改内层子对象会影响双方

a[0][0] = 999

print(b[0][0])          # 999（b也受到影响！）

a = [[1, 2], [3, 4]]

c = copy.deepcopy(a)    # 深拷贝

print(a is c)           # False

print(a[0] is c[0])     # False（内层子对象也不同！）

a[0][0] = 999

print(c[0][0])          # 1（c不受影响）

import gc

print(gc.get_threshold())  # 默认 (700, 10, 10)

gc.set_threshold(1000, 10, 5)  # 自定义阈值

gc.collect()               # 手动触发垃圾回收

import sys

a = [1, 2, 3]           # 引用计数 = 1

b = a                   # 引用计数 = 2

del b                   # 引用计数 = 1

c = {'key': a}          # 引用计数 = 2

del c['key']            # 引用计数 = 1

del a                   # 引用计数 = 0 → 对象被销毁

class Node:

def __init__(self, value):

self.value = value

self.next = None

node1 = Node(1)

node2 = Node(2)

node1.next = node2

node2.next = node1    # 循环引用！

del node1

del node2

# 此时两个对象的引用计数都不为0（互相引用）

# — 只能由垃圾回收器的标记-清除机制处理

# 1. 手动断开

node1.next = None

node2.next = None

# 2. 使用弱引用

import weakref

node1.next = weakref.ref(node2)  # 弱引用不增加引用计数

# 3. 手动触发GC

import gc

gc.collect()

import tracemalloc

tracemalloc.start()

# ... 运行代码 ...

snapshot = tracemalloc.take_snapshot()

top_stats = snapshot.statistics('lineno')

for stat in top_stats[:10]:

print(stat)

# 1. 使用推导式代替循环

squares = [i**2 for i in range(1000)]  # 比 for+append 快

# 2. 字符串拼接用 join 而非 +

result = ''.join(list_of_strings)       # 比 += 快

# 3. 使用局部变量（访问更快）

def fast():

    local_var = global_var   # 缓存在局部

for i in range(1000):

        process(local_var)

# 4. 使用生成器处理大数据（节省内存）

sum(x**2 for x in range(10**8))

# 5. 合理使用集合/字典进行查找（O(1) vs 列表的O(n)）

valid = set(['a', 'b', 'c'])

if item in valid:   # O(1)

pass

# cProfile：标准库性能分析器

python -m cProfile -o output.prof script.py

# line_profiler：逐行分析

# memory_profiler：内存分析

# I/O密集型：多线程有效

import threading

def io_task():

    # 网络请求等I/O操作

    time.sleep(1)  # 此时GIL被释放

# CPU密集型：多线程无效，应用多进程

from multiprocessing import Pool

def cpu_task(n):

return sum(i * i for i in range(n))

with Pool(4) as p:

    results = p.map(cpu_task, [10**6] * 10)

CPU 密集型 → 多进程（multiprocessing）或 C 扩展（NumPy/Numba）

I/O 密集型

  ├── 并发 < 100，逻辑简单 → 多线程（threading）

  └── 并发 > 1000 → asyncio（协程）

      1000 线程也可跑但上下文切换开销大，不如协程高效

import multiprocessing as mp

# 在Unix上可以设置启动方式

mp.set_start_method('fork')   # 或 'spawn'、'forkserver'

# 推荐：用 spawn 确保跨平台兼容

if __name__ == '__main__':

    mp.set_start_method('spawn', force=True)

from multiprocessing import Process, Pool, Queue, Pipe, Lock, Manager

import time

# 1. Process：创建独立进程

def worker(name):

print(f'Worker {name} started')

    time.sleep(1)

print(f'Worker {name} finished')

if __name__ == '__main__':

    p = Process(target=worker, args=('A',))

    p.start()

    p.join()  # 等待进程结束

# 2. Pool：进程池并发

def square(x):

return x * x

if __name__ == '__main__':

with Pool(4) as p:

        results = p.map(square, [1, 2, 3, 4, 5, 6])

print(results)  # [1, 4, 9, 16, 25, 36]

# 3. Queue：进程间安全通信

def producer(q):

    q.put('Hello from child process')

if __name__ == '__main__':

    q = Queue()

    p = Process(target=producer, args=(q,))

    p.start()

print(q.get())  # 主进程收取数据

    p.join()

# 4. Manager：共享复杂Python对象

def update(shared_dict, key, value):

    shared_dict[key] = value

if __name__ == '__main__':

with Manager() as manager:

        shared_dict = manager.dict()

        processes = [Process(target=update, args=(shared_dict, i, i*i)) for i in range(4)]

for p in processes:

            p.start()

for p in processes:

            p.join()

print(shared_dict)  # {0: 0, 1: 1, 2: 4, 3: 9}

from concurrent.futures import ProcessPoolExecutor

import time

def cpu_task(n):

    time.sleep(1)  # 模拟计算

return n * n

if __name__ == '__main__':

    numbers = [1, 2, 3, 4, 5, 6, 7, 8]

with ProcessPoolExecutor(max_workers=4) as executor:

        # 方法1：submit + Future

        futures = [executor.submit(cpu_task, num) for num in numbers]

        results = [f.result() for f in futures]

        # 方法2：map（保持输入顺序）

        results = list(executor.map(cpu_task, numbers))

print(results)  # [1, 4, 9, 16, 25, 36, 49, 64]

class BankAccount:

def __init__(self, owner, balance):

self.owner = owner       # 公有

self.__balance = balance  # 私有

@property

def balance(self):

        """getter：对外提供安全的访问方式"""

returnself.__balance

@balance.setter

def balance(self, amount):

        """setter：在修改时进行验证"""

if amount < 0:

raise ValueError("余额不能为负")

self.__balance = amount

account = BankAccount("Alice", 1000)

print(account.balance)      # 1000（通过property访问）

account.balance = 2000      # 通过setter修改

# account.__balance         # AttributeError!

class Animal:

def __init__(self, name):

self.name = name

def speak(self):

pass

class Dog(Animal):

def speak(self):                    # 方法重写（Override）

return f"{self.name} says Woof!"

class Cat(Animal):

def speak(self):

return f"{self.name} says Meow!"

class A:

def who(self): return "A"

class B(A):

def who(self): return "B"

class C(A):

def who(self): return "C"

class D(B, C):  # D 继承 B 和 C

pass

print(D.mro())       # D → B → C → A → object

print(D().who())     # "B" —— B 在 C 前面

class Person:

def __init__(self, name):

self.name = name

class Employee(Person):

def __init__(self, name, employee_id):

super().__init__(name)          # 调用父类__init__

self.employee_id = employee_id

# Python的鸭子类型（Duck Typing）：

# "如果它走起来像鸭子，叫起来像鸭子，那它就是鸭子"

class Dog:

def speak(self):

return "Woof!"

class Cat:

def speak(self):

return "Meow!"

class Duck:

def speak(self):

return "Quack!"

# 多态：统一的接口，不同的行为

def animal_sound(animal):

print(animal.speak())

animal_sound(Dog())   # Woof!

animal_sound(Cat())   # Meow!

animal_sound(Duck())  # Quack!

class Database:

def connect(self):

print("Connecting to DB")

# 紧耦合：UserService 内部创建 Database

class UserService:

def __init__(self):

self.db = Database()        # ❌ 紧耦合

# 松耦合：从外部注入依赖

class UserService:

def __init__(self, db):         # ✅ 依赖注入

self.db = db

from abc import ABC, abstractmethod

class DatabaseInterface(ABC):

@abstractmethod

def connect(self):

pass

class MySQLDatabase(DatabaseInterface):

def connect(self):

print("Connecting to MySQL")

class UserService:

def __init__(self, db: DatabaseInterface):  # 面向接口编程

self.db = db

class EventBus:

def __init__(self):

self.listeners = []

def subscribe(self, listener):

self.listeners.append(listener)

def publish(self, event):

for listener in self.listeners:

            listener(event)

class Singleton:

    _instance = None

def __new__(cls, *args, **kwargs):

ifnotcls._instance:

cls._instance = super().__new__(cls)

returncls._instance

class CarFactory:

def create_car(self, car_type):

if car_type == "sedan":

return Sedan()

elif car_type == "truck":

return Truck()

class CarStrategy:

def travel(self): pass

class TrainStrategy:

def travel(self): return "Traveling by train"

context = TravelContext(TrainStrategy())

context.travel()  # Traveling by train

# type()：获取对象类型

print(type(42))               # <class 'int'>

# dir()：列出对象的所有属性和方法

print(dir([1, 2, 3]))

# hasattr/getattr/setattr：动态操作属性

class Person:

    name = "Alice"

p = Person()

print(hasattr(p, 'name'))     # True

print(getattr(p, 'name'))     # Alice

setattr(p, 'age', 30)

# isinstance/issubclass：检查继承关系

print(isinstance([], list))   # True

print(issubclass(bool, int))  # True（bool是int的子类）

# __dict__：查看对象的属性字典

print(p.__dict__)              # {'age': 30}

# callable：检查是否可调用

print(callable(print))        # True