这是一份专为前端工程师设计的Python完整教程。通过JavaScript对比学习，让你快速掌握Python的所有核心语法。

随着ai普及，对程序员的要求会更高，全栈是趋势

对自己有比较清楚的认知，我大概率一直为牛马

预计学习时间：3-4小时

前置要求：熟悉JavaScript

目录

1. 基础语法 - 变量、注释、字符串、条件、循环
2. 数据类型 - 数字、列表、字典、集合、元组
3. 函数 - 定义、参数、装饰器、闭包
4. 面向对象 - 类、继承、魔术方法、属性
5. 异步编程 - async/await、协程、并发
6. 模块系统 - 导入、包管理、虚拟环境
7. 常用库 - HTTP、JSON、文件、日期
8. 高级特性 - 推导式、生成器、上下文管理器
9. 实战项目 - 完整的实际应用案例
10. 常见陷阱 - 避免踩坑

基础语法

1. 变量和常量

核心概念：Python的变量不需要声明类型，赋值即创建。这和JavaScript的let类似，但更简洁。

JavaScript vs Python 对比

// JavaScript - 需要关键字声明const PI = 3.14;        // 常量（不可修改）let count = 0;          // 变量（可修改）var oldStyle = 1;       // 不推荐（作用域问题）// 试图修改常量会报错PI = 3.15;  // ❌ TypeError: Assignment to constant variable

# Python - 直接赋值即可PI = 3.14# 约定：大写表示常量（但实际可修改）count = 0# 变量old_style = 1# Python没有var，都是变量# Python没有真正的常量机制PI = 3.15# ✅ 可以修改，但不建议（靠约定）

详细说明

JavaScript的变量声明：

• const：块级作用域，不可重新赋值（但对象属性可修改）
• let：块级作用域，可重新赋值
• var：函数作用域，存在变量提升问题

Python的变量声明：

• 无需关键字，直接赋值
• 动态类型，可以随时改变类型
• 遵循"鸭子类型"：如果它走起来像鸭子，叫起来像鸭子，那就是鸭子

实际案例：变量类型可变

// JavaScript - 类型可变，但需要重新赋值let value = 42;          // numbervalue = "hello";         // string - 可以，但TypeScript会报错value = [1, 2, 3];       // array - 可以

# Python - 类型完全自由value = 42# intvalue = "hello"# str - 完全没问题value = [1, 2, 3]        # list - 很自然value = {"key": "val"}   # dict - 随便切换# 查看类型print(type(value))       # <class 'dict'>

命名规范对比

// JavaScript - 驼峰命名（camelCase）const userName = "张三";let userAge = 25;const MAX_SIZE = 100;  // 常量用大写

# Python - 蛇形命名（snake_case）user_name = "张三"user_age = 25MAX_SIZE = 100# 常量用大写# Python命名规范（PEP 8）# 变量和函数：lowercase_with_underscores# 类名：CapitalizedWords# 常量：UPPERCASE_WITH_UNDERSCORES

多变量赋值（Python特有）

// JavaScript - 解构赋值const [a, b, c] = [1, 2, 3];const {name, age} = {name: "张三", age: 25};// 交换变量需要临时变量let x = 1, y = 2;[x, y] = [y, x];  // ES6+ 支持

# Python - 更简洁的多变量赋值a, b, c = 1, 2, 3# 多变量赋值name, age = "张三", 25# 同时赋值# 交换变量（Python特色）x, y = 1, 2x, y = y, x                 # 无需临时变量！# 解包（类似解构）first, *middle, last = [1, 2, 3, 4, 5]print(first)   # 1print(middle)  # [2, 3, 4]print(last)    # 5

实战案例：配置管理

// JavaScript - 常量配置const config = {API_URL: "https://api.example.com",TIMEOUT: 5000,MAX_RETRIES: 3};// 不能重新赋值config，但可以修改属性// config = {};  // ❌ 错误config.TIMEOUT = 10000;  // ✅ 可以

# Python - 常量配置（约定）# config.py 文件API_URL = "https://api.example.com"TIMEOUT = 5000MAX_RETRIES = 3# 使用from config import API_URL, TIMEOUT# 虽然可以修改，但不应该这样做# TIMEOUT = 10000  # ⚠️ 违反约定# 如果需要真正的常量，可以使用类classConfig:    API_URL = "https://api.example.com"    TIMEOUT = 5000def__setattr__(self, key, value):raise AttributeError("Constants are immutable")

