入门 on Liangweidong's blog

Python 入门：核心语法与环境管理（基于 Python 3.13）

Fri, 15 Nov 2024 00:00:00 +0800

为什么写这篇：Python 是少有的"零基础一周能上手、一年能进工程"的语言。但"上手"和"工程"之间有一道坎——缩进、动态类型、包管理、虚拟环境。这篇用一篇的篇幅把这些一并讲完，让你能从 print("hello") 平滑过渡到 pip install -r requirements.txt。

适用读者：完全没接触过 Python 的初学者；或用过 Python 但没系统管理过依赖/环境的开发者。

基线版本：本文示例基于 Python 3.13（2024-10-07 正式发布）与 pyenv 2.6.27。3.13 引入了实验性 JIT 编译器、改进的交互式 REPL（Py 3.13 起 python 默认带颜色高亮与多行编辑）、typing 模块的进一步类型化语义等；但本文语法示例与 3.10+ 完全兼容，向下覆盖到 3.8 仍可运行。

1. Python 程序结构

Python 用缩进表示代码块，不用 {}。同一代码块的语句必须缩进相同空格数（约定 4 空格）。

1
2
3


当语句以冒号 : 结尾时，缩进的语句视为代码块
按照约定俗成的惯例，应该始终坚持使用 4 个空格的缩进
Python 程序是大小写敏感的，如果写错了大小写，程序会报错

一个完整的程序示例（PEP 8 风格）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#!/usr/bin/env python3
"""this is a test module.""" # 模块文档字符串（双/单引号皆可）

import sys # 模块导入

debug = True # 全局变量


class FooClass: # 类定义（Py 3 不用写 object）
 """Foo class"""

 pass


def test(): # 函数定义
 """test func"""
 foo = FooClass()
 if debug:
 print("run test()")


if __name__ == "__main__": # 主程序入口
 test()

元素	作用
`__init__.py`	标识一个文件夹是包（Python 3.3+ 命名空间包可省略，但显式写更稳）
`import`	导入模块/包
`if __name__ == "__main__"`	直接执行时为 `True`，被 import 时为 `False`——模块既可作库也可作脚本
文档字符串（`"""..."""`）	写模块/类/函数的官方注释，可用 `help()` / `__doc__` 查

为什么模块入口要写 if __name__ == "__main__"：避免 import 时副作用自动执行。一个文件既能 python file.py 直接跑，也能 import file 复用。

Py 3.13 的小升级：解释器现在会在交互模式下自动给 python 命令加颜色高亮（--no-color 关闭），并把 REPL 默认行为改成了"多行粘贴友好"——以前在 >>> 提示符粘贴带缩进的代码块经常乱，现在会自动识别和续行。

2. 类型与变量

2.1 基本类型

1
2
3
4
5


整数（如 2、4、20）的类型是 int —— 任意精度，不会溢出
带小数（如 5.0、1.6）的类型是 float —— 底层 IEEE-754 双精度
复数后缀 j 或 J：3 + 5j
Decimal、Fraction：高精度 / 精确分数场景
bool 是 int 的子类：True == 1, False == 0

2.2 变量赋值

1
2


等号（=）用于给变量赋值
如果变量未定义（即未赋值），使用该变量会提示 NameError

Python 是动态类型——变量无类型，值才有类型：

1
2
3


x = 10 # x 是 int
x = "hello" # x 现在是 str——OK，python 允许
x = [1, 2, 3] # x 现在是 list——也 OK

动态类型的代价：大型项目里"传错类型"只有运行时才发现。解法：用 type hint + mypy（x: int = 10），在 IDE / 静态检查阶段拦截。Python 3.13 把 typing 模块的运行时开销进一步降低，类型注解对启动速度的影响可忽略。

3. 运算符

运算	运算符	说明
除法	`/`	永远返回 float（`4 / 2 == 2.0`）
整除	`//`	向下取整，返回 int（如果两边都是 int）
取余	`%`	`7 % 3 == 1`
乘方	`**`	`2 ** 10 == 1024`
矩阵乘	`@`	3.5+ 引入，配合 numpy 用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


>>> 7 / 2
3.5
>>> 7 // 2
3
>>> 7 % 2
1
>>> 2 ** 10
1024
>>> -7 // 2 # 整除是"向下"取整（向 -∞）
-4

整除负数是"向 -∞ 方向取整"，不是"截断"：-7 // 2 == -4 而不是 -3。需要"截断"就用 int(a / b)。

4. 字符串

4.1 字面量与转义

1
2
3
4
5
6


s1 = 'hello' # 单引号
s2 = "hello" # 双引号——和单引号完全等价
s3 = "he\"llo" # 反斜杠转义
s4 = r"C:\new\test" # 原始字符串，前缀 r，反斜杠不转义
s5 = """line1
line2""" # 三引号支持多行，行结束符会保留

字面量前缀	含义	典型场景
`r"..."`	原始字符串，反斜杠不转义	正则、文件路径
`b"..."`	字节串（bytes）	二进制协议、文件 IO
`f"..."`	格式化字符串（Py 3.6+）	拼字符串 + 变量
`R"..."` / `B"..."`	与 `r` / `b` 等价	见惯就行

1
2
3


# f-string 拼变量
name = "Python"
print(f"hello {name}! 1 + 1 = {1 + 1}") # hello Python! 1 + 1 = 2

原始字符串 r"…" 的常见坑：末尾不能放奇数个反斜杠——r"\" 是非法的。规避方法：把最后一个 \ 单独写 '\\'，或者用普通字符串拼。

4.2 拼接、索引、切片

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


s = "hello world"

# 拼接
"hi" + " " + "everyone" # "hi everyone"
"hi" * 3 # "hihihi"

# 索引（从 0 开始；负数从右开始）
s[0] # 'h'
s[-1] # 'd'（最后一个）
s[-2] # 'l'（倒数第二个）

# 切片（左闭右开）
s[0:5] # "hello"
s[6:] # "world"
s[:5] # "hello"
s[::2] # "hlowrd"（步长 2）
s[::-1] # "dlrow olleh"（反转）

