1. 元编程

宏的使用（类似Python装饰器）
Julia代码：

# 定义宏（在编译阶段操作代码）  
macro assert(condition)  
    :($condition || error("断言失败"))  
end  

@assert 2 + 2 == 4  # 正常执行  
@assert 1 > 2       # 抛出错误  

Python对比（装饰器运行时生效）：

def assert_decorator(func):  
    def wrapper(*args):  
        if not args[0]:  
            raise ValueError("断言失败")  
        return func(*args)  
    return wrapper  

@assert_decorator  
def check_condition(cond):  
    pass  

check_condition(1 > 2)  # 抛出错误  

2. 类型系统进阶

复合类型（类似Python类）
Julia代码（不可变类型，默认高效存储）：

struct Point  
    x::Float64  
    y::Float64  
end  
p = Point(1.0, 2.0)  
println(p.x)  # 输出1.0  

Python对比：

class Point:  
    def __init__(self, x, y):  
        self.x = x  
        self.y = y  
p = Point(1.0, 2.0)  
print(p.x)  

参数化类型（泛型编程）

struct Box{T}  
    content::T  
end  
Box(10)     # 自动推断为Box{Int64}  
Box("text") # Box{String}  

3. 并行计算

多线程计算（对比Python的GIL限制）
Julia代码：

using Base.Threads  
data = zeros(10)  
@threads for i in 1:10  
    data[i] = i^2  # 多线程并行赋值  
end  

Python对比（受GIL限制，需用多进程）：

from multiprocessing import Pool  
def square(i):  
    return i**2  

with Pool() as p:  
    data = p.map(square, range(1,11))  

4. 性能优化技巧

避免全局变量
Julia代码（将代码封装到函数中）：

function calculate()  
    x = 100  # 局部变量（编译器可优化）  
    x * 2  
end  

Python对比：全局变量访问速度较慢

检查类型稳定性

function unstable(x)  
    if x > 0  
        return 1  
    else  
        return "负数"  # 类型不稳定！  
    end  
end  

@code_warntype unstable(5)  # 输出显示类型推断问题  

5. 与Python互操作

通过PyCall调用Python库
Julia代码：

using PyCall  
np = pyimport("numpy")  
arr = np.array([1,2,3])  
println(np.sum(arr))  # 输出6  

# 调用Matplotlib绘图  
plt = pyimport("matplotlib.pyplot")  
plt.plot([1,2,3], [4,5,6])  
plt.savefig("plot.png")  

6. 实战案例

案例1：数据处理（对比Pandas）
Julia代码（使用DataFrames.jl）：

using CSV, DataFrames  
df = CSV.read("data.csv", DataFrame)  
filtered = df[df.Age .> 30, :]  
println(describe(filtered))  

Python对比：

import pandas as pd  
df = pd.read_csv("data.csv")  
filtered = df[df.Age > 30]  
print(filtered.describe())  

案例2：微分方程求解
Julia代码（使用DifferentialEquations.jl）：

using DifferentialEquations  
function lorenz!(du, u, p, t)  
    σ, ρ, β = p  
    du[1] = σ*(u[2]-u[1])  
    du[2] = u[1]*(ρ-u[3]) - u[2]  
    du[3] = u[1]*u[2] - β*u[3]  
end  
u0 = [1.0, 0.0, 0.0]  
tspan = (0.0, 100.0)  
p = (10.0, 28.0, 8/3)  
prob = ODEProblem(lorenz!, u0, tspan, p)  
sol = solve(prob)  

下篇核心总结表

练习题

1. 将以下Python装饰器转换为Julia宏：

def repeat(n):  
    def decorator(func):  
        def wrapper(*args):  
            for _ in range(n):  
                func(*args)  
        return wrapper  
    return decorator  

@repeat(3)  
def greet(name):  
    print(f"Hello {name}")  

greet("Alice")  # 打印三次Hello Alice  

2. 优化以下Julia代码性能：

x = 0  
for i in 1:1_000_000  
    global x += i  
end  

答案

1. Julia宏实现：

macro repeat(n, expr)  
    quote  
        for _ in 1:$n  
            $expr  
        end  
    end  
end  

@repeat 3 println("Hello Alice")  

2. 性能优化（避免全局变量）：

function sum_loop()  
    x = 0  
    for i in 1:1_000_000  
        x += i  
    end  
    x  
end  
sum_loop()  # 速度提升百倍以上