关键点总结

2. 注释

// JavaScript// 单行注释/*  多行注释  多行注释*//** * JSDoc 注释 * @param {string}name */

# Python# 单行注释"""多行注释多行注释"""defgreet(name: str) -> str:"""    函数文档字符串（docstring）    Args:        name: 用户名    Returns:        问候语    """returnf"Hello, {name}"

3. 字符串操作

核心概念：Python的字符串功能非常强大，f-string（格式化字符串）几乎和JavaScript的模板字符串一样好用。

基础字符串对比

// JavaScript - 三种字符串定义方式const single = 'Hello';          // 单引号const double = "World";          // 双引号（推荐）const template = `Hello ${name}`; // 模板字符串（ES6+）// 多行字符串const multiLine = `  第一行  第二行  第三行`;

# Python - 也是三种方式single = 'Hello'# 单引号double = "World"# 双引号（推荐）f_string = f"Hello {name}"# f-string（Python 3.6+）# 多行字符串multi_line = """  第一行  第二行  第三行"""# 也可以用三个单引号multi_line2 = '''  这也是多行字符串'''

字符串格式化详解

// JavaScript - 模板字符串const name = "张三";const age = 25;// 方式1：模板字符串（推荐）const msg1 = `我叫${name}，今年${age}岁`;// 方式2：字符串拼接（老式）const msg2 = "我叫" + name + "，今年" + age + "岁";// 方式3：表达式const msg3 = `明年我${age + 1}岁`;

# Python - 多种格式化方式name = "张三"age = 25# 方式1：f-string（推荐，Python 3.6+）msg1 = f"我叫{name}，今年{age}岁"# 方式2：format方法（Python 2.7+）msg2 = "我叫{}，今年{}岁".format(name, age)msg3 = "我叫{name}，今年{age}岁".format(name=name, age=age)# 方式3：百分号格式化（老式，不推荐）msg4 = "我叫%s，今年%d岁" % (name, age)# 方式4：字符串拼接msg5 = "我叫" + name + "，今年" + str(age) + "岁"# 注意：需要转换类型# f-string中的表达式msg6 = f"明年我{age + 1}岁"msg7 = f"名字长度：{len(name)}"

字符串方法完整对比

// JavaScript - 字符串方法const text = "  Hello World  ";text.length;                    // 13 - 长度text.toUpperCase();            // "  HELLO WORLD  "text.toLowerCase();            // "  hello world  "text.trim();                   // "Hello World"text.split(" ");               // ["", "", "Hello", "World", "", ""]text.includes("Hello");        // truetext.startsWith("  H");        // truetext.endsWith("d  ");          // truetext.replace("Hello", "Hi");   // "  Hi World  "text.substring(2, 7);          // "Hello"text.charAt(2);                // "H"text.indexOf("World");         // 8

# Python - 字符串方法（更丰富）text = "  Hello World  "len(text)                      # 13 - 长度（函数，不是方法）text.upper()                   # "  HELLO WORLD  "text.lower()                   # "  hello world  "text.strip()                   # "Hello World" - 去除两端空格text.lstrip()                  # "Hello World  " - 去除左边空格text.rstrip()                  # "  Hello World" - 去除右边空格text.split()                   # ["Hello", "World"] - 自动处理多个空格text.split(" ")                # ["", "", "Hello", "World", "", ""]"Hello"in text                # True - 成员检查text.startswith("  H")         # Truetext.endswith("d  ")           # Truetext.replace("Hello", "Hi")    # "  Hi World  "text[2:7]                      # "Hello" - 切片text[2]                        # "H" - 索引text.find("World")             # 8 - 查找位置（找不到返回-1）text.index("World")            # 8 - 查找位置（找不到抛异常）# Python特有的实用方法text.count("l")                # 3 - 统计字符出现次数text.isdigit()                 # False - 是否全是数字text.isalpha()                 # False - 是否全是字母text.isalnum()                 # False - 是否全是字母或数字"-".join(["2026", "03", "17"]) # "2026-03-17" - 拼接text.capitalize()              # "  hello world  " - 首字母大写text.title()                   # "  Hello World  " - 每个单词首字母大写