字符串不可变——s[0] = 'H' 报错。要改字符只能新建：s = 'H' + s[1:]。

4.3 常用内置方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


s = "Hello, World!"

s.lower() # "hello, world!"
s.upper() # "HELLO, WORLD!"
s.strip() # 去首尾空白
s.split(",") # ["Hello", " World!"]——按分隔符切成列表
",".join(["a","b"]) # "a,b"——列表拼成字符串
s.replace("World", "Python") # "Hello, Python!"
s.find("World") # 7——子串位置；找不到返回 -1
"World" in s # True——子串判断
len(s) # 13——长度
s.startswith("He") # True
s.endswith("!") # True

5. 列表

列表是 Python 最常用的容器——有序、可变、类型可混。

1
2
3


fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "two", 3.0, [4, 5]] # 允许混类型（但不推荐）

5.1 增删改查

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


fruits = ["apple", "banana", "cherry"]

# 查
fruits[0] # "apple"
fruits[-1] # "cherry"
fruits[0:2] # ["apple", "banana"]——切片返回新列表

# 改
fruits[1] = "blueberry"

# 增
fruits.append("date") # 末尾追加
fruits.insert(1, "avocado") # 在索引 1 处插入
fruits.extend(["elderberry"]) # 末尾追加多个（合并可迭代对象）

# 删
fruits.remove("banana") # 按值删（只删第一个）
popped = fruits.pop() # 删末尾，返回被删元素
popped = fruits.pop(0) # 按索引删
del fruits[0] # 按索引删（不返回）
fruits.clear() # 清空

5.2 切片赋值

切片赋值可以改变列表大小——这是 Python 列表的独门技能：

1
2
3
4


nums = [1, 2, 3, 4, 5]
nums[1:3] = [20, 30, 40] # [1, 20, 30, 40, 4, 5]
nums[1:4] = [] # [1, 4, 5]——切片清空
nums[:] = [] # []——清空整个列表

5.3 常用方法

1
2
3
4
5
6
7
8
9


nums = [3, 1, 4, 1, 5, 9, 2, 6]

len(nums) # 8
nums.sort() # 就地排序，返回 None
nums.reverse() # 就地反转
nums.count(1) # 2——统计 1 出现次数
nums.index(9) # 5——首次出现位置
nums.copy() # 浅拷贝（等价于 nums[:]）
new = sorted(nums) # 不改原列表，返回新列表

坑：nums.sort() 返回 None！新手常写 sorted_nums = nums.sort() 然后 print(sorted_nums) 打印 None。正确做法：要保留原列表就用 new = sorted(nums)，要就地排序就别接返回值。

5.4 推导式（List Comprehension）

1
2
3
4
5
6
7
8


# 把偶数过滤出来再平方
squares_of_even = [x * x for x in range(10) if x % 2 == 0]
# [0, 4, 16, 36, 64]

# 二维展平
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [n for row in matrix for n in row]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

推导式可读性比 map + filter 高，是 Python 圈"地道写法"的标志之一。但不要嵌套超过两层，否则赶紧拆循环。

6. 流程控制

6.1 if / elif / else

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


x = int(input("请输入一个整数："))

if x < 0:
 x = 0
 print("Negative changed to zero")
elif x == 0:
 print("Zero")
elif x == 1:
 print("Single")
else:
 print("More")

Py 3.10+ 的新写法——match-case：

1
2
3
4
5
6
7
8


cmd = input("> ")
match cmd:
 case "quit" | "exit":
 print("bye")
 case "help":
 print("type quit to leave")
 case _:
 print(f"unknown: {cmd}")

match 不是 switch 的语法糖——它支持模式匹配（解构、类型判断、guard 子句），写解释器 / 解析器时格外好用。

6.2 for 循环

1
2
3


words = ["cat", "window", "defenestrate"]
for w in words:
 print(w, len(w))

带索引：

1
2


for i, w in enumerate(words):
 print(i, w)

Py 3.13 起 enumerate 的 start 参数更显眼了：

1
2
3


# 编号从 1 开始
for i, w in enumerate(words, start=1):
 print(i, w)

6.3 while / break / continue

1
2
3
4
5
6
7
8


n = 0
while n < 5:
 n += 1
 if n == 3:
 continue # 跳过本次
 if n == 4:
 break # 跳出循环
 print(n)

没有 do-while：Python 只用 while + if 实现"至少执行一次"的效果：

1
2
3
4
5


while True:
 user_input = input("> ")
 if user_input == "quit":
 break
 process(user_input)

7. 虚拟环境：pyenv + venv

为什么需要虚拟环境：不同项目依赖不同版本的包（django 2.x vs django 4.x），共用全局环境会冲突。虚拟环境给每个项目一份独立的 site-packages。

7.1 pyenv：管理 Python 版本

pyenv 是社区里最主流的多版本 Python 管理工具（macOS / Linux 原生支持，Windows 建议用 pyenv-win）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 安装 pyenv
curl -fsSL https://pyenv.run | bash

# 配置 shell（zsh 举例）
echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.zshrc
echo '[[ -d $PYENV_ROOT/bin ]] && export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.zshrc
echo 'eval "$(pyenv init - zsh)"' >> ~/.zshrc
source ~/.zshrc

# 验证
pyenv -v
# pyenv 2.6.27

装一个具体的 Python 版本（3.13 在 2024-10-07 发布后，pyenv 数小时内就支持了）：

1
2
3
4
5
6
7
8
9


# 查可安装的版本
pyenv install --list | grep "3\."

# 安装具体版本
pyenv install 3.13.13
pyenv uninstall 3.13.13

# 查看已装的所有版本
pyenv versions

虚拟环境插件：

1
2
3
4


git clone https://github.com/pyenv/pyenv-virtualenv.git \
 ~/.pyenv/plugins/pyenv-virtualenv
echo 'eval "$(pyenv virtualenv-init -)"' >> ~/.zshrc
source ~/.zshrc

创建 / 激活虚拟环境：

1
2
3
4
5
6
7
8
9


