Posted 2026-01-11Updated 2026-02-22Note11 minutes read (About 1667 words)

使用 Python 和 Pygame 实现生命游戏

0. 教学目标

通过本实验，学习：

使用 二维数组表示离散网格世界
理解并实现 生命游戏的局部规则 → 全局演化
使用 Pygame 进行基础的二维图形显示
使用 键盘事件控制程序行为
将一个问题分解为：
数据结构 → 规则函数 → 显示函数 → 主循环

1. 什么是生命游戏（Conway’s Game of Life）

生命游戏是一个离散、确定性、无随机的元胞自动机：

空间：二维网格
时间：离散时间步
每个格子（细胞）只有两种状态：
- 活 (1)
- 死 (0)

1.1 演化规则（只依赖局部）

对每个细胞，统计它周围 8 个邻居 中活细胞的数量：

当前状态	活邻居数	下一状态
活	2 或 3	活
活	其他	死
死	3	活
死	其他	死

重要思想：

全局复杂行为来自简单的局部规则

2. 程序整体结构设计

在开始写代码前，先规划模块结构：

生命游戏程序
│
├── 参数设置（网格大小、颜色）
├── 二维数组表示网格
├── 邻居统计函数
├── 下一代计算函数
├── Pygame 绘制函数
└── 主循环（事件处理 + 显示）

3. 第一步：准备环境和基本参数

3.1 安装并导入库

1	pip install pygame

1 2	import pygame import random

3.2 定义网格和显示参数

CELL_SIZE = 10          # 每个细胞在屏幕上的像素大小
GRID_WIDTH = 80         # 网格列数
GRID_HEIGHT = 60        # 网格行数

SCREEN_WIDTH = GRID_WIDTH * CELL_SIZE
SCREEN_HEIGHT = GRID_HEIGHT * CELL_SIZE

解释：

我们的“世界”是逻辑网格
Pygame 显示的是像素
一个细胞 ↔ 一个矩形

3.3 定义细胞状态和颜色

ALIVE = 1
DEAD = 0

COLOR_BG = (0, 0, 0)
COLOR_CELL = (255, 255, 255)
COLOR_GRID = (40, 40, 40)

4. 第二步：用二维数组表示生命世界

4.1 二维数组的含义

1	grid[y][x]

y：第几行
x：第几列
值：0 或 1

4.2 随机初始化网格

def random_grid():
    grid = []  # 用来存放整个二维网格（每一行是一个列表）

    for y in range(GRID_HEIGHT):
        row = []  # 当前行
        for x in range(GRID_WIDTH):
            cell = random.choice([ALIVE, DEAD])
            row.append(cell)
        grid.append(row)

    return grid

更优雅的写法：

def random_grid():
    return [
        [random.choice([ALIVE, DEAD]) for _ in range(GRID_WIDTH)]
        for _ in range(GRID_HEIGHT)
    ]

教学要点：

外层列表 → 行
内层列表 → 列
每个位置随机赋值

5. 第三步：统计邻居数量（核心逻辑之一）

5.1 邻域定义

每个细胞有 8 个邻居：

1
2
3

(-1,-1) (0,-1) (1,-1)
(-1, 0)   X    (1, 0)
(-1, 1) (0, 1) (1, 1)

5.2 邻居统计函数

def count_neighbors(grid, x, y):
    count = 0
    for dy in [-1, 0, 1]:
        for dx in [-1, 0, 1]:
            if dx == 0 and dy == 0:
                continue
            nx, ny = x + dx, y + dy
            if 0 <= nx < GRID_WIDTH and 0 <= ny < GRID_HEIGHT:
                count += grid[ny][nx]
    return count

逐行解释：

两层循环遍历 3×3 区域
排除自身
检查是否越界
累加存活细胞数

6. 第四步：计算下一代网格

6.1 为什么不能原地修改？

当前状态 → 决定下一状态
如果边算边改，会影响后续计算

解决方案：

使用一个新的二维数组

6.2 下一代计算函数