字符串切片（Python特色）

// JavaScript - 使用substring/sliceconst text = "Hello World";text.substring(0, 5);   // "Hello"text.slice(0, 5);       // "Hello"text.slice(-5);         // "World" - 倒数5个字符text.slice(6);          // "World" - 从索引6开始// 没有简单的反转字符串方法text.split('').reverse().join('');  // "dlroW olleH"

# Python - 切片功能超强大text = "Hello World"# 基本切片 [start:end:step]text[0:5]          # "Hello" - 从索引0到5（不含5）text[:5]           # "Hello" - 省略start，从头开始text[6:]           # "World" - 省略end，到结尾text[:]            # "Hello World" - 复制整个字符串# 负索引text[-5:]          # "World" - 倒数5个字符text[:-6]          # "Hello" - 到倒数第6个字符text[-1]           # "d" - 最后一个字符# 步长（step）text[::2]          # "HloWrd" - 每隔一个字符text[::-1]         # "dlroW olleH" - 反转字符串！text[1:8:2]        # "el o" - 从1到8，每隔一个# 实用技巧text[::1]          # 正向复制text[::-1]         # 反转text[1::2]         # 奇数索引的字符text[::2]          # 偶数索引的字符

实战案例：处理用户输入

// JavaScript - 验证和清理用户输入functionvalidateEmail(email) {  email = email.trim();  // 去空格if (!email.includes('@')) {returnfalse;  }if (!email.endsWith('.com') && !email.endsWith('.cn')) {returnfalse;  }returntrue;}// 提取文件名const path = "/Users/name/document.txt";const fileName = path.split('/').pop();  // "document.txt"

# Python - 更简洁的字符串处理defvalidate_email(email):    email = email.strip()  # 去空格if'@'notin email:returnFalseifnot (email.endswith('.com') or email.endswith('.cn')):returnFalsereturnTrue# 提取文件名path = "/Users/name/document.txt"file_name = path.split('/')[-1]  # "document.txt"# 或者使用pathlib（更专业）from pathlib import Pathfile_name = Path(path).name  # "document.txt"

实战案例：格式化输出

// JavaScript - 格式化金额functionformatMoney(amount) {return`¥${amount.toFixed(2)}`;}console.log(formatMoney(1234.5));  // "¥1234.50"// 格式化日期const date = newDate();const formatted = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;

# Python - 格式化金额defformat_money(amount):returnf"¥{amount:.2f}"# .2f 表示保留2位小数print(format_money(1234.5))  # "¥1234.50"# 格式化日期from datetime import datetimedate = datetime.now()formatted = date.strftime("%Y-%m-%d")  # "2026-03-17"# f-string高级格式化price = 1234.5678print(f"{price:.2f}")        # "1234.57" - 保留2位小数print(f"{price:,.2f}")       # "1,234.57" - 千分位分隔print(f"{price:>10.2f}")     # "   1234.57" - 右对齐，宽度10print(f"{price:<10.2f}")     # "1234.57   " - 左对齐print(f"{price:^10.2f}")     # " 1234.57  " - 居中对齐# 百分比ratio = 0.8567print(f"{ratio:.2%}")        # "85.67%" - 百分比格式# 科学计数法big_num = 1234567890print(f"{big_num:e}")        # "1.234568e+09"

字符串的不可变性

// JavaScript - 字符串不可变let str = "Hello";str[0] = "h";  // 无效，但不报错console.log(str);  // 还是 "Hello"// 必须重新赋值str = "hello";

# Python - 字符串也不可变text = "Hello"# text[0] = "h"  # ❌ TypeError: 'str' object does not support item assignment# 必须创建新字符串text = "h" + text[1:]  # "hello"# 或者转换成列表再修改chars = list(text)chars[0] = "h"text = "".join(chars)  # "hello"

关键点总结

4. 条件语句

// JavaScriptif (age >= 18) {console.log("成年");} elseif (age >= 12) {console.log("青少年");} else {console.log("儿童");}// 三元运算符const status = age >= 18 ? "成年" : "未成年";