# 用 3.13.13 创建一个名为 myenv 的虚拟环境
pyenv virtualenv 3.13.13 myenv

# 激活
pyenv activate myenv
# 退出
pyenv deactivate
# 删除
pyenv uninstall myenv

切换当前目录默认版本（pyenv local 会在目录里写一个 .python-version）：

1
2
3
4


pyenv local 3.13.13 # 当前目录默认 3.13.13
pyenv local --unset # 取消目录级
pyenv global system # 取消全局设置
pyenv shell --unset # 取消 shell 临时设置

pyenv 适合 macOS / Linux。Windows 下推荐用 pyenv-win（用法几乎一致）或直接用 python -m venv（标准库自带，跨平台更稳）。

7.2 venv：标准库内置（跨平台）

不想装 pyenv？Python 自带的 venv 就够用，3.13 起默认就是 venv 而不是被废弃的 virtualenv。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


# 创建虚拟环境
python3 -m venv ~/.myenv

# 激活
# macOS / Linux：
source ~/.myenv/bin/activate

# Windows (PowerShell)：
~/.myenv/Scripts/Activate.ps1

# Windows (cmd)：
~/.myenv\Scripts\activate.bat

# 退出
deactivate

激活后 python 和 pip 都指向虚拟环境里的，包只装在 myenv/ 里，不污染全局。

Py 3.13 的 venv 改进：默认创建的 venv 不再包含 pip，需要用 python -m ensurepip --upgrade 引导安装。这是 PEP 668 推动"显式依赖"的一部分——避免 venv 一创建就拉一堆默认包。

7.3 项目级：用 pyenv + venv 协同

最工程化的做法：pyenv 管 Python 解释器版本，venv 管项目依赖。

1
2
3
4
5


# 在项目目录里
pyenv local 3.13.13 # 该目录自动用 3.13.13
python -m venv .venv # 创建 venv（推荐 .venv 而不是 .env）
source .venv/bin/activate
pip install -r requirements.txt

把 .venv/ 写进 .gitignore：

1
2
3


.venv/
__pycache__/
*.pyc

8. pip 与国内镜像

8.1 基础命令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


# 引导并升级 pip（Py 3.13 之后 venv 默认不带 pip）
python -m ensurepip --upgrade
python -m pip install --upgrade pip

# 装包
pip install requests
pip install requests==2.31.0 # 指定版本（requests 2.31.0 发布于 2023-05-22）
pip install -r requirements.txt # 批量装

# 查包
pip list
pip show requests

# 导出依赖
pip freeze > python_modules.txt

# 卸载
pip uninstall requests
pip freeze | xargs pip uninstall -y # 一键全卸
pip uninstall -r python_modules.txt -y # 按文件卸

8.2 国内镜像（强烈推荐）

直连 PyPI 在国内经常超时，挂个国内源秒装：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# 清华源
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

# 阿里源
pip config set global.index-url https://mirrors.aliyun.com/pypi/simple

# 腾讯源
pip config set global.index-url https://mirrors.cloud.tencent.com/pypi/simple

# 豆瓣源
pip config set global.index-url https://pypi.douban.com/simple/

# 网易源
pip config set global.index-url https://mirrors.163.com/pypi/simple/

pip config list
# Writing to C:\Users\Administrator\AppData\Roaming\pip\pip.ini

设置后会写入 ~/AppData/Roaming/pip/pip.ini（Windows）或 ~/.config/pip/pip.conf（macOS / Linux）：

1
2
3
4


[global]
index-url = https://mirrors.aliyun.com/pypi/simple
[install]
trusted-host = mirrors.aliyun.com

配镜像后必须关掉代理——很多公司开发网络走代理，配了国内源反而走代理到国外、慢得离谱。unset http_proxy && unset https_proxy（macOS / Linux）或 PowerShell Remove-Item Env:http_proxy（Windows）后再装包。

8.3 代理场景

1
2
3


# Windows cmd 临时挂代理
set http_proxy=http://127.0.0.1:1081
set https_proxy=http://127.0.0.1:1081

1
2
3


# macOS / Linux 临时挂代理
export http_proxy=http://127.0.0.1:1081
export https_proxy=http://127.0.0.1:1081

装包失败先看这个顺序：(1) 是不是公司代理挡了？(2) 是不是 SSL 证书问题？(3) 是不是镜像源 5xx 临时挂了？三步都排完再怀疑代码。

8.4 用 `pipx` 装命令行工具

有些工具是命令行型的（black、ruff、httpie），用 pip 装到全局会污染 site-packages，推荐用 pipx：

1
2


pipx install black # 隔离环境装，自动加到 PATH
pipx upgrade-all

9. 常见坑

9.1 缩进错误

1
2
3


if x:
 print("a")
 print("b") # IndentationError：缩进不一致

规避：编辑器装 Python 扩展自动缩进 4 空格，混用 Tab / 空格是禁忌。

9.2 可变默认参数

1
2
3
4
5
6


def add_item(item, bucket=[]): # 坑！
 bucket.append(item)
 return bucket

add_item(1) # [1]
add_item(2) # [1, 2]——bucket 在函数定义时创建一次，跨调用共享

修法：

1
2
3
4
5


def add_item(item, bucket=None):
 if bucket is None:
 bucket = []
 bucket.append(item)
 return bucket

Why：Python 默认参数在函数定义时只求值一次，不是每次调用都新建。这是 Python 最经典的设计陷阱。

9.3 浮点比较

1
2
3
4


>>> 0.1 + 0.2 == 0.3
False
>>> 0.1 + 0.2
0.30000000000000004

修法：用 decimal.Decimal 或 math.isclose(a, b)：

1
2


import math
math.isclose(0.1 + 0.2, 0.3) # True

9.4 字符串拼接性能

1
2
3
4
5
6
7


# 反例：循环里用 += 拼字符串
s = ""
for x in range(10000):
 s += str(x) # 每次新建对象，O(n²)

# 正解：用 join
s = "".join(str(x) for x in range(10000)) # O(n)

9.5 import 顺序

PEP 8 推荐：

标准库
第三方库
本地应用 / 库

