后端第六课：Python 语法速通（0 基础入门，AI 应用开发的第一门语言）

👋 我是 Yulia，一线 AI 应用开发工程师：4 年工程经验，在职做大模型应用落地。

只写一件事——把最新 AI 技术讲成人话 + 给你能直接跑通的代码（全部本机实测，不搬运不注水）。
有用就点个关注，持续更新大模型应用的前沿实战。

📚 本文是《后端开发从入门到靠谱》系列第 6 篇。第五课我们选定了主线语言Python + FastAPI——这一篇正式开始学 Python 语法。整个系列共 20 篇，我会在关键知识点处标注 Java / Go 的对应写法，让你边学边建立"三语言对照感"。关注我，不错过后续 14 篇。

上一课我们解决了"学什么语言"，这一课解决"怎么学"。网上 Python 语法教程很多，但大多是零散的知识点罗列——学了几个月，还是写不出一个完整的小项目。这篇不一样：我按写程序时的真实思考顺序组织语法（先存数据 → 再控制流程 → 再组织代码），并且每一节都标注 Java / Go 的差别，让你从一开始就建立三语言对照感。

读完你会拿到：

• Python 全部核心语法：变量、数据类型、控制流、函数、类、异常、模块
• 一个思维模型：动态类型 vs 静态类型——三语言差异的总根源
• 每个语法点的 Java / Go 对照写法（差别一目了然）
• 一套学完就能写小脚本、为 FastAPI 和 AI 应用打底的语法体系

先看全景图，建立全局认知：

一、先建立总思维模型：动态类型 vs 静态类型

学 Python 语法之前，必须先理解一个概念——它决定了后面所有语法的样子。

Python 是动态类型语言，Java 和 Go 是静态类型语言。差别在哪？

# Python：变量没有"类型声明"，赋值什么就是什么age=25# 是整数age="二十五"# 现在变成了字符串，完全合法

// Java：变量必须声明类型，之后不能变intage=25;// 明确声明是 intage="二十五";// 编译直接报错！

// Go：同样静态类型，但写法更简洁age:=25// := 自动推断类型为 intage="二十五"// 编译报错

一句话总结差别：静态类型（Java/Go）在"编译时"就把类型锁死，错误在写代码时就被编译器抓住；动态类型（Python）在"运行时"才检查类型，写起来灵活，但错误可能到运行时才爆出来。

这个模型能解释后面的一切：

• 为什么 Python 不需要写int、string这些类型名（自动推断）；
• 为什么 Python 的同一个变量能存任何类型（运行时才知道）；
• 为什么 Java/Go 代码更"啰嗦"但更"安全"（类型提前锁定）。

二、变量与数据类型

2.1 变量：直接赋值即可

Python 定义变量不需要任何关键字，直接赋值：

name="Yulia"# 字符串 strage=25# 整数 intprice=19.9# 浮点数 floatis_student=True# 布尔 bool

Java 对照：String name = "Yulia"; int age = 25;（类型在前，分号结尾）
Go 对照：name := "Yulia"（冒号等号自动推断，或var name string = "Yulia"）

注意两个 Python 细节：

• 语句结尾没有分号（Java/Go 都要分号）；
• 代码块用缩进表示（Java/Go 用大括号{}）。缩进是 Python 语法的核心，后面每节都会体现。

2.2 数字与字符串

a=10+3# 13b=10/3# 3.3333... 除法一定得浮点数（Java/Go 的整数除法会截断！）c=10//3# 3 整除d=10%3# 1 取余e=2**10# 1024 幂运算（Java/Go 没有 ** 运算符）s="hello"+" "+"world"# 字符串拼接print(f"我有{age}岁")# f-string 格式化，Python 最推荐的写法

Java 对照：10 / 3结果是3（整数除法截断），需要10.0 / 3才得浮点数——这是三语言最经典的"坑"差别。
Go 对照：同样10 / 3 = 3；格式化用fmt.Printf("我有 %d 岁", age)。

2.3 四种容器类型：列表 / 元组 / 字典 / 集合

这是 Python 数据操作的核心，AI 开发里天天用：