def next_generation(grid):
    new_grid = [
        [DEAD for _ in range(GRID_WIDTH)]
        for _ in range(GRID_HEIGHT)
    ]

    for y in range(GRID_HEIGHT):
        for x in range(GRID_WIDTH):
            neighbors = count_neighbors(grid, x, y)
            if grid[y][x] == ALIVE:
                if neighbors in (2, 3):
                    new_grid[y][x] = ALIVE
            else:
                if neighbors == 3:
                    new_grid[y][x] = ALIVE

    return new_grid

教学重点：

规则直接翻译成代码
清晰的 if / else 逻辑
新旧网格分离

7. 第五步：使用 Pygame 显示网格

7.1 显示原理

一个细胞 → 一个矩形
坐标换算：

1 2	屏幕 x = 网格列 * CELL_SIZE 屏幕 y = 网格行 * CELL_SIZE

7.2 绘制函数

def draw_grid(screen, grid):
    screen.fill(COLOR_BG)

    for y in range(GRID_HEIGHT):
        for x in range(GRID_WIDTH):
            if grid[y][x] == ALIVE:
                rect = pygame.Rect(
                    x * CELL_SIZE,
                    y * CELL_SIZE,
                    CELL_SIZE,
                    CELL_SIZE
                )
                pygame.draw.rect(screen, COLOR_CELL, rect)

7.3 （可选）绘制网格线

for x in range(GRID_WIDTH):
    pygame.draw.line(
        screen, COLOR_GRID,
        (x * CELL_SIZE, 0),
        (x * CELL_SIZE, SCREEN_HEIGHT)
    )

for y in range(GRID_HEIGHT):
    pygame.draw.line(
        screen, COLOR_GRID,
        (0, y * CELL_SIZE),
        (SCREEN_WIDTH, y * CELL_SIZE)
    )

8. 第六步：主循环与键盘控制

8.1 Pygame 程序基本结构

1
2
3

pygame.init()
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
clock = pygame.time.Clock()

8.2 事件处理与主循环

grid = random_grid()
running = True

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_SPACE:
                grid = next_generation(grid)
            elif event.key == pygame.K_r:
                grid = random_grid()
            elif event.key == pygame.K_ESCAPE:
                running = False

    draw_grid(screen, grid)
    pygame.display.flip()
    clock.tick(60)

教学重点：

SPACE：推进一代
R：重新初始化
ESC：退出

9. 总结：完整程序的思想

二维数组 = 世界状态
局部规则 → 全局演化
显示逻辑与计算逻辑分离
主循环 = 事件 + 更新 + 绘制

完整程序：

import pygame
import random

# ==================================================
# 1. 参数设置
# ==================================================
CELL_SIZE = 10          # 单个细胞显示的像素大小
GRID_WIDTH = 80         # 网格列数
GRID_HEIGHT = 60        # 网格行数

SCREEN_WIDTH = GRID_WIDTH * CELL_SIZE
SCREEN_HEIGHT = GRID_HEIGHT * CELL_SIZE

ALIVE = 1
DEAD = 0

# 颜色定义
COLOR_BG = (0, 0, 0)
COLOR_CELL = (255, 255, 255)
COLOR_GRID = (40, 40, 40)


# ==================================================
# 2. 网格初始化（双层 for 循环版）
# ==================================================
def random_grid():
    grid = []

    for y in range(GRID_HEIGHT):
        row = []
        for x in range(GRID_WIDTH):
            cell = random.choice([ALIVE, DEAD])
            row.append(cell)
        grid.append(row)

    return grid


# ==================================================
# 3. 邻居数量统计
# ==================================================
def count_neighbors(grid, x, y):
    count = 0

    for dy in [-1, 0, 1]:
        for dx in [-1, 0, 1]:
            # 跳过自身
            if dx == 0 and dy == 0:
                continue

            nx = x + dx
            ny = y + dy

            # 边界检查
            if 0 <= nx < GRID_WIDTH and 0 <= ny < GRID_HEIGHT:
                count += grid[ny][nx]

    return count