每组之间空一行：

1
2
3
4
5
6
7


import os
import sys

import numpy as np
import requests

from myproject.utils import helper

9.6 `is` vs `==`

1
2
3
4


a = [1, 2, 3]
b = [1, 2, 3]
a == b # True——值相等
a is b # False——不是同一个对象

小整数缓存例外：a = 256; b = 256; a is b 可能是 True，因为 CPython 缓存了 [-5, 256] 的小整数。但不要依赖这个，用到 is 的场景几乎都是"判断 None / 哨兵对象"。

9.7 不要用 `from module import *`

1

from os import * # 会污染命名空间

import * 让代码不可读、不可重构——open() 是 os.open 还是 builtins.open？避免。

小结

一句话总结：Python 的"易学"在语法——缩进代替大括号、动态类型、丰富的内置容器；Python 的"工程难点"在依赖管理——pyenv 管版本、venv 管隔离、pip 管包，配上国内镜像速度起飞。

5 个最常用内置：

1
2
3
4
5


len(s) # 长度
s.split(",") # 切
",".join(list) # 拼
range(10) # 整数序列
enumerate(list) # 索引 + 值

5 个最容易踩的坑：

可变默认参数 def f(bucket=[]) → bucket 跨调用共享
浮点比较 0.1 + 0.2 != 0.3 → 用 math.isclose
sort 不返回 nums.sort() 返回 None → 要新列表用 sorted(nums)
缩进混 Tab / 空格 → 编辑器强制 4 空格
循环里 += 拼字符串 → 用 "".join(...)

5 个 3.13 时代的新习惯：

默认用 f-string，不要再用 % 或 .format()
路径用 pathlib.Path，不要用 os.path 拼字符串
类型注解 + mypy，别只靠运行时
数据类 dataclass 替代手写 __init__
依赖锁 pip freeze 进 git，CI / 生产环境必须可复现

2024+ 视角：Python 3.13 JIT 与 free-threading

Python 3.13 关键变化（已在用）

实验性 JIT 编译器（--enable-experimental-jit）：简单计算性能 +10-15%
改进的 REPL：默认带颜色高亮、多行粘贴友好、exit_code 显示
GIL 改进：--disable-gil 实验标志（free-threading 铺垫）
类型注解改进：type X = int 类型别名支持
弃用 locale.resetlocale()：编码问题改用 locale.setlocale(LC_ALL, "") 配合 open(..., encoding="utf-8")

Python 3.14（2025-10 计划）核心变化

PEP 779：Free-Threaded Python 官方支持（GIL 可移除）
PEP 750：Template Strings（t"..." 模板字符串）
PEP 649：延迟求值注解（注解默认不求值，启动更快）
PEP 761：PyPI 签名归档格式更新

Free-Threading 时代的 Python 并发

1
2
3
4
5
6
7


# 装 free-threaded Python
python3.14t

# 检查 GIL 是否启用
python -c "import sys; print(sys.flags.gil)"
# -1 = 启用 GIL
# 0 = 禁用 GIL（free-threading）

影响：

CPU 密集型：终于可以用多线程跑满多核
生态兼容：numpy / pandas / requests 都需要更新
AI / 数值计算：巨大收益（不再需要 multiprocessing）

2024+ 数值计算新范式

`numpy` 2.x

1
2
3
4
5
6
7
8
9


# numpy 2.0+ 默认 64 位
import numpy as np

# Typed scalars
arr = np.array([1, 2, 3], dtype=np.int32)
print(type(arr[0])) # numpy.int32（不是 Python int）

# String dtype 标准化
arr = np.array(['a', 'b', 'c'], dtype=np.str_)

`polars` 1.x 替代 `pandas` 部分场景

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


import polars as pl

# 比 pandas 快 5-30 倍
df = pl.read_parquet("data.parquet")
result = (
 df
 .filter(pl.col("amount") > 100)
 .group_by("category")
 .agg(pl.col("amount").sum())
)

polars 优势：

Rust 写的，多线程 + SIMD
延迟求值（LazyFrame）
内存效率高 50%
不依赖 NumPy

`pydantic` 2.x（Rust 核心）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


from pydantic import BaseModel, Field
from datetime import datetime

class User(BaseModel):
 id: int
 name: str = Field(min_length=1, max_length=100)
 email: str
 created_at: datetime

# 自动验证 + 序列化（Rust 写的核心，速度 +20x）
user = User(id=1, name="Alice", email="alice@example.com", created_at="2024-01-01")

Python 异步生态 2024+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# asyncio + uvloop（替代默认事件循环）
import asyncio
import uvloop

asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

# FastAPI 0.110+（主流 Web 框架）
from fastapi import FastAPI
app = FastAPI()

@app.get("/users/{user_id}")
async def get_user(user_id: int):
 return {"id": user_id, "name": "Alice"}

# SQLAlchemy 2.0+ 异步
from sqlalchemy.ext.asyncio import AsyncSession
async with AsyncSession(engine) as session:
 result = await session.execute(select(User).where(User.id == user_id))

AI / LLM 时代 Python 生态

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# LangChain 0.3+（LLM 应用框架）
from langchain.chat_models import init_chat_model
from langchain_core.messages import HumanMessage, SystemMessage

model = init_chat_model("gpt-4o", model_provider="openai")
response = model.invoke([
 SystemMessage("你是一个严谨的技术写作助手"),
 HumanMessage("用一句话解释 GIL 是什么")
])
print(response.content)

# 国产替代
from langchain.chat_models import init_chat_model
qwen = init_chat_model("qwen-plus", model_provider="dashscope")

# 端侧小模型
from llama_cpp import Llama
llm = Llama(model_path="./qwen2.5-7b.gguf", n_ctx=4096)
output = llm("Q: 1+1?\nA:", max_tokens=20)

Python 包管理 2024+ 新工具

工具	特点	2024+
uv（Astral 出品）	装包比 pip 快 10-100 倍	强烈推荐
poetry	依赖锁定 + 虚拟环境	主流企业
pdm	PEP 582 标准	国产活跃
rye	统一 Python + 包管理	实验性
hatch	现代构建系统	库作者首选

