Python 笔记：给前端开发者的语法对照

这篇只记 JavaScript 开发者最容易误判的 Python 差异。默认你已经会写 JS，不重复解释变量、循环是什么。

先看结论#

场景	JavaScript	Python
输出	`console.log(x)`	`print(x)`
字符串插值	`${x}`	`f"{x}"`
布尔值与空值	`true` / `false` / `null`	`True` / `False` / `None`
逻辑运算	`&&` `\|\|` `!`	`and` `or` `not`
代码块	`{ ... }`	`:` + 缩进
遍历	`for (const x of a)`	`for x in a`
长度	`a.length`	`len(a)`
最后一个元素	`a.at(-1)`	`a[-1]`
字典/对象读取	`obj.key`	`d["key"]` / `d.get("key")`
函数定义	`function f() {}`	`def f():`
实例引用	`this`	`self`
异常捕获	`catch (err)`	`except Error as err:`
变量声明	`let` / `const`	直接赋值，没有 `const`
实例化	`new Person()`	`Person()`
包管理	`npm` + `node_modules`	`pip` + `venv`

变量与字符串#

1
let name = "Mia";
2
const age = 20;
3

4
console.log(`${name} is ${age}`);

1
name = "Mia"
2
age = 20
3

4
print(f"{name} is {age}")

Python 没有 let / const。变量只是名字，重新赋值就是重新绑定：

1
name = "Mia"
2
name = "Leo"

约定使用 snake_case，常量通常写全大写：

1
MAX_RETRY = 3

字符串拼接不同类型会报错，需要显式转换：

1
age = 20
2
print("Age is " + str(age))

代码块与条件#

JavaScript 靠花括号，Python 靠缩进。缩进不是格式，是语法。

1
if (age >= 18) {
2
  console.log("Adult");
3
} else if (age >= 12) {
4
  console.log("Teenager");
5
} else {
6
  console.log("Child");
7
}

1
if age >= 18:
2
    print("Adult")
3
elif age >= 12:
4
    print("Teenager")
5
else:
6
    print("Child")
7

另一个容易忽略的差异：Python 的条件和循环不会创建块级作用域。

1
if True:
2
    level = "adult"
3

4
print(level)  # adult

JS 里 let level 写在 if 内，块外不能访问；Python 可以。

数字、布尔值和空值#

写法	JavaScript	Python
除法	`7 / 2` → `3.5`	`7 / 2` → `3.5`
整除	`Math.floor(7 / 2)`	`7 // 2`
乘方	`2 ** 10`	`2 ** 10`
类型	`typeof 2`	`type(2)`
相等	优先用 `===`	用 `==`
逻辑	`&&` `\|\|` `!`	`and` `or` `not`
空值	`undefined` / `null`	`None`
布尔	`true` / `false`	`True` / `False`

Python 的 == 比较值，is 比较是不是同一个对象。不要拿 is 代替 ==。

1
2 == "2"      # False
2
2 is 2        # True
3
None is None  # True

Python 和 JS 的真值判断也不同：

1
bool([])      # False
2
bool({})      # False
3
bool("")      # False
4
bool(0)       # False
5
bool(None)    # False

JS 中空数组和空对象都是真值，这是最常见的迁移坑之一。

列表 vs 数组#

操作	JavaScript	Python
追加	`arr.push(x)`	`arr.append(x)`
长度	`arr.length`	`len(arr)`
最后一个	`arr.at(-1)`	`arr[-1]`
切片	`arr.slice(1, 3)`	`arr[1:3]`
包含	`arr.includes(x)`	`x in arr`
删除	`arr.splice()`	`del arr[i]` / `pop()`
排序	`arr.sort()` 原地修改	`sorted(arr)` 返回新列表

1
nums = [3, 10, 4, 1, 5]
2

3
nums.append(9)
4
print(len(nums))       # 6
5
print(nums[-1])        # 9
6
print(nums[1:3])       # [10, 4]
7
print(4 in nums)       # True
8
print(sorted(nums))    # [1, 3, 4, 5, 9, 10]

sorted() 返回新列表，nums.sort() 才是原地排序：

1
result = sorted(nums)
2
nums.sort()

列表推导式可以直接替代 filter + map：

1
result = [n * 2 for n in nums if n > 3]

执行逻辑是：先过滤 n > 3，再把满足条件的 n 变成 n * 2。

字典 vs 对象#

操作	JavaScript	Python
读取	`book.title`	`book["title"]`
缺失键	返回 `undefined`	抛 `KeyError`
安全读取	`book.rating ?? 0`	`book.get("rating", 0)`
遍历	`Object.entries(book)`	`book.items()`