# ==================================================
# 4. 计算下一代
# ==================================================
def next_generation(grid):
    new_grid = []

    for y in range(GRID_HEIGHT):
        new_row = []
        for x in range(GRID_WIDTH):
            neighbors = count_neighbors(grid, x, y)

            if grid[y][x] == ALIVE:
                if neighbors == 2 or neighbors == 3:
                    new_row.append(ALIVE)
                else:
                    new_row.append(DEAD)
            else:
                if neighbors == 3:
                    new_row.append(ALIVE)
                else:
                    new_row.append(DEAD)

        new_grid.append(new_row)

    return new_grid


# ==================================================
# 5. 绘制网格
# ==================================================
def draw_grid(screen, grid):
    screen.fill(COLOR_BG)

    # 绘制细胞
    for y in range(GRID_HEIGHT):
        for x in range(GRID_WIDTH):
            if grid[y][x] == ALIVE:
                rect = pygame.Rect(
                    x * CELL_SIZE,
                    y * CELL_SIZE,
                    CELL_SIZE,
                    CELL_SIZE
                )
                pygame.draw.rect(screen, COLOR_CELL, rect)

    # 绘制网格线（教学可选）
    for x in range(GRID_WIDTH):
        pygame.draw.line(
            screen,
            COLOR_GRID,
            (x * CELL_SIZE, 0),
            (x * CELL_SIZE, SCREEN_HEIGHT)
        )

    for y in range(GRID_HEIGHT):
        pygame.draw.line(
            screen,
            COLOR_GRID,
            (0, y * CELL_SIZE),
            (SCREEN_WIDTH, y * CELL_SIZE)
        )


# ==================================================
# 6. 主程序
# ==================================================
def main():
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Conway's Game of Life (Teaching Version)")

    clock = pygame.time.Clock()

    grid = random_grid()
    running = True

    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False

            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    # 推进到下一代
                    grid = next_generation(grid)

                elif event.key == pygame.K_r:
                    # 随机重新初始化
                    grid = random_grid()

                elif event.key == pygame.K_ESCAPE:
                    running = False

        draw_grid(screen, grid)
        pygame.display.flip()
        clock.tick(60)

    pygame.quit()


# ==================================================
# 7. 程序入口
# ==================================================
if __name__ == "__main__":
    main()

#Python

Posted 2025-12-15Updated 2026-02-22Notea minute read (About 156 words)

深度相机选型

近距离拍摄”螺栓”

#Robotics Camera

Posted 2025-12-15Updated 2026-02-22Notea few seconds read (About 97 words)

Lec11

参照组装手册拼装带夹爪的机器小车。

Posted 2025-12-11Updated 2026-02-22Note5 minutes read (About 773 words)

小鹏机器人面试

已知末端的位置和姿态，以及所有连杆的几何参数下，求解关节的位置。

#Robot 实习

Posted 2025-11-27Updated 2026-02-22Review3 minutes read (About 511 words)

ChemGPT

ChemGPT 早期基座模型基于 EleutherAI 的语言模型 GPT‑Neo，在分子字符串语料（SMILES 或 SELFIES）上进行自回归建模。
典型预训练数据集为公开的大规模分子库 PubChem10M，参数规模覆盖百万到十亿级别（如约 4.7M 的轻量版本或 100M+ 的科研版本）。
属于领域特化的 decoder-only 化学语言模型。

#Research-paper LLM Chemistry

Posted 2025-11-24Updated 2026-02-22Note5 minutes read (About 677 words)

Lec8

# ===== 第一课时：函数的定义与使用 =====

# 1. 最简单的函数 - 无参数无返回值
print("--- 示例1：打招呼函数 ---")

def say_hello():
    """这是一个简单的打招呼函数"""
    print("你好！")
    print("欢迎学习Python！")

# 调用函数
say_hello()
say_hello()  # 可以多次调用

# 2. 带参数的函数
print("\n--- 示例2：带参数的函数 ---")

def greet(name):
    """向指定的人打招呼"""
    print("你好，", name, "！")
    print("很高兴见到你！")

greet("小明")
greet("小红")
greet("小刚")