1
2
3
4
5
6
7


# uv 一行替代 pip / pip-tools / venv / pyenv
curl -LsSf https://astral.sh/uv/install.sh | sh

uv python install 3.13
uv venv
uv pip install -r requirements.txt
uv pip sync requirements.lock

2024+ 工具链推荐

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


现代 Python 项目
├── 运行时：Python 3.13（3.14 free-threading 实验）
├── 包管理：uv 0.4+（推荐）/ poetry 1.8+
├── 类型检查：mypy 1.13 / pyright 1.1（更快）
├── 格式化：ruff 0.6+（替代 black + isort + flake8）
├── 测试：pytest 8 + coverage
├── 静态分析：ruff + mypy
├── 文档：mkdocs-material 9
├── 异步：asyncio + uvloop
├── Web：FastAPI 0.110+ + SQLAlchemy 2.0
├── 数据：polars 1.x / pandas 2.x
├── AI：LangChain 0.3+ / vLLM / llama-cpp-python
└── 部署：Docker + Uvicorn

数据来源：

Go 入门与基础：从 GOPATH 到 Module 的平滑过渡

Thu, 15 Feb 2018 00:00:00 +0800

前置知识

至少写过 Java / Python / C 任一语言
了解命令行基础（cd ls export）
安装过开发工具（JDK / Python / Node.js）

为什么 2018 年学 Go

Go（又称 Golang）由 Google 的 Robert Griesemer、Rob Pike、Ken Thompson 在 2007 年设计，2009 年开源，2012 年发布 1.0。到 2018 年，Go 已经在云原生、DevOps、命令行工具领域成为事实标准：

Docker（2013-03 开源）—— Go 写的
Kubernetes（2014-06 开源）—— Go 写的
Prometheus（2016-05 1.0）—— Go 写的
etcd / Consul / Terraform —— 都是 Go

Go 1.11 在 2018-08 引入 Go Module（go.mod）——彻底解决 GOPATH 时代的所有依赖管理痛点。本文带你从 0 到 1 搭建 Go 环境，跑通第一个 Hello World。

一、安装 Go

1.1 下载与安装

官网：https://golang.org/（2019 年后主域名变 https://go.dev/）
中文文档：https://studygolang.com/pkgdoc
下载页：https://go.dev/dl/

1
2
3
4
5


# Windows MSI 安装包（示例：1.19.4）
# https://go.dev/dl/go1.19.4.windows-amd64.msi

# 默认安装路径 <DEV_DIR>go
# 环境变量 Path 自动加 <DEV_DIR>go\bin

升级：直接覆盖原安装路径即可。

1.2 验证

1
2


go version
# go version go1.19.4 windows/amd64

1.3 源码获取

1
2
3


git clone https://go.googlesource.com/go
# 或 GitHub 镜像
git clone https://github.com/golang/go.git

二、GOPATH 时代：理解"工作区"概念

2018 年之前，Go 项目必须放在 $GOPATH/src 下才能编译——这与 Java 的 Maven、Python 的 venv、Node 的 npm 都不同。

1
2
3
4
5
6
7


# 默认 GOPATH
C:\Users\Administrator\go

# go env 关键变量
go env GOPATH
go env GOROOT
go env GOPROXY

2.1 早期项目结构

1
2
3
4
5
6


$HOME/go/
└── src/
 └── github.com/
 └── yourname/
 └── hello/
 └── main.go

1
2


mkdir -p $HOME/go/src/github.com/yourname/hello
cd $HOME/go/src/github.com/yourname/hello

2.2 Go 1.11 之前的痛点

项目必须放 $GOPATH/src 下，否则 import 找不到
没有版本概念，go get 永远拉最新 master
第三方包版本冲突时只能 git clone 到本地再 replace
公司内部包上传私有 Git 仓库，每次更新全靠 go get -u

这些痛点催生了 2018 年的 Go Module（1.11 引入，1.14 默认开启）。

三、Go Module 时代（Go 1.11+）

3.1 创建一个 Hello World

1
2
3
4
5
6


# 任意位置都可（不再强制 $GOPATH/src）
mkdir E:\workspace\go\tutorial\01hello
cd E:\workspace\go\tutorial\01hello

go mod init example/hello
# go: creating new go.mod in module example/hello

go.mod 内容：

1
2
3


module example/hello

go 1.19

新建 hello.go：

1
2
3
4
5
6
7


package main

import "fmt"

func main() {
 fmt.Println("Hello, World!")
}

1
2


go run .
# Hello, World!

3.2 导入第三方包

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

import (
 "fmt"
 "rsc.io/quote"
)

func main() {
 fmt.Println(quote.Go())
}

1
2
3


go mod tidy # 拉取缺失依赖、清理多余
go run .
# Don't communicate by sharing memory, share memory by communicating.

go.mod 自动加了一行：

1

require rsc.io/quote v1.5.2

go.sum 记录依赖哈希——保证其他机器拉下来版本一致。

四、Hello 进阶：双模块调用

官方教程 https://go.dev/doc/tutorial/create-module 演示了"两个模块相互调用"的经典场景。

4.1 创建 greetings 模块

1
2
3


mkdir E:\workspace\go\tutorial\02module\greetings
cd E:\workspace\go\tutorial\02module\greetings
go mod init example.com/greetings

greetings.go：

1
2
3
4
5
6
7
8


package greetings

import "fmt"

func Hello(name string) string {
 message := fmt.Sprintf("Hi, %v. Welcome!", name)
 return message
}

4.2 创建调用方 hello 模块

1
2
3


mkdir E:\workspace\go\tutorial\02module\hello
cd E:\workspace\go\tutorial\02module\hello
go mod init example.com/hello

hello.go：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import (
 "fmt"
 "example.com/greetings"
)

func main() {
 message := greetings.Hello("Gladys")
 fmt.Println(message)
}

4.3 本地 replace

模块未发布，直接 go run . 会报"找不到 example.com/greetings"。

1
2
3
4
5