# Python（注意缩进！）if age >= 18:    print("成年")elif age >= 12:    print("青少年")else:    print("儿童")# 三元表达式status = "成年"if age >= 18else"未成年"

5. 循环详解

核心概念：Python的for循环更像JavaScript的for...of，而不是传统的for(i=0; i<n; i++)。

基本循环对比

// JavaScript - C风格for循环for (let i = 0; i < 5; i++) {console.log(i);  // 0, 1, 2, 3, 4}// for...of（遍历值）const arr = [1, 2, 3];for (const item of arr) {console.log(item);  // 1, 2, 3}// for...in（遍历索引，不推荐用于数组）for (const index in arr) {console.log(index);  // "0", "1", "2" - 注意是字符串}// forEach（函数式）arr.forEach((item, index) => {console.log(index, item);});// while循环let i = 0;while (i < 5) {console.log(i);  i++;}

# Python - 没有C风格for，更像for...of# for + range（生成数字序列）for i in range(5):    print(i)  # 0, 1, 2, 3, 4# for...in（直接遍历元素）arr = [1, 2, 3]for item in arr:    print(item)  # 1, 2, 3# enumerate（带索引，类似forEach）for index, item in enumerate(arr):    print(index, item)  # 0 1, 1 2, 2 3# enumerate指定起始索引for index, item in enumerate(arr, start=1):    print(index, item)  # 1 1, 2 2, 3 3# while循环（和JS一样）i = 0while i < 5:    print(i)    i += 1

range()函数详解

# range(stop) - 从0到stop-1for i in range(5):    print(i)  # 0, 1, 2, 3, 4# range(start, stop) - 从start到stop-1for i in range(2, 5):    print(i)  # 2, 3, 4# range(start, stop, step) - 指定步长for i in range(0, 10, 2):    print(i)  # 0, 2, 4, 6, 8# 倒序for i in range(5, 0, -1):    print(i)  # 5, 4, 3, 2, 1# range是惰性的（不会立即生成所有数字）big_range = range(1000000)  # 不占用太多内存print(list(range(5)))  # 转换成列表：[0, 1, 2, 3, 4]

遍历字典

// JavaScript - 遍历对象const user = {name: "张三", age: 25, city: "北京"};// 遍历键for (const key in user) {console.log(key);}// 遍历值for (const value ofObject.values(user)) {console.log(value);}// 遍历键值对for (const [key, value] ofObject.entries(user)) {console.log(key, value);}

# Python - 遍历字典user = {"name": "张三", "age": 25, "city": "北京"}# 遍历键（默认）for key in user:    print(key)# 明确遍历键for key in user.keys():    print(key)# 遍历值for value in user.values():    print(value)# 遍历键值对（推荐）for key, value in user.items():    print(f"{key}: {value}")

循环控制语句

// JavaScript - break和continuefor (let i = 0; i < 10; i++) {if (i === 3) continue;  // 跳过3if (i === 7) break;     // 到7就停止console.log(i);  // 0, 1, 2, 4, 5, 6}

# Python - break、continue和elsefor i in range(10):if i == 3:continue# 跳过3if i == 7:break# 到7就停止    print(i)  # 0, 1, 2, 4, 5, 6# Python特有：for...else（循环正常结束时执行）for i in range(5):if i == 10:  # 永远不会满足breakelse:    print("循环正常结束")  # 会执行# 实战：查找元素deffind_element(arr, target):for item in arr:if item == target:            print(f"找到了: {item}")breakelse:        print("没找到")  # 只有没break时才执行

嵌套循环

// JavaScript - 嵌套循环for (let i = 1; i <= 3; i++) {for (let j = 1; j <= 3; j++) {console.log(`${i} x ${j} = ${i * j}`);  }}// 生成二维数组const matrix = [];for (let i = 0; i < 3; i++) {const row = [];for (let j = 0; j < 3; j++) {    row.push(i * 3 + j);  }  matrix.push(row);}

# Python - 嵌套循环for i in range(1, 4):for j in range(1, 4):        print(f"{i} x {j} = {i * j}")# 生成二维数组（列表推导式更简洁）# 传统方式matrix = []for i in range(3):    row = []for j in range(3):        row.append(i * 3 + j)    matrix.append(row)# 列表推导式（一行搞定）matrix = [[i * 3 + j for j in range(3)] for i in range(3)]# [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

