import ctypes
import os

def basic_ctypes_demo():
    """基础ctypes演示"""
    print("=== 基础ctypes演示 ===")
    
    # 1. 调用系统库函数
    print("1. 调用系统库函数:")
    
    # Windows系统
    if os.name == 'nt':
        kernel32 = ctypes.windll.kernel32
        # 获取当前进程ID
        process_id = kernel32.GetCurrentProcessId()
        print(f"当前进程ID: {process_id}")
    
    # Unix系统
    else:
        libc = ctypes.CDLL("libc.so.6")
        # 获取当前进程ID
        process_id = libc.getpid()
        print(f"当前进程ID: {process_id}")
    
    # 2. 定义C函数签名
    print("\n2. 定义C函数签名:")
    
    # 创建简单的数学函数
    def create_math_lib():
        """创建数学库函数"""
        # 定义函数原型
        add_func = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int)
        
        def add(a, b):
            return a + b
        
        # 包装函数
        add_wrapper = add_func(add)
        return add_wrapper
    
    math_func = create_math_lib()
    result = math_func(10, 20)
    print(f"数学函数结果: 10 + 20 = {result}")

basic_ctypes_demo()

import ctypes
from ctypes import Structure, c_int, c_char_p, c_double

class Point(Structure):
    """C结构体定义"""
    _fields_ = [
        ("x", c_int),
        ("y", c_int),
    ]
    
    def __repr__(self):
        return f"Point({self.x}, {self.y})"

def advanced_ctypes_demo():
    """高级ctypes特性演示"""
    print("\n=== 高级ctypes特性演示 ===")
    
    # 1. 结构体操作
    print("1. 结构体操作:")
    
    # 创建Point结构体
    point = Point(10, 20)
    print(f"创建点: {point}")
    
    # 修改结构体字段
    point.x = 30
    point.y = 40
    print(f"修改后: {point}")
    
    # 2. 数组操作
    print("\n2. 数组操作:")
    
    # 创建整数数组
    int_array = (c_int * 5)(1, 2, 3, 4, 5)
    print(f"整数数组: {list(int_array)}")
    
    # 修改数组元素
    int_array[2] = 99
    print(f"修改后: {list(int_array)}")
    
    # 创建结构体数组
    point_array = (Point * 3)()
    point_array[0] = Point(1, 1)
    point_array[1] = Point(2, 2)
    point_array[2] = Point(3, 3)
    
    print("结构体数组:")
    for i, point in enumerate(point_array):
        print(f"  point_array[{i}] = {point}")

advanced_ctypes_demo()

# 这个示例展示如何在Python中使用Cython概念
# 实际的Cython代码需要保存在.pyx文件中并编译

def cython_concepts_demo():
    """Cython概念演示（Python版本）"""
    print("\n=== Cython概念演示 ===")
    
    # 1. 类型声明（在Cython中会这样写）
    print("1. Cython类型声明示例:")
    print("""
    # Cython代码示例 (.pyx文件):
    
    # 函数类型声明
    cdef int fast_fibonacci(int n):
        cdef int a = 0, b = 1, i
        for i in range(n):
            a, b = b, a + b
        return a
    
    # 类属性类型声明
    cdef class Point:
        cdef public int x, y
        
        def __init__(self, int x, int y):
            self.x = x
            self.y = y
        
        cdef double distance_from_origin(self):
            return (self.x * self.x + self.y * self.y) ** 0.5
    """)
    
    # 2. 纯Python版本的实现（用于对比）
    class PythonPoint:
        """纯Python版本的Point类"""
        def __init__(self, x, y):
            self.x = x
            self.y = y
        
        def distance_from_origin(self):
            return (self.x * self.x + self.y * self.y) ** 0.5
    
    def python_fibonacci(n):
        """纯Python版本的斐波那契"""
        a, b = 0, 1
        for _ in range(n):
            a, b = b, a + b
        return a
    
    # 测试性能差异（概念演示）
    import time
    
    print("\n2. 性能对比演示:")
    
    # 测试斐波那契
    n = 30
    start_time = time.time()
    result = python_fibonacci(n)
    python_time = time.time() - start_time
    print(f"Python斐波那契({n}) = {result}, 耗时: {python_time:.6f}秒")
    
    # 测试Point类
    point = PythonPoint(3, 4)
    distance = point.distance_from_origin()
    print(f"Python Point距离 = {distance}")

cython_concepts_demo()

import os

def cython_build_demo():
    """Cython构建演示"""
    print("\n=== Cython构建演示 ===")
    
    print("Cython构建过程:")
    print("1. 创建.pyx文件")
    print("2. 创建setup.py文件")
    print("3. 运行 python setup.py build_ext --inplace")
    print("4. 导入编译后的模块")
    
    print("\n构建命令示例:")
    print("python setup.py build_ext --inplace")
    
    print("\nCython优化要点:")
    print("- 使用cdef声明C类型")
    print("- 避免Python对象创建")
    print("- 使用cpdef声明可调用的C函数")
    print("- 利用Cython的循环优化")
    
    print("\n示例setup.py文件:")
    print("""
    from distutils.core import setup
    from Cython.Build import cythonize
    
    setup(
        ext_modules = cythonize("math_utils.pyx")
    )
    """)

cython_build_demo()

import time
from array import array

def performance_comparison():
    """性能对比分析"""
    print("\n=== 性能对比分析 ===")
    
    def python_sum_squares(n):
        """纯Python版本"""
        total = 0
        for i in range(n):
            total += i * i
        return total
    
    def python_list_sum_squares(n):
        """Python列表推导式版本"""
        return sum(i * i for i in range(n))
    
    def array_sum_squares(n):
        """使用array模块版本"""
        arr = array('i', range(n))
        total = 0
        for i in arr:
            total += i * i
        return total
    
    # 测试不同实现的性能
    n = 100000
    print(f"测试规模: {n}")
    
    # 纯Python循环
    start = time.time()
    result1 = python_sum_squares(n)
    time1 = time.time() - start
    print(f"纯Python循环: {result1}, 耗时: {time1:.6f}秒")
    
    # 列表推导式
    start = time.time()
    result2 = python_list_sum_squares(n)
    time2 = time.time() - start
    print(f"列表推导式: {result2}, 耗时: {time2:.6f}秒")
    
    # array模块
    start = time.time()
    result3 = array_sum_squares(n)
    time3 = time.time() - start
    print(f"array模块: {result3}, 耗时: {time3:.6f}秒")
    
    # 性能比较
    print("\n性能比较:")
    times = [time1, time2, time3]
    names = ["纯Python循环", "列表推导式", "array模块"]
    
    fastest_time = min(times)
    for i, (name, t) in enumerate(zip(names, times)):
        speedup = t / fastest_time
        print(f"{name}: {speedup:.2f}x {'(最快)' if t == fastest_time else ''}")

performance_comparison()