Mojo 语言入门¶

为什么要学¶

Mojo 是一门新语言，目标是成为"Python 的超集 + 系统级性能"：

Python 超集：大部分 Python 代码可以直接在 Mojo 中运行
极致性能：比 Python 快 68000 倍（官方基准测试）
AI 原生：专为 AI/ML 计算设计，SIMD/GPU 一等支持
渐进式类型：从动态到静态，按需添加类型注解获得性能
MLIR 基础：基于 LLVM/MLIR 编译器基础设施
内存安全：借鉴 Rust 的所有权模型

Mojo 的愿景是让 AI 研究者用 Python 的语法写出 C++/CUDA 级别的性能代码。

核心概念¶

白话解释¶

Mojo 像一个"涡轮增压的 Python"： - 写起来像 Python（同样的语法和缩进） - 跑起来像 C++（编译优化+SIMD+并行） - 需要性能时加类型注解，不需要时保持 Python 的灵活

核心概念对照表¶

Mojo	Python对比	说明
fn	def	严格类型函数(编译优化)
def	def	动态类型函数(兼容Python)
var	=	可变变量(需显式声明)
let	=	不可变绑定
struct	class	值类型(栈分配, 更快)
SIMD	numpy	内置向量化操作
owned/borrowed/inout	(无)	所有权/借用(类Rust)
@parameter	(无)	编译时参数
alias	(无)	编译时常量
DType	dtype	数据类型(Float32等)

安装配置¶

安装¶

# 安装Modular CLI
curl -s https://get.modular.com | sh

# 安装Mojo
modular install mojo

# 添加到PATH (按提示操作)
echo 'export PATH="$HOME/.modular/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

# 验证
mojo --version

开发环境¶

# VS Code扩展
# 安装 "Mojo" 扩展(Modular官方)

# 创建项目
mkdir my_mojo_project && cd my_mojo_project

# 创建文件
touch hello.mojo

运行方式¶

# 直接运行
mojo hello.mojo

# REPL
mojo

# 构建为二进制
mojo build hello.mojo -o hello
./hello

快速上手¶

Hello World¶

fn main():
    print("Hello, Mojo! 🔥")

    # Python风格的动态代码也可以
    var name = "World"
    print("Hello, " + name)

def vs fn¶

# def: 动态类型, 兼容Python行为
def dynamic_add(a, b):
    return a + b

# fn: 静态类型, 编译优化, 更快
fn typed_add(a: Int, b: Int) -> Int:
    return a + b

fn main():
    # 两种都可以用
    print(dynamic_add(1, 2))  # 动态
    print(typed_add(1, 2))    # 静态, 更快

Struct（值类型）¶

struct Point:
    var x: Float64
    var y: Float64

    fn __init__(inout self, x: Float64, y: Float64):
        self.x = x
        self.y = y

    fn distance(self, other: Point) -> Float64:
        var dx = self.x - other.x
        var dy = self.y - other.y
        return (dx * dx + dy * dy) ** 0.5

    fn __str__(self) -> String:
        return "Point(" + str(self.x) + ", " + str(self.y) + ")"

fn main():
    var p1 = Point(0.0, 0.0)
    var p2 = Point(3.0, 4.0)
    print(p1.distance(p2))  # 5.0

SIMD 向量化¶

from math import sqrt

fn main():
    # SIMD: 单指令多数据, 一次处理多个值
    var vec = SIMD[DType.float32, 4](1.0, 2.0, 3.0, 4.0)
    var squared = vec * vec
    print(squared)  # [1.0, 4.0, 9.0, 16.0]

    # 向量运算
    var a = SIMD[DType.float64, 4](1.0, 2.0, 3.0, 4.0)
    var b = SIMD[DType.float64, 4](5.0, 6.0, 7.0, 8.0)
    var dot_product = (a * b).reduce_add()
    print(dot_product)  # 1*5 + 2*6 + 3*7 + 4*8 = 70.0

进阶用法¶

1. 高性能计算¶

from algorithm import vectorize, parallelize

# 向量化的矩阵运算
fn matmul_naive(
    C: UnsafePointer[Float32],
    A: UnsafePointer[Float32],
    B: UnsafePointer[Float32],
    M: Int, N: Int, K: Int
):
    for i in range(M):
        for j in range(N):
            var sum: Float32 = 0.0
            for k in range(K):
                sum += A[i * K + k] * B[k * N + j]
            C[i * N + j] = sum