1
book = {"title": "Dune", "year": 1965}
2

3
print(book["title"])              # Dune
4
print(book.get("rating", 0))      # 0
5

6
for key, value in book.items():
7
    print(key, value)

注意：get() 的默认值只在键不存在时生效。键存在但值是 None，仍然会返回 None。

循环#

1
for (const fruit of fruits) {
2
  console.log(fruit);
3
}

1
for fruit in fruits:
2
    print(fruit)
3

需要索引时，Python 用 enumerate()：

1
for index, fruit in enumerate(fruits):
2
    print(index, fruit)

数数字用 range()，右边界不包含：

1
for i in range(5):
2
    print(i)  # 0 1 2 3 4

Python 没有 i++：

1
count = 0
2
while count < 5:
3
    count += 1

函数#

1
function greet(name, greeting = "Hi") {
2
  return `${greeting}, ${name}!`;
3
}
4

5
greet("Mia");
6
greet("Mia", "Hello");

1
def greet(name, greeting="Hi"):
2
    return f"{greeting}, {name}!"
3

4
greet("Mia")
5
greet("Mia", "Hello")
6
greet(name="Mia", greeting="Hello")

关键差异：

Python 支持关键字参数，JS 通常用对象参数模拟。
Python 缺少必填参数会直接抛 TypeError；JS 可能得到 undefined。
Python 函数没有 return 时返回 None。
lambda 只能写单个表达式，复杂逻辑应写普通函数。

排序函数的写法也不同：

1
words = ["banana", "fig", "apple"]
2

3
sorted(words, key=len)                 # 按长度
4
sorted(words, key=lambda w: w[-1])     # 按最后一个字符

类#

1
class Person {
2
  constructor(name) {
3
    this.name = name;
4
  }
5

6
  speak() {
7
    return `${this.name} is speaking`;
8
  }
9
}
10

11
const person = new Person("Mia");

1
class Person:
2
    def __init__(self, name):
3
        self.name = name
4

5
    def speak(self):
6
        return f"{self.name} is speaking"
7

8
person = Person("Mia")
9
10
11

记住三点：构造方法叫 __init__，实例方法第一个参数是 self，创建实例不用 new。

异常处理#

1
try {
2
  const data = JSON.parse(text);
3
  console.log(data.age);
4
} catch (error) {
5
  console.log(error.message);
6
}
7

1
import json
2

3
try:
4
    data = json.loads(text)
5
    print(data["age"])
6
except json.JSONDecodeError as error:
7
    print(error)

主动抛错：

1
throw new Error("Invalid data");

1
raise ValueError("Invalid data")

不要捕获所有异常后什么都不做。至少记录错误，或只捕获明确的异常类型。

异步#

JS 中 async 函数由运行时调度；Python 中协程需要事件循环执行。

1
async function main() {
2
  const data = await fetchData();
3
}
4
5
6

1
import asyncio
2

3
async def main():
4
    data = await fetch_data()
5

6
asyncio.run(main())

调用 main() 只是创建协程，不会自动执行；asyncio.run() 才会启动事件循环。

运行、依赖与模块#

场景	JavaScript	Python
运行文件	`node app.js`	`python app.py`
安装依赖	`npm install`	`pip install`
项目配置	`package.json`	`requirements.txt` / `pyproject.toml`
依赖位置	当前项目 `node_modules`	默认全局，项目通常使用 `venv`
导入	`import x from "./x.js"`	`import x` / `from x import y`

Python 项目建议始终创建虚拟环境：

1
python -m venv .venv
2

3
# Windows PowerShell
4
.\.venv\Scripts\Activate.ps1
5

6
# macOS / Linux
7
source .venv/bin/activate

激活后再安装依赖，避免污染系统 Python：

1
pip install requests
2
pip freeze > requirements.txt

最容易踩的坑#

空数组不是“有值”：Python 的 [] 是假值，JS 的 [] 是真值。
数组排序语义不同：JS sort() 默认按字符串比较且原地修改；Python sorted() 返回新列表。
对象缺键不返回 undefined：Python 字典缺键会抛 KeyError，不确定时用 get()。
没有 ++：用 i += 1。

不要用可变对象做默认参数：

1
def add(item, items=None):
2
    if items is None:
3
        items = []
4
    items.append(item)
5
    return items

赋值不等于复制：
```
1
a = [1, 2]
2
b = a
3
b.append(3)
4
print(a)  # [1, 2, 3]
```
需要副本时用 b = a.copy() 或 b = a[:]。
缩进错误就是语法错误：不要混用 Tab 和空格。
None 不是 undefined：Python 没有 undefined，缺值统一用 None。