# 3. 带多个参数的函数
print("\n--- 示例3：多个参数 ---")

def introduce(name, age, hobby):
    """自我介绍函数"""
    print(f"大家好，我叫{name}")
    print(f"我今年{age}岁")
    print(f"我喜欢{hobby}")
    print("-" * 30)

introduce("小明", 10, "打篮球")
introduce("小红", 9, "画画")

# 4. 带返回值的函数
print("\n--- 示例4：返回值 ---")

def add(a, b):
    """计算两个数的和"""
    result = a + b
    return result

sum1 = add(5, 3)
sum2 = add(10, 20)
print("5 + 3 =", sum1)
print("10 + 20 =", sum2)

# 5. 实用函数：计算矩形面积
print("\n--- 示例5：计算面积 ---")

def rectangle_area(length, width):
    """计算矩形面积"""
    area = length * width
    return area

area1 = rectangle_area(5, 3)
area2 = rectangle_area(10, 8)
print("长5宽3的矩形面积：", area1)
print("长10宽8的矩形面积：", area2)

# 6. 实用函数：判断奇偶
print("\n--- 示例6：判断奇偶数 ---")

def is_even(number):
    """判断一个数是否为偶数"""
    if number % 2 == 0:
        return True
    else:
        return False

print("4是偶数吗？", is_even(4))
print("7是偶数吗？", is_even(7))
print("10是偶数吗？", is_even(10))

# 7. 实用函数：计算平均分
print("\n--- 示例7：计算平均分 ---")

def calculate_average(score1, score2, score3):
    """计算三门课的平均分"""
    total = score1 + score2 + score3
    average = total / 3
    return average

avg = calculate_average(85, 90, 88)
print("平均分是：", avg)

# 8. 综合练习：温度转换
print("\n--- 示例8：温度转换 ---")

def celsius_to_fahrenheit(celsius):
    """摄氏度转华氏度"""
    fahrenheit = celsius * 9/5 + 32
    return fahrenheit

def fahrenheit_to_celsius(fahrenheit):
    """华氏度转摄氏度"""
    celsius = (fahrenheit - 32) * 5/9
    return celsius

temp_c = 25
temp_f = celsius_to_fahrenheit(temp_c)
print(f"{temp_c}°C = {temp_f}°F")

temp_f2 = 77
temp_c2 = fahrenheit_to_celsius(temp_f2)
print(f"{temp_f2}°F = {temp_c2}°C")

# 9. 带默认参数的函数
print("\n--- 示例9：默认参数 ---")

def power(number, exponent=2):
    """计算幂次方，默认是平方"""
    result = number ** exponent
    return result

print("5的平方：", power(5))
print("2的3次方：", power(2, 3))
print("3的4次方：", power(3, 4))

# 10. 实践项目：成绩管理系统
print("\n--- 综合实践：成绩管理 ---")

def get_grade(score):
    """根据分数返回等级"""
    if score >= 90:
        return "优秀"
    elif score >= 80:
        return "良好"
    elif score >= 60:
        return "及格"
    else:
        return "不及格"

def print_report(name, math, chinese, english):
    """打印成绩单"""
    print(f"\n===== {name}的成绩单 =====")
    print(f"数学：{math}分 - {get_grade(math)}")
    print(f"语文：{chinese}分 - {get_grade(chinese)}")
    print(f"英语：{english}分 - {get_grade(english)}")
    
    avg = calculate_average(math, chinese, english)
    print(f"平均分：{avg:.1f}分 - {get_grade(avg)}")
    print("=" * 30)

print_report("小明", 85, 92, 88)
print_report("小红", 95, 87, 91)

#Python Robot

Posted 2025-11-22Updated 2026-02-22Review2 minutes read (About 233 words)

DREAM TO CONTROL= LEARNING BEHAVIORS BY LATENT IMAGINATION

论文使用**RSSM(Recurrent State Space Model)**：使用encoder来编码环境和动作生成latent state, 预测未来latent state，最后基于latent state预测奖励。

#Research-paper ML RL Embodied-AI WorldModel