# 列表 list：有序、可修改（对应 Java 的 ArrayList，Go 的 slice）nums=[1,2,3]nums.append(4)# [1, 2, 3, 4] 追加nums[0]# 1 按下标访问，从 0 开始nums[-1]# 4 负数下标 = 从末尾数，Python 特色nums[1:3]# [2, 3] 切片：取下标 1 到 2，左闭右开len(nums)# 4 长度# 元组 tuple：有序、不可修改（定义后不能增删改）point=(3,5)point[0]# 3# point[0] = 9 # 报错！元组不可变# 字典 dict：键值对（对应 Java 的 HashMap，Go 的 map）user={"name":"Yulia","age":25}user["age"]# 25user["city"]="北京"# 新增键fork,vinuser.items():print(k,v)# 集合 set：无序、元素唯一（去重神器）ids={1,2,2,3}print(ids)# {1, 2, 3} 自动去重

可变 vs 不可变是 Python 的一个关键概念：

它影响两件事：① 不可变类型可以当字典的 key（{(1,2): "a"}合法，{[1,2]: "a"}报错）；② 函数传参时，可变对象会被"原地修改"（第四节会讲这个坑）。

三、控制流：让程序会判断、会循环

3.1 if 分支

score=85ifscore>=90:print("优秀")# 注意：冒号结尾 + 缩进开始代码块elifscore>=60:# elif = Java/Go 的 else ifprint("及格")else:print("不及格")

Java/Go 对照：if (score >= 90) { ... }——条件要加括号、代码块用大括号。Python 用冒号 + 缩进替代了这两样。

3.2 for / while 循环

# for 循环：直接遍历容器，不需要写下标fornin[1,2,3]:print(n)foriinrange(5):# range(5) 生成 0,1,2,3,4print(i)# while 循环count=0whilecount<3:count+=1# Python 没有 count++ 这种写法！# break / continue 与 Java/Go 一致

Java 对照：for (int i = 0; i < 5; i++) { ... }——三要素写全。
Go 对照：for i := 0; i < 5; i++ { ... }——Go 只有 for 一种循环关键字。
注意：Python 没有i++/++i，只有i += 1。

3.3 列表推导式：Python 最优雅的语法糖

squares=[x**2forxinrange(10)]# 0~9 的平方evens=[xforxinrange(20)ifx%2==0]# 带条件的过滤

这两行对应 Java/Go 里四五行的循环代码。推导式是 Python 风格的核心——AI 开发里处理数据时几乎处处用它，务必练熟。

四、函数：组织代码的第一步

4.1 定义与调用

defadd(a,b):"""求和（这是文档字符串）"""returna+bprint(add(1,2))# 3

4.2 参数的花样

defgreet(name,greeting="你好"):# 默认参数：不传就用默认值print(f"{greeting}，{name}")greet("Yulia")# 你好，Yuliagreet("Yulia",greeting="早")# 关键字参数：按名字传，可乱序greet(greeting="早",name="Yulia")defsum_all(*args):# *args：接收任意多个位置参数，变成元组returnsum(args)defshow(**kwargs):# **kwargs：接收任意多个关键字参数，变成字典print(kwargs)