# 用本地路径替换远程引用
go mod edit -replace example.com/greetings=../greetings
go mod tidy
go run .
# Hi, Gladys. Welcome!

go.mod 会多一行：

1

replace example.com/greetings => ../greetings

发布时把 replace 行删掉，调用方用 go get example.com/greetings@latest 即可。

4.4 错误处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package greetings

import (
 "errors"
 "fmt"
)

func Hello(name string) (string, error) {
 if name == "" {
 return "", errors.New("empty name")
 }
 message := fmt.Sprintf("Hi, %v. Welcome!", name)
 return message, nil
}

调用方：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import (
 "fmt"
 "log"
 "example.com/greetings"
)

func main() {
 log.SetPrefix("greetings: ")
 log.SetFlags(0)

 message, err := greetings.Hello("")
 if err != nil {
 log.Fatal(err)
 }
 fmt.Println(message)
}

4.5 随机问候

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package greetings

import (
 "errors"
 "fmt"
 "math/rand"
)

func Hello(name string) (string, error) {
 if name == "" {
 return name, errors.New("empty name")
 }
 message := fmt.Sprintf(randomFormat(), name)
 return message, nil
}

func randomFormat() string {
 formats := []string{
 "Hi, %v. Welcome!",
 "Great to see you, %v!",
 "Hail, %v! Well met!",
 }
 return formats[rand.Intn(len(formats))]
}

4.6 多人问候

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


func Hellos(names []string) (map[string]string, error) {
 messages := make(map[string]string)
 for _, name := range names {
 message, err := Hello(name)
 if err != nil {
 return nil, err
 }
 messages[name] = message
 }
 return messages, nil
}

4.7 单元测试

greetings_test.go：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package greetings

import (
 "regexp"
 "testing"
)

func TestHelloName(t *testing.T) {
 name := "Gladys"
 want := regexp.MustCompile(`\b` + name + `\b`)
 msg, err := Hello("Gladys")
 if !want.MatchString(msg) || err != nil {
 t.Fatalf(`Hello("Gladys") = %q, %v, want match for %#q, nil`, msg, err, want)
 }
}

func TestHelloEmpty(t *testing.T) {
 msg, err := Hello("")
 if msg != "" || err == nil {
 t.Fatalf(`Hello("") = %q, %v, want "", error`, msg, err)
 }
}

1
2


go test
go test -v

4.8 编译安装

1
2
3
4
5
6
7
8


cd hello
go build
# Windows 下生成 hello.exe

# 配置 GOBIN 后可 go install
go env -w GOBIN=E:\workspace\go\bin
go install
# hello.exe 出现在 GOBIN 目录下

五、Go 1.x 历史里程碑

版本	发布日期	关键特性
1.0	2012-03	第一个稳定版
1.5	2015-08	编译器自举（用 Go 写 Go 编译器）
1.7	2016-08	context 包、Vendor 目录
1.11	2018-08	Go Module 引入
1.13	2019-09	GOPROXY 增强、错误包装
1.14	2020-02	Module 默认开启
1.16	2021-02	`go install` 行为变化（用 `@version`）
1.18	2022-03	泛型、模糊测试、Workspace
1.21	2023-08	PGO、`log/slog`、`slices` `maps` `cmp` 标准库
1.22	2024-02	for 循环变量行为改变
1.24	2025-02	泛型类型别名、Swiss Table map

六、环境变量核心配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 关键环境变量
go env GOROOT # Go 安装根目录
go env GOPATH # 工作区（默认 %USERPROFILE%\go）
go env GOMODCACHE # 依赖缓存（C:\Users\Administrator\go\pkg\mod）
go env GOPROXY # 依赖代理
go env GOSUMDB # 校验数据库
go env GOBIN # go install 输出目录
go env GO111MODULE # off / on / auto（1.16+ 默认 on）
go env GOFLAGS # 全局 flags
go env CGO_ENABLED # 是否启用 CGO
go env GOOS / GOARCH # 交叉编译目标

6.1 国内代理

1
2


go env -w GOPROXY=https://goproxy.cn,direct
go env -w GOSUMDB=sum.golang.org

七牛、阿里云、字节跳动都提供 GOPROXY 镜像——goproxy.cn 是七牛维护的官方推荐镜像。

6.2 GO111MODULE 三种模式

off：禁用 module，沿用 GOPATH 模式（基本没人用了）
on：完全用 module，不去 GOPATH 找
auto（默认）：当前目录在 GOPATH/src 之外且有 go.mod 才启用 module

Go 1.16 起 auto 默认行为就是 on——新项目务必用 module。

七、IDE 与插件

7.1 IDEA / GoLand

装插件 Go、Go Template
设置 GOROOT（Go 安装根目录）
启用 Go Modules

7.2 VS Code

装 Go 扩展（golang.go）—— 提供 LSP、自动补全、调试
推荐 gopls（Go 官方语言服务器）

7.3 快捷键（IDEA）

快捷键	作用
`Alt + Enter`	生成头注释 / 快速修复
`Ctrl + Shift + T`	选择生成测试

八、常见问题

8.1 Delve 调试器版本不匹配

1

WARNING: undefined behavior - version of Delve is too old for Go version 1.21.0

Go 升级了 1.21，但 IDE 还在用老 Delve。解决：

1
2
3
4


go install github.com/go-delve/delve/cmd/dlv@latest
# 会在 GOPATH/bin 下生成 dlv.exe
# 复制到 IDEA 插件目录
# C:\Users\Administrator\AppData\Roaming\JetBrains\IntelliJIdea2023.1\plugins\go-plugin\lib\dlv\windows\dlv.exe

8.2 GOPROXY 拉不到私有仓库

1
2


