Python面试教程：全面掌握技术面试核心要点

def modify_list(lst):
    lst.append(4)
def modify_str(s):
    s += " world"
my_list = [1, 2, 3]
my_str = "hello"
modify_list(my_list)
modify_str(my_str)
print(my_list)  # [1, 2, 3, 4]
print(my_str)   # "hello"

import copy
a = [1, [2, 3], "hello"]
b = copy.copy(a)   # 浅拷贝
c = copy.deepcopy(a) # 深拷贝
a[1].append(4)
print(b[1])  # [2, 3, 4] — 浅拷贝只复制外层，内层仍共享引用
print(c[1])  # [2, 3] — 深拷贝递归复制所有层级

def log_call(prefix="INFO"):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"{prefix}: Calling {func.__name__}")
            return func(*args, **kwargs)
        return wrapper
    return decorator
@log_call("DEBUG")
def calculate(x, y):
    return x + y
print(calculate(3, 5))  # DEBUG: Calling calculate\n8

class A:
    def foo(self):
        print("A")
class B(A):
    def foo(self):
        print("B")
class C(A):
    def foo(self):
        print("C")
class D(B, C):
    def foo(self):
        super().foo()  # 调用B.foo()
        print("D")
print(D.__mro__)  # (, , , , )
D().foo()  # B\nD

class Fib:
    def __init__(self, n):
        self.n = n
    def __iter__(self):
        a, b = 0, 1
        for _ in range(self.n):
            yield a
            a, b = b, a + b
fib = Fib(5)
print(list(fib))  # [0, 1, 1, 2, 3]

class Positive:
    def __set_name__(self, owner, name):
        self.name = "_" + name
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return getattr(obj, self.name)
    def __set__(self, obj, value):
        if value < 0:
            raise ValueError("Value must be positive")
        setattr(obj, self.name, value)
class Product:
    price = Positive()
    def __init__(self, name, price):
        self.name = name
        self.price = price
p = Product("Apple", 10)
p.price = -5  # ValueError: Value must be positive

def simple_gen():
    print("Step 1")
    yield 1
    print("Step 2")
    yield 2
    print("Step 3")
gen = simple_gen()
print(next(gen))  # Step 1\n1
print(next(gen))  # Step 2\n2
print(next(gen))  # Step 3\nStopIteration

import asyncio
async def fetch_data(url):
    print(f"Start fetching {url}")
    await asyncio.sleep(1)  # 模拟网络请求
    print(f"Finished fetching {url}")
    return {"url": url, "data": "sample"}
async def main():
    urls = ["a.com", "b.com", "c.com"]
    tasks = [fetch_data(url) for url in urls]
    results = await asyncio.gather(*tasks)
    print(results)
asyncio.run(main())

def coroutine():
    print("Coroutine started")
    while True:
        x = yield
        print(f"Received: {x}")
cr = coroutine()
next(cr)  # 预激协程
cr.send(10)  # Received: 10
cr.send("hello")  # Received: hello
try:
    cr.throw(ValueError("Error!"))  # ValueError: Error! (在yield处抛出)
except StopIteration:
    pass

async def async_func():
    return 42
def sync_func():
    result = async_func()  # 错误！返回协程对象
    return result
print(sync_func())  # 

import asyncio
import aiohttp
async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()
async def main():
    urls = ["https://httpbin.org/get"] * 5
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        responses = await asyncio.gather(*tasks)
        print(f"Fetched {len(responses)} pages")
asyncio.run(main())

import hashlib
import base64
def encode_url(long_url):
    hash_bytes = hashlib.md5(long_url.encode()).digest()
    return base64.urlsafe_b64encode(hash_bytes)[:6].decode()
def shorten(long_url):
    short_code = encode_url(long_url)
    # 存入数据库（MySQL/Redis）
    return f"https://short.ly/{short_code}"

from collections import OrderedDict
class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = OrderedDict()
    def get(self, key):
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)
        return self.cache[key]
    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

import time
class TokenBucket:
    def __init__(self, rate, capacity):
        self.rate = rate  # tokens/second
        self.capacity = capacity
        self.tokens = capacity
        self.last_update = time.time()
    def consume(self, tokens=1):
        now = time.time()
        elapsed = now - self.last_update
        self.tokens = min(self.capacity, self.tokens + elapsed * self.rate)
        self.last_update = now
        if self.tokens >= tokens:
            self.tokens -= tokens
            return True
        return False