Java 对照：Java 没有默认参数和关键字参数（靠方法重载模拟）；变长参数是void f(int... nums)。
Go 对照：Go 同样没有默认参数/关键字参数；变长参数是func f(nums ...int)。*args/**kwargs是 Python 独有的灵活性。

4.3 作用域与可变对象的"坑"

defappend_to(lst,item):lst.append(item)# lst 是可变对象，原地修改——外面也变了！nums=[1,2]append_to(nums,3)print(nums)# [1, 2, 3] —— 不是 [1, 2]！

这是 Python 新手必踩的坑：可变对象（list/dict）传进函数后，函数内的修改会"带出来"。理解方法：变量名只是"标签"，函数内外贴的是同一个对象。

4.4 lambda 匿名函数

square=lambdax:x**2square(5)# 25nums=[3,1,2]nums.sort(key=lambdax:-x)# 按降序排，key 接收一个函数

lambda 适合"只用一次的小函数"，常和sort、map、filter搭配。

五、面向对象：三个语言三种哲学

面向对象（OOP）是语法里最体现"语言性格"的部分，三语言差别最大：

5.1 class 基础

classUser:def__init__(self,name,age):# 构造方法，self = 对象自己self.name=name self.age=agedefintroduce(self):print(f"我是{self.name}，{self.age}岁")u=User("Yulia",25)# 创建对象：不用 new 关键字！u.introduce()

三个关键点：

1. self是"对象自己"的引用，每个方法第一个参数必须写 self（Java/Go 里是隐式的 this，不用写出来）；
2. __init__是构造方法（双下划线开头结尾的方法叫dunder / 魔法方法，Python 特色）；
3. 创建对象直接User(...)，没有 new 关键字（Java 要new User(...)）。

5.2 继承与多态

classAnimal:defspeak(self):return"..."classDog(Animal):# 括号里写父类 = 继承defspeak(self):return"汪汪"# 覆写父类方法classCat(Animal):defspeak(self):return"喵"forain[Dog(),Cat()]:# 多态：同一句代码，行为随对象而变print(a.speak())# 汪汪 / 喵

三语言哲学对照（这一节的灵魂）：

Go 特别说明：Go 没有类和继承，type Dog struct { ... }+ 为类型定义方法，接口是"隐式实现"（有这个方法就算实现了接口，不用显式声明）。理解这点，学 Go 时就不会用 Java 思维硬套。

5.3 Python 的鸭子类型

defmake_it_speak(obj):print(obj.speak())# 不检查 obj 是什么类型，只要有 speak 方法就能用make_it_speak(Dog())# 汪汪make_it_speak(Cat())# 喵

这就是"鸭子类型"：不关心你是什么，只关心你会不会。它让 Python 代码极其灵活，代价是类型错误要到运行时才发现——第一节"动态类型"模型的直接体现。

六、异常处理：出错不崩，优雅兜底

try:n=int(input("输入一个数字："))print(10/n)exceptValueError:print("你输的不是数字")# 捕获特定异常exceptZeroDivisionError:print("不能除以 0")exceptExceptionase:print(f"其它错误：{e}")# 兜底捕获，as e 拿到异常对象else:print("没有异常才会执行")finally:print("无论是否异常都执行")

Java 对照：try/catch/finally，但 Java 有"受检异常"——方法签名必须声明可能抛出的异常，编译器强制处理。Python 和 Go 都没有这个强制。
Go 对照：没有 try/catch！Go 的哲学是多返回值：result, err := f()，靠检查if err != nil处理错误。这是学 Go 时思维转换最大的一点。

七、模块与包：复用别人写好的代码

importmath# 导入整个模块print(math.sqrt(16))# 4.0frommathimportsqrt# 只导入某个函数print(sqrt(16))importnumpyasnp# 起别名，社区惯例（numpy/pandas 都这么写）arr=np.array([1,2,3])# pip 安装第三方库# pip install numpy pandas fastapi

配套概念：

• 模块：一个.py文件就是一个模块；
• 包：一个含__init__.py的目录；
• pip：Python 的包管理器（对应 Java 的 Maven、Go 的 go modules）；
• 虚拟环境：每个项目独立的依赖空间，python -m venv venv创建——动手写项目前必学，否则不同项目的依赖会互相打架。

八、三语言语法差别速查表

学了这么多，最后把三语言的关键语法并排放一起，这张表建议收藏：

总结：一张图带走

三个立即可用的行动：

1. 打开任意在线 Python 环境，把第二到七节的代码全部亲手敲一遍（语法不是看会的，是敲会的）；
2. 把第八节速查表存到收藏夹，学 Java/Go 的时候翻回来对照；
3. 写一个 30 行以内的小脚本练手：读一个列表、过滤、排序、写进文件——检验这一课的全部语法点。

如果这篇对你有帮助，点个赞、收藏一下，下一篇对照这张速查表学 Java 会轻松很多。

关注我，这个系列共 20 篇：Python 语法 → Java 对照 → Go 对照 → 网络 → 数据库 → FastAPI 实战 → AI 应用后端架构，一路带你到能独立写生产级后端。

你在学 Python 时踩过什么坑？是10/3的除法，还是可变对象传参的"灵异事件"？评论区聊聊，我挨个回。

（本文语法基于 Python 3.10+ 撰写，Java 对照基于 Java 17，Go 对照基于 Go 1.21，有版本差异评论区提醒我。）