# SIMD向量化版本
fn matmul_vectorized(
    C: UnsafePointer[Float32],
    A: UnsafePointer[Float32],
    B: UnsafePointer[Float32],
    M: Int, N: Int, K: Int
):
    alias simd_width = simdwidthof[Float32]()

    for i in range(M):
        for j_outer in range(0, N, simd_width):
            var sum = SIMD[DType.float32, simd_width](0)
            for k in range(K):
                var a_val = SIMD[DType.float32, simd_width](A[i * K + k])
                var b_vec = B.load[width=simd_width](k * N + j_outer)
                sum += a_val * b_vec
            C.store(i * N + j_outer, sum)

2. 并行化¶

from algorithm import parallelize

fn parallel_computation():
    var size = 1000000
    var data = UnsafePointer[Float64].alloc(size)

    # 并行处理
    @parameter
    fn process_chunk(i: Int):
        data[i] = Float64(i) * Float64(i)

    parallelize[process_chunk](size)

    # 验证
    print(data[999])  # 999 * 999 = 998001
    data.free()

3. 编译时参数¶

# 编译时参数化的泛型结构
struct Array[T: DType, size: Int]:
    var data: SIMD[T, size]

    fn __init__(inout self):
        self.data = SIMD[T, size](0)

    fn __init__(inout self, val: Scalar[T]):
        self.data = SIMD[T, size](val)

    fn sum(self) -> Scalar[T]:
        return self.data.reduce_add()

fn main():
    var arr = Array[DType.float32, 8](1.0)
    print(arr.sum())  # 8.0

4. 所有权和借用¶

struct UniquePtr:
    var data: UnsafePointer[Int]

    fn __init__(inout self, value: Int):
        self.data = UnsafePointer[Int].alloc(1)
        self.data[] = value

    fn __del__(owned self):
        self.data.free()

    fn __moveinit__(inout self, owned existing: Self):
        self.data = existing.data
        existing.data = UnsafePointer[Int]()

# borrowed: 只读借用(默认)
fn read_value(borrowed ptr: UniquePtr) -> Int:
    return ptr.data[]

# inout: 可变借用
fn modify_value(inout ptr: UniquePtr, new_val: Int):
    ptr.data[] = new_val

# owned: 转移所有权
fn consume(owned ptr: UniquePtr):
    print(ptr.data[])
    # ptr在函数结束时被销毁

5. Python 互操作¶

from python import Python

fn main() raises:
    # 直接使用Python库
    var np = Python.import_module("numpy")
    var plt = Python.import_module("matplotlib.pyplot")

    # NumPy操作
    var arr = np.array([1, 2, 3, 4, 5])
    var squared = arr ** 2
    print(squared)

    # Pandas
    var pd = Python.import_module("pandas")
    var df = pd.DataFrame({"x": [1, 2, 3], "y": [4, 5, 6]})
    print(df.describe())

6. Traits（接口）¶

trait Printable:
    fn to_string(self) -> String:
        ...

trait Numeric:
    fn __add__(self, other: Self) -> Self:
        ...
    fn __mul__(self, other: Self) -> Self:
        ...

struct Vector2D(Printable, Numeric):
    var x: Float64
    var y: Float64

    fn __init__(inout self, x: Float64, y: Float64):
        self.x = x
        self.y = y

    fn to_string(self) -> String:
        return "(" + str(self.x) + ", " + str(self.y) + ")"

    fn __add__(self, other: Self) -> Self:
        return Self(self.x + other.x, self.y + other.y)

    fn __mul__(self, other: Self) -> Self:
        return Self(self.x * other.x, self.y * other.y)

常见问题¶

Q1: Mojo 能完全替代 Python 吗？¶

目前不能。Mojo 还在快速发展中，并非所有 Python 库和语法都支持。适合计算密集型代码，日常脚本仍用 Python 更方便。

Q2: 和 Cython/Numba 的区别？¶

方面	Mojo	Cython	Numba
独立语言	是	否(Python扩展)	否(装饰器)
全部重写	可选	部分	部分
GPU支持	原生	无	CUDA
生态	新	成熟	成熟
性能上限	C++级	接近C	接近C(限制场景)

Q3: 当前限制？¶

仅支持 Linux 和 macOS（Windows 支持开发中）
生态库还很少
部分 Python 功能尚未实现
语言本身仍在演进

Q4: 适合什么场景？¶

AI/ML 模型推理加速
科学计算
数据处理管道的热点函数
需要 GPU 加速的计算
替代 C/C++ 扩展

参考资源¶

Mojo 官网 - 官方网站
Mojo 文档 - 完整文档
Mojo Playground - 在线试用
Modular GitHub - 相关代码
Mojo Changelog - 更新日志