实战案例：处理数据

# 案例1：过滤和转换数据users = [    {"name": "张三", "age": 25, "active": True},    {"name": "李四", "age": 17, "active": False},    {"name": "王五", "age": 30, "active": True}]# 找出所有活跃的成年用户active_adults = []for user in users:if user["age"] >= 18and user["active"]:        active_adults.append(user["name"])print(active_adults)  # ['张三', '王五']# 案例2：统计分类scores = [85, 92, 78, 95, 88, 65, 90]grades = {"A": 0, "B": 0, "C": 0}for score in scores:if score >= 90:        grades["A"] += 1elif score >= 80:        grades["B"] += 1else:        grades["C"] += 1print(grades)  # {'A': 3, 'B': 3, 'C': 1}# 案例3：二维数组操作matrix = [    [1, 2, 3],    [4, 5, 6],    [7, 8, 9]]# 遍历所有元素for row in matrix:for num in row:        print(num, end=" ")  # 1 2 3 4 5 6 7 8 9    print()  # 换行# 按列遍历（使用zip）for col in zip(*matrix):    print(col)  # (1, 4, 7), (2, 5, 8), (3, 6, 9)

迭代器和可迭代对象

# 理解迭代器numbers = [1, 2, 3]# 获取迭代器iterator = iter(numbers)# 手动迭代print(next(iterator))  # 1print(next(iterator))  # 2print(next(iterator))  # 3# print(next(iterator))  # StopIteration异常# for循环的本质就是使用迭代器# 以下代码等价：for num in numbers:    print(num)# 等价于：iterator = iter(numbers)whileTrue:try:        num = next(iterator)        print(num)except StopIteration:break

zip()和enumerate()实用技巧

# zip - 并行遍历多个序列names = ["张三", "李四", "王五"]ages = [25, 30, 28]cities = ["北京", "上海", "广州"]for name, age, city in zip(names, ages, cities):    print(f"{name}, {age}岁, 来自{city}")# 转换成字典user_dict = dict(zip(names, ages))# {'张三': 25, '李四': 30, '王五': 28}# enumerate - 带索引遍历tasks = ["写代码", "测试", "部署"]for index, task in enumerate(tasks, start=1):    print(f"{index}. {task}")# 1. 写代码# 2. 测试# 3. 部署# reversed - 反向遍历for num in reversed(range(5)):    print(num)  # 4, 3, 2, 1, 0# sorted - 排序后遍历numbers = [3, 1, 4, 1, 5]for num in sorted(numbers):    print(num)  # 1, 1, 3, 4, 5

性能对比：循环 vs 推导式

import time# 方式1：传统循环start = time.time()squares1 = []for i in range(1000000):    squares1.append(i ** 2)print(f"循环耗时: {time.time() - start:.3f}秒")# 方式2：列表推导式（更快）start = time.time()squares2 = [i ** 2for i in range(1000000)]print(f"推导式耗时: {time.time() - start:.3f}秒")# 方式3：生成器（最省内存）start = time.time()squares3 = (i ** 2for i in range(1000000))# 只创建生成器，不计算值print(f"生成器耗时: {time.time() - start:.6f}秒")

关键点总结

数据类型

1. 数字

// JavaScriptconst integer = 42;const float = 3.14;const hex = 0xFF;const binary = 0b1010;

# Pythoninteger = 42float_num = 3.14hex_num = 0xFFbinary = 0b1010# Python 特有：大整数支持big_number = 99999999999999999999999999999

2. 布尔值

// JavaScriptconst isTrue = true;const isFalse = false;// 假值：false, 0, "", null, undefined, NaNif (!value) {console.log("假值");}

# Pythonis_true = True# 注意：首字母大写！is_false = False# 假值：False, 0, "", None, [], {}ifnot value:    print("假值")

3. 数组/列表

// JavaScriptconst arr = [1, 2, 3, 4, 5];// 常用方法arr.push(6);           // 添加元素arr.pop();             // 删除最后一个arr.shift();           // 删除第一个arr.unshift(0);        // 开头添加arr.slice(1, 3);       // 切片arr.map(x => x * 2);   // 映射arr.filter(x => x > 2); // 过滤arr.reduce((a, b) => a + b); // 归约