go env -w GOPRIVATE=github.com/yourcompany/*
# 私有仓库不走代理、不走 sum 校验

九、下一步

基础语法：《Go 语言圣经》https://gopl-zh.github.io/
Web 框架：Gin（轻量）、Echo（极简）、Beego（全栈）
ORM：GORM（最流行）、XORM、Ent
微服务：gRPC-Go、Kitex（字节）、Kratos（哔哩哔哩）
云原生：Kubernetes Operator、Client-Go

参考资料

Go 官方教程：https://go.dev/doc/tutorial/
Go 中文文档：https://studygolang.com/
《Go 程序设计语言》（The Go Programming Language）—— Alan A.A. Donovan / Brian W. Kernighan
Go Module 提案：https://go.dev/design/24301-versioned-go-modules

2024+ 视角：Go 1.23 / 1.24 与现代 Go 工程实践

Go 版本演进（2024+ 视角）

版本	发布时间	关键特性
1.21	2023-08	PGO、`log/slog`、标准库 `slices` / `maps` / `cmp`
1.22	2024-02	`for` 循环变量范围修正、HTTP 路由增强
1.23	2024-08	iter 包（迭代器协议）、`unique` 包、`structs` 标签、`maps` / `slices` 增量
1.24	2025-02	泛型类型别名、Swiss Table Map 性能 +30%、`go.mod` toolchain 字段
1.25（计划）	2025-08	协程本地存储、`sync` 包增强

Go 1.23 必学特性

`iter` 包 + range-over-func

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// 1.23 起标准库支持"自定义迭代器"
func Backward[T any](s []T) iter.Seq[T] {
 return func(yield func(T) bool) {
 for i := len(s) - 1; i >= 0; i-- {
 if !yield(s[i]) {
 return
 }
 }
 }
}

// 使用（像 Python generator）
for v := range Backward([]int{1, 2, 3}) {
 fmt.Println(v) // 3 2 1
}

`unique` 包：值类型化

1
2
3
4
5
6
7
8


// 替代 map[string]struct{} 做 set，内存省 50%
import "unique"

var once unique.Handle[string]

func intern(s string) string {
 return once.Value(s) // 同字符串只存一份
}

`maps` / `slices` 标准库

1
2
3
4
5


// 1.21+ 标准库，不再用 golang.org/x/exp
slices.Sort(mySlice)
slices.Reverse(mySlice)
maps.Clone(myMap)
maps.Copy(dst, src)

Go 1.24 关键变化

泛型类型别名：type Set[T comparable] = map[T]struct{} 完整支持
Swiss Table Map：内部 map 性能 +30%，内存占用 -20%
go.mod toolchain 字段：

1
2
3
4


// go.mod
module my-project
go 1.24
toolchain go1.24.1 // 锁编译工具链

PGO（Profile-Guided Optimization）2024+ GA

1
2
3
4
5
6
7


# 1. 收集 CPU profile
go test -cpuprofile=cpu.prof -bench=.

# 2. 用 profile 编译
go build -pgo=cpu.prof -o myapp .

# 性能提升 5-15%（生产级服务）

PGO 在 Go 1.21 起 GA，生产环境强烈建议开——零成本收益。

Go 工具链 2024+ 新范式

`go run` 简化开发

1
2
3
4
5


# 跑单个文件（不需要 go.mod）
go run main.go

# 跑远程代码
go run golang.org/x/example/hello@latest

`go work` 多模块开发

1
2
3
4


# monorepo 多模块
go work init
go work use ./pkg1 ./pkg2
go work edit -replace github.com/me/lib=./lib

`go test` 增强

1
2
3
4
5
6


# 模糊测试（Fuzzing）
go test -fuzz=FuzzParse -fuzztime=30s

# 代码覆盖率 HTML 报告
go test -coverprofile=cover.out
go tool cover -html=cover.out -o cover.html

Go 1.22 的 for 循环"修大坑"

1
2
3
4
5
6
7
8
9


// 1.22 之前：循环变量共享
for _, v := range []int{1, 2, 3} {
 go func() {
 fmt.Println(v) // 全部输出 3（v 被覆盖）
 }()
}

// 1.22+：每次迭代有独立 v
// 输出 1 2 3（符合直觉）

生产意义：闭包捕获循环变量的并发 bug 全部消失。

依赖管理 2024+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


# go.mod 必填字段
module my-project

go 1.24

require (
 github.com/gin-gonic/gin v1.10.0
 github.com/spf13/viper v1.19.0
)

// 间接依赖
require (
 github.com/xx/yy v1.0.0 // indirect
)

// 替换（本地开发）
replace github.com/me/lib => ../lib

// 私有仓库不走 proxy / sum
exclude github.com/me/internal v1.0.0

主流 Web 框架 2024+

框架	定位	2024+
Gin	主流 HTTP 框架	仍是中文社区首选
Echo	极简高性能	性能好
Fiber	Express 风格（基于 fasthttp）	性能 SOTA
Chi	轻量 + 标准库风格	标准项目首选
Hertz	字节跳动	国产高性能
Kratos	B 站 / 微服务	复杂业务首选
go-zero	极客时间	国内微服务首选

微服务框架对比 2024+

框架	维护方	特点
go-zero	好未来 / 万俊峰	国内主流 + 自带 goctl 代码生成
Kratos	B 站	字节系 + gRPC + 配置中心
Kitex	字节跳动	字节系 + 高性能 RPC
Istio + Go	Google	服务网格
CloudWeGo	字节跳动	字节系全家桶（Hertz + Kitex + Thrift）

2024+ 实战坑

go 1.22+ for 循环变量范围修正——老项目升级后并发代码可能行为变化，要全量回归
PGO 默认开启与否——go env GOEXPERIMENT 控制
Swiss Table Map——某些老代码依赖 map 迭代顺序的会有问题
泛型类型推断——编译器越来越聪明，但过度嵌套的泛型仍会写得很烂

2024+ 推荐组合

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


Go 后端服务（生产）
├── Go 1.24 + toolchain 锁版本
├── go-zero / Kratos（微服务）
├── GORM / SQLx（ORM）
├── go-redis / redigo（Redis）
├── zap / zerolog（日志，slog 标准库）
├── prometheus + Grafana（监控）
├── OpenTelemetry（Tracing）
├── go test + testify（单测）
├── gofuzz（模糊测试）
├── PGO 开启（性能 +5-15%）
└── go.mod 用 BOM（Bill of Materials）管理版本

Kubernetes 入门：何时需要 K8s 与集群架构总览

Thu, 15 Jun 2017 00:00:00 +0800

写于 2017-06，背景：Kubernetes 1.7 刚 GA、Docker Swarm 还在与 K8s 掰手腕，etcd v3.2、Helm v2 已经成熟。本文聚焦"为什么需要 K8s"与"集群由哪些组件组成"，帮你建立全局视图。

一、为什么需要 Kubernetes

应用在不同规模下，对"运行环境"的需求完全不同：

规模	解决方案	痛点
1 台机器	docker + docker-compose	一台机器上启动 N 个容器，简单直接
3~5 台	每台单独配置 + 负载均衡器	应用升级、机器扩容、版本回滚需要手工操作
十几到几十台	重复性脚本 + Ansible	加机器 1 小时、版本回滚半小时、灰度发布？祈祷吧
上百到上千台	Kubernetes	一个 `kubectl scale` 完成扩容、`kubectl rollout undo` 完成回滚

Kubernetes（k8s） 是 Google 在 2014 年开源的容器编排系统（2015-07 v1.0 GA），前身是 Borg 系统。它的目标很简单：让你像操作一台机器一样操作上千台机器组成的集群。

“谈笑间，樯橹灰飞烟灭”——加机器、版本升级、灰度发布，都只是一个 YAML + 一个命令的事。

二、集群架构总览

K8s 集群分两类节点：

master（主节点）：控制平面，不跑业务负载，通常 1 个或 3 个（高可用）
worker（工作节点）：跑 Pod，可以是虚拟机或物理机，可以不断加

2.1 核心组件

组件	角色
`kube-apiserver`	API 服务器，对外暴露 Kubernetes HTTP API，是整个集群的"门卫"
`etcd`	分布式键值数据库，保存集群所有状态（Pod、Service、ConfigMap 等）
`kube-scheduler`	调度器，决定 Pod 调度到哪个 worker 节点
`kube-controller-manager`	控制器集合（Deployment/Node/Endpoint 等 30+ 控制器）
`cloud-controller-manager`	与云服务商集成（负载均衡、存储卷、节点生命周期）
`kubelet`	worker 节点上的"代理"，负责 Pod 生命周期
`kube-proxy`	worker 节点上的网络代理，维护 iptables/IPVS 规则
`container runtime`	容器运行时（containerd / CRI-O / Docker），真正运行容器

2.2 Pod 是什么

Pod 是 K8s 调度和管理的最小单位，不是容器。

一个 Pod 可以包含 1 个或多个容器
同一个 Pod 里的容器共享网络（同一个 IP）、存储卷、生命周期
Pod 有自己的虚拟 IP（ClusterIP）
主节点根据资源、亲和性、污点等策略，把 Pod 调度到合适的 worker

把 Pod 想象成"一个逻辑主机"，里面的容器就像同一台机器上的进程——它们共享网络、可以本地通信。

三、kubectl 速查

kubectl 是 K8s 的命令行工具，几乎所有操作都通过它完成。

3.1 查看基本信息

1
2
3
4
5
6
7
8


# 客户端 + 服务端版本
kubectl version

# 可用 API 版本
kubectl api-versions

# 某个资源类型的字段说明
kubectl explain deployment.apiVersion

3.2 命名空间

1
2
3
4
5
6
7
8


# 查所有命名空间下的资源
kubectl get all -o wide -A

# 查某个命名空间
kubectl get all -o wide -n test

# 删除命名空间（会删除里面所有资源）
kubectl delete ns dev

3.3 Pod 操作

1
2
3
4
5
6
7
8


# 强制删除卡在 Terminating 的 Pod
kubectl delete pods nacos-846d6cd5f7-t7h2x -n dev --grace-period=0 --force

# 查看 Pod 日志
kubectl logs -f pod-name -n namespace

# 进入 Pod 终端
kubectl exec -it pod-name -n namespace -- sh

3.4 资源缩写

资源	缩写
pods	po
services	svc
deployments	deploy
namespaces	ns
nodes	no
configmaps	cm
persistentvolumes	pv

四、版本节奏

K8s 一年发布 3 个版本（1.x 时代），从 1.28 起改为每年 4 个版本：

大版本	GA 时间	维护状态
1.28	2023-08-16	支持到 2024-10-28
1.27	2023-06-14	支持到 2024-06-28
1.26	2022-12-08	支持到 2024-02-28
1.25	2022-08-23	已 EOL

版本约定：x.y.z，x 是大版本，y 是次要版本，z 是补丁版本。例如 1.28.5 是 1.28 的第 5 个补丁。

升级建议：生产集群不要追新，每年升 1~2 个次要版本即可。大版本升级前必须看 CHANGELOG 里 kubelet 参数、API 废弃、依赖变化。

五、何时不该上 K8s

不是所有场景都适合 K8s：

单机应用：直接 docker-compose，引入 K8s 反而增加复杂度
状态强一致的服务（如传统 MySQL 主从）：运维复杂度高，不如托管 RDS
小团队（< 5 人）：学习曲线陡峭，K8s 本身的运维成本可能高于业务价值
没有 DevOps 文化：K8s 是工具，本质还是要 CI/CD + GitOps + 监控告警体系

决策树：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


应用规模 → 单机？
 ↓ yes
 docker-compose
 ↓ no
应用规模 → 3~10 台？
 ↓ yes
 docker swarm 或 k3s（轻量）
 ↓ no
业务高可用要求？
 ↓ 高
 Kubernetes（生产集群 + 高可用 + GitOps）
 ↓ 低
 k3s / kubeadm 单 master

六、前置知识 / 下一步

前置：

熟练使用 Docker（构建镜像、容器操作、网络模式）
理解 Linux 网络（iptables、IPVS、网桥）
掌握至少一种证书签发工具（cfssl / openssl）

下一步：

K8s 工具链速装（2018-12-15）—— kubectl / kubeadm / minikube / helm 一文搞定
二进制部署完整路径（2020-03-15）—— 理解集群组件如何协作
Kubeadm 一键部署（2022-06-15）—— 生产环境最常见的部署方式