Posted 2025-11-21Updated 2026-02-22Review4 minutes read (About 643 words)

奠定世界模型= Intelligence without representation

目前学界广泛认为，世界模型是通往AGI的正确道路。而世界模型这一理念可以追溯到这篇1991年的文章。

寓言

1890 年代的人想造飞机，却只能根据他们零碎的观察去猜。他们看到现代飞机巨大、复杂，于是做了一个错误类比：
“现代飞机又大又重 → 所以重量不是问题。”
这当然荒唐。真正让飞机能飞的前提是升力、功率重量比、材料强度等关键工程指标的平衡。但他们只看到了表象，所以：

座椅用实心钢
完全不关心重量控制
座舱设计完全按马车或汽车类比
控制系统用汽车方向盘、油门
甚至把“看地面”和“开窗透气”当成关键需求

寓言中的团队觉得项目太大，所以分专业化研究，但他们犯了一个致命错误： 没有系统架构，没有统一指标，没有工程指导思想。
因此：

每个小组各做各的
没有协调
没有明确目标
没有性能指标
完全不知道“重量、升力、结构”是耦合的
这其实是现代大型项目失败的典型原因。

论文的核心思想：AI 不应依赖内部表征，世界就是模型

Brooks 的核心观点用一句话总结就是：

智能不是“建模世界 + 推理”的结果，而是“直接在世界中行动”的结果。世界本身就是模型，不需要额外的表征。

传统 AI（symbolic AI）强调：

先感知世界形成表征
用表征进行内部推理
规划行动

Brooks 强烈反对。他认为：

显式表征只会拖慢系统、增加错误来源
真正的智能首先来源于“行动”而非“思考”
复杂智能应从简单行为逐层堆叠，而非从复杂推理开始

这种思想后来直接催生了：

行为式机器人学
Embodied AI
Subsumption Architecture
深度强化学习中“end-to-end from pixels to actions”的理念
现代多模态 agent 的行为驱动架构
Brooks 的方法强调直接耦合感知与动作，由多个独立行为层并行运行，无中心控制，无统一世界模型。

#Robotics Research-paper Embodied-AI WorldModel

Posted 2025-11-12Updated 2026-02-22Notea few seconds read (About 0 words)

ROS2 Basic

#ROS

Posted 2025-11-12Updated 2026-02-22Note2 minutes read (About 260 words)

Custom Robot URDF with Moveit2

URDF 生成

使用solidworks URDF exporter.

https://www.bilibili.com/video/BV1WX4y157gg/?spm_id_from=333.337.search-card.all.click&vd_source=45fc7197aaca220eec8fef4c2711efe3

需要注意不要使用 lock constrain 限制零件位置。

URDF with Moveit2

https://moveit.picknik.ai/main/doc/examples/examples.html#integration-with-a-new-robot
首先克隆moveit2的示例仓库:

1	git clone -b humble https://github.com/moveit/moveit2_tutorials

编译项目colcon build，启动setup assistant：

1	ros2 launch moveit_setup_assistant setup_assistant.launch.py

随后按照教程配置SRDF。
注意不要将virtual_joint加入group。
注意更改moveit_controllers.yaml:

# moveit_controllers.yaml
moveit_controller_manager: moveit_simple_controller_manager/MoveItSimpleControllerManager

moveit_simple_controller_manager:
  controller_names:
    - arm_controller
  
  arm_controller:
    type: FollowJointTrajectory
    action_ns: follow_joint_trajectory
    default: true
    joints:
      - j1
      - j2
      - j3
      - j4
      - j5
      - j6

注意更改ros2_controllers.yaml:

arm_controller:
  ros__parameters:
    joints:
      - j1
      - j2
      - j3
      - j4
      - j5
      - j6
    
    command_interfaces:
      - position
    
    state_interfaces:
      - position
      - velocity

配置完成后可以启动示例代码：

1	ros2 launch panda_moveit_config demo.launch.py

会将机械臂可视化并且拖动目标位置之后可以plan&execute。

#ROS Robotics Moveit