# Pythonarr = [1, 2, 3, 4, 5]# 常用方法arr.append(6)          # 添加元素arr.pop()              # 删除最后一个arr.pop(0)             # 删除第一个arr.insert(0, 0)       # 指定位置插入arr[1:3]               # 切片[x * 2for x in arr]   # 列表推导式（映射）[x for x in arr if x > 2] # 列表推导式（过滤）sum(arr)               # 求和# 列表推导式（Python 特色）squares = [x**2for x in range(10)]  # [0, 1, 4, 9, 16, ...]evens = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]

4. 对象/字典

// JavaScriptconst user = {name: "张三",age: 25,skills: ["React", "Vue"]};// 访问user.name;           // "张三"user["age"];         // 25// 方法Object.keys(user);   // ["name", "age", "skills"]Object.values(user); // ["张三", 25, [...]]

# Pythonuser = {"name": "张三","age": 25,"skills": ["React", "Vue"]}# 访问user["name"]         # "张三"user.get("age")      # 25（推荐，不存在返回 None）# 方法user.keys()          # dict_keys(['name', 'age', 'skills'])user.values()        # dict_values([...])user.items()         # dict_items([('name', '张三'), ...])# 字典推导式squares = {x: x**2for x in range(5)}  # {0: 0, 1: 1, 2: 4, ...}

5. Set（集合）

// JavaScriptconstset = new Set([1, 2, 2, 3]);  // Set {1, 2, 3}set.add(4);set.has(2);  // trueset.delete(1);

# Pythonmy_set = {1, 2, 2, 3}  # {1, 2, 3}my_set.add(4)2in my_set  # Truemy_set.remove(1)# 集合操作a = {1, 2, 3}b = {3, 4, 5}a | b  # 并集 {1, 2, 3, 4, 5}a & b  # 交集 {3}a - b  # 差集 {1, 2}

6. None vs null/undefined

// JavaScriptlet value = null;       // 空值let value2 = undefined; // 未定义

# Pythonvalue = None# 唯一的空值（类似 null）# 检查if value isNone:    print("空值")if value:  # None 是假值    print("有值")

函数

1. 基本定义

// JavaScriptfunctionadd(a, b) {return a + b;}// 箭头函数const add = (a, b) => a + b;// 默认参数functiongreet(name = "Guest") {return`Hello, ${name}`;}

# Pythondefadd(a, b):return a + b# 默认参数defgreet(name="Guest"):returnf"Hello, {name}"# Lambda（类似箭头函数）add = lambda a, b: a + b

2. 参数类型

// JavaScriptfunctionprocess(required, optional = "default", ...rest) {console.log(required, optional, rest);}process(1, 2, 3, 4, 5);  // 1 2 [3, 4, 5]

# Pythondefprocess(required, optional="default", *args, **kwargs):    print(required, optional, args, kwargs)process(1, 2, 3, 4, key="value")  # 1 2 (3, 4) {'key': 'value'}# *args: 可变位置参数（元组）# **kwargs: 可变关键字参数（字典）

3. 类型提示（Type Hints）

// JavaScript (TypeScript)functionadd(a: number, b: number): number{return a + b;}

# Pythondefadd(a: int, b: int) -> int:return a + b# 复杂类型from typing import List, Dict, Optionaldefprocess_users(    users: List[Dict[str, str]]) -> Optional[str]:return users[0]["name"] if users elseNone

面向对象

1. 类定义

// JavaScriptclassUser{constructor(name, age) {this.name = name;this.age = age;  }  greet() {return`Hello, I'm ${this.name}`;  }static createGuest() {returnnew User("Guest", 0);  }}const user = new User("张三", 25);

# PythonclassUser:def__init__(self, name, age):        self.name = name        self.age = agedefgreet(self):returnf"Hello, I'm {self.name}"    @staticmethoddefcreate_guest():return User("Guest", 0)user = User("张三", 25)

2. 继承

// JavaScriptclassAdminextendsUser{constructor(name, age, role) {super(name, age);this.role = role;  }  manageUsers() {return"Managing users...";  }}

# PythonclassAdmin(User):def__init__(self, name, age, role):        super().__init__(name, age)        self.role = roledefmanage_users(self):return"Managing users..."

3. 私有属性