Python 快速上手

0030 秒速览：三句话 + 按你的处境挑入口

读完这一篇，你能做到一件事：在终端里敲几行命令，让电脑读一个文件、算一算、把结果存成新文件——而不是只知道"Python 是一门很火的编程语言"。这一篇不教你成为工程师，只教你把脑子里的"要是电脑能替我做这个就好了"变成一段真能跑起来的代码。

按你现在的处境，直接用这个

如果你只有半小时：这样走

读完你应该能

几个你会反复看到的数字

01Python 到底是什么：先破掉三个错想

你在网上一定见过"Python 是 AI 语言""Python 是做爬虫的"。这些说法不算错，但它们描述的是别人拿 Python 干的事，不是 Python 是什么。先确认一件更基本的事——它其实和你已经会用的东西很像。

它不是什么

那它是什么

Python 官方的入门教程第一句就是它的定义（原文）："Python is an easy to learn, powerful programming language."——一门易学、强大的编程语言。紧接着官方还给了三个关键词：elegant syntax（优雅语法）、dynamic typing（动态类型）、interpreted nature（解释型本质），并说这些让它"非常适合脚本与快速开发"。[3]

动态类型这个词听着吓人，拆开就一句话：你写 age = 30 时不需要提前声明"age 是个整数"——存进去什么，它就是什么，Python 自己看。（代价是类型错了要到运行时才发现，第 10 节讲这个代价长什么样。）

一个你一定要知道的边界：官方教程不是给零基础看的

这点很少有人告诉你。官方教程开头有一句提醒（原文）："This tutorial is designed for programmers that are new to the Python language, not beginners who are new to programming."——它是写给"已经会编程、只是不熟 Python"的人，不是写给完全没写过代码的人。[3]

所以你直接去读官方教程会有一个很具体的卡点：它会突然开始讲"对象""可迭代""命名空间"这些词，而这些词本身就是它要解释的东西。本文的写法就是针对这个断层——凡是你没见过的词，第一次出现就当场用日常语言说明白。

你写的东西，到底是怎么跑起来的

你写好的是一份纯文本文件，习惯上以 .py 结尾（这个后缀就是给人的提示：这是一份 Python 源码）。它自己不会动，需要一个叫解释器的程序来读它。整条链路是这样的：

因为"写一行、跑一行"这件事成立，你起步时可以只用一个入口：交互式模式——直接敲 python3 回车，屏幕上出现 >>>，你打一句它答一句，像聊天。这个 >>> 叫主提示符（primary prompt），是"解释器在等你说话"的记号；多行语句没写完时它会换成 ...，那是续行提示。[2]

它已经在替人做这些事

这些方向你现在一个都不用碰。提一句只是让你知道：你学的不是玩具语言，它是 AI、数据、自动化三座大山的共同地基。

新手最容易先卡住的三处

02它替你解决哪一类问题：什么时候该用它

很多人第一门语言学 Python，不只是因为它简单，而是因为它从"入门"到"干正事"之间几乎没有断层：今天学的语法，明天就能用来处理你电脑里那张 Excel。

四个具体的理由

和别的选择比，它赢在哪

那它的短处是什么

"我就想自动化一件小事"，该用 Python 还是别的

03把 Python 装到你的 Mac 上，并用一条命令验证

本节目标：装好一个可用的 Python，并且能用一条命令确认它真的在。下面每一步都不需要 sudo，照着官方安装包点下去就行。

第 1 步：先看看你电脑里是不是已经有了

macOS 最近几个版本自带一个 python3，所以第一件事不是下载，是确认。打开"终端"：按 Command + 空格，输入"终端"（Terminal）回车，会弹出一个能敲字的窗口。然后输入：

python3 --version

三种可能的结果，对应三种做法：

第 2 步：装官方安装包（推荐路线）

打开官网下载页 python.org/downloads，页面正中的大按钮就是当时的稳定版（本文校对时是 Python 3.14.7，2026 年 8 月 5 日发布）。macOS 用户下载的是 .pkg 安装包，双击后一路"继续 / 安装"，中途输一次开机密码即可。安装选项保持默认就好，不要去勾那些自己也不认识的组件。[1]

第 3 步：验证它真的装好了

python3 --version
# 期望输出：Python 3.14.7

看到 Python 3.x.y 这一行就成了。3.11 及以上都能跑本文的所有例子，不必和 3.14.7 一模一样。

另一种装法：Homebrew（可跳过）

如果你之前装过 brew（macOS 上常见的软件包管理器，用一行命令装软件的工具），也可以：

brew install python@3.14

两种方式都行。重点是：装完统一用 python3 验证，别把不同渠道装的 Python 混着用——两个版本抢着当"python3"是新手最难查的一类怪问题。本文以官方 .pkg 为准。

万一报 command not found，按这个顺序排查

$ python3 --version
zsh: command not found: python3

第 4 步：知道这三个入口就够起步

写 Python 绕不开终端：先记四条命令

Windows 用户怎么办

本文以 Mac 为主，但内容同样适用于 Windows，只有两处不同：装 python.org 的 .exe 安装包时务必勾上 "Add Python to PATH"，之后把本文所有的 python3 换成 py 即可，例如 py --version。

PATH 是什么？它是系统里一份"去哪些文件夹找命令"的清单。你敲一个命令名，系统就照着这份清单一个文件夹一个文件夹地去翻。不勾 "Add Python to PATH"，就等于没把 Python 所在的文件夹写进清单——文件明明在硬盘上，命令行也找不到它。Mac 上那个 command not found 是同一回事，只是 Mac 的官方安装包会默认替你写进清单。

安装这一步的四个新手坑

04最小例子：十分钟跑通你的第一个程序

理论先放一边。这一节跟着做，十分钟内你会亲手写出并跑通两个程序，而且第二个已经是在"算真东西"了。

第 1 步：进交互模式，说一句话

print("你好，Python！")

第 2 步：写进文件，让它能重复跑

交互模式里试完就忘；真正要保存下来、以后还能再跑的程序，写进 .py 文件。

# 在桌面建一个文件夹专门放练习，然后进去
mkdir -p ~/Desktop/python-练习
cd ~/Desktop/python-练习

接着把下面这段存成 hello.py。最省事的办法：把内容复制进"文本编辑"，然后"文件 → 存储为"，文件名填 hello.py。

# hello.py —— 你的第一个 Python 程序
# 以 # 开头的行是"注释"，给人和 AI 看的，Python 会跳过它
print("你好，世界！")

# input() 让程序停下来问你一句，等你敲完回车
name = input("你叫什么名字？")
# f 字符串：把 {变量} 的值拼进一句话里
print(f"欢迎，{name}！你已经迈出第一步了。")

然后运行它：

python3 hello.py

看到输出就代表你的第一个 Python 程序跑通了。

第 3 步：一个有数学的最小例子

编程不只是打印文字。下面这个程序把摄氏度换算成华氏度，它演示了入门必备的四件事：从用户拿输入 → 把文字变成数字 → 算 → 格式化输出。

# temp.py —— 摄氏度 → 华氏度换算器
c = float(input("请输入摄氏温度，例如 25："))   # float() 把文字变成小数
f = c * 9 / 5 + 32                          # 换算公式
print(f"{c} 摄氏度 = {f} 华氏度")
print(f"保留一位小数：{f:.1f}")              # :.1f 表示保留 1 位小数

python3 temp.py

运行过程与输出（25 是你敲进去的）：

请输入摄氏温度，例如 25：25
25.0 摄氏度 = 77.0 华氏度
保留一位小数：77.0

这段代码你该盯住什么

05变量、注释、缩进：Python 的三条书写规则

这一节把 Python 最核心的"书写规则"讲完——其实只有三件事。懂了这三件，你就能读懂大半 Python 代码。

变量：给数据贴一个名字标签

变量就像便利贴：把一个值存进电脑的内存，再给它起个名字，方便以后反复用。变量这个词的意思是"可以变的量"——你随时可以撕掉旧便利贴换一张新的。你不需要提前声明它装什么类型，直接赋值即可：

name = "小明"      # 存一段文字（字符串）
age = 30           # 存一个整数
height = 1.75      # 存一个小数（浮点数）
is_ok = True       # 存真/假（布尔值，True/False 首字母大写）

print(name, age, height, is_ok)   # print 可以一次打印多个，用逗号分隔
print(age + 1)                    # 30 + 1 → 31

这里的 = 读作"把右边的值存进左边的名字"，不是数学里的"等于"。判断相等要用 ==（两个等号），这是第 14 节的第一个坑。

命名规则：记住三条就够

x = 100
y = 12
z = x * y
print(z)

price = 100
count = 12
total = price * count
print(total)

注释：写给人（和 AI）看的话

# 后面同一行的内容 Python 会跳过，用来解释"这段在干嘛"：

# 把一小时的秒数算出来
seconds = 60 * 60
seconds = 60 * 60   # 也可以写在代码末尾

注释不参与运行，所以它唯一的价值是"给读代码的人留线索"。你和 AI 协作时，写得清楚的注释会显著提高它改对的概率（第 13 节会展开）。

缩进：Python 用它划分"哪几行是一伙的"

这是 Python 和其他语言最大的不同。别的语言用花括号 { } 表示"这些代码是一组"，Python 用行首的缩进。凡是以冒号 : 结尾的行，下面缩进的代码都属于它：

score = 85
if score >= 60:            # 冒号结尾，表示下面是一个块
    print("及格啦")        # 这一行缩进了 4 个空格，属于 if
    print("继续加油")
print("这句没缩进，永远会执行")

输入与输出的标准姿势

input() 收进来的永远是文字；print() 只管把东西显示出来。补一个"一次输入多个值"的技巧（先眼熟，用得到再回来看）：

a, b = input("用空格隔开两个数：").split()
print("第一个数是", a, "，第二个是", b)

这一节的三个新手坑

06文字、数字，与"能装东西的盒子"

数据在 Python 里有不同类型。类型这个词的意思是"这份数据是什么种类"——它决定了你能不能对它加减、能不能切片、该怎么一个个取出来。先记住四种基础类型和三种容器。

四种基础类型

想随时知道一个值是什么类型、有多长，有两个内置函数：

x = "你好"
print(type(x))      # <class 'str'>
print(len(x))       # 2（中文按字符数算）
print("Python" * 3) # 字符串也能乘：PythonPythonPython

列表 list：有序、可改的"购物车"

列表就是把一堆东西按顺序装在一起，用一个名字带着走。它是新手最常用的容器。

fruits = ["苹果", "香蕉", "橙子"]
print(fruits[0])            # 苹果 —— 下标从 0 开始！
print(fruits[-1])           # 橙子 —— -1 表示最后一个
fruits.append("葡萄")        # 末尾追加
fruits.remove("香蕉")        # 按值删除
print(len(fruits))          # 3
print(fruits[1:])            # ['橙子', '葡萄'] —— 切片：从下标 1 取到最后

字典 dict：按"名字"查值的通讯录

列表按下标（第几个）取，字典按键（key）取——适合存有名字的字段，比如一个人的资料。你可以把它想成通讯录：你说"给我小明的电话"，不需要知道小明排在第几页。

person = {"name": "小明", "age": 30, "city": "上海"}
print(person["name"])            # 小明
person["age"] = 31                # 改一个已有的值
person["job"] = "工程师"          # 加一个新键
print(person.get("salary"))       # None —— .get 找不到不报错
print(person.get("salary", 0))    # 0 —— 找不到时给个默认值

这里的 None 是 Python 表示"什么都没有"的专用值（不是 0，也不是空字符串，就是"没有"）。.get() 比 person["salary"] 安全：后者在键不存在时会直接报 KeyError 让程序崩掉。

另外两种容器：元组与集合（眼熟即可）

t = (1, 2, 3)        # 元组 tuple：和 list 类似，但创建后不可改
s = {1, 2, 2, 3}     # 集合 set：自动去重，结果是 {1, 2, 3}

字符串的常用方法：每天都用得上

text = "  Hello, Python  "
print(text.strip())                        # 去掉首尾空格
print(text.lower())                        # 全小写
print(text.replace("Python", "世界"))     # 替换
print("a,b,c".split(","))                  # ['a', 'b', 'c'] 按逗号切分 → 超常用
print(text.upper().strip().startswith("HELLO"))  # True，方法可以连着用

最后一行展示了 Python 很讨喜的一点：方法可以串起来写。先 upper() 变大写，再 strip() 去空格，最后 startswith() 判断是不是以某段开头——从左往右依次生效，读起来像一句话。

f-string：把变量优雅地塞进句子

name = "小明"
score = 92.5
print(f"{name} 考了 {score:.1f} 分，班级排名第 1")   # 小明 考了 92.5 分，班级排名第 1
print(f"得分率：{score / 100:.0%}")                 # 得分率：93%

f"..." 里的花括号 {} 会被里面表达式的值替换掉；冒号后面是格式说明，控制"怎么显示"。:.1f 是保留 1 位小数，:.0% 是显示成百分比、不保留小数。这是 Python 3.6 起就有的写法，本文的示例统一用它。

列表套字典：真实数据的"标准形状"

单个字典只描述"一个人"；现实中通常是一整班人——于是就是列表里装着很多字典。这个形状你会在 CSV、JSON、数据库查询结果里反复遇到：

students = [
    {"name": "小明", "score": 88},
    {"name": "小红", "score": 95},
    {"name": "小刚", "score": 72},
]

# 一个个取出每个人，再按下标取里面的字段
for s in students:
    print(f"{s['name']} 考了 {s['score']} 分")

# 一行算出平均分
avg = sum(s["score"] for s in students) / len(students)
print(f"平均分：{avg:.1f}")                 # 平均分：85.0

读完这段你回头会惊讶：第 11 节用 csv.DictReader 读表格时，每一行恰好就是这样一个字典——CSV、JSON、dict 三者在这个"形状"上彻底打通了。

类型转换一张表：九成 TypeError 都在这里解决

# 最经典的组合：input 来的都是文字，分别转好再参与运算
price = input("单价：")          # 拿到的是 "10"
qty = input("数量：")            # 拿到的是 "3"
total = float(price) * int(qty)   # 10.0 * 3 = 30.0
print(f"共 {total:.2f} 元")

这一节的四个新手坑

07让程序自己做决定、反复做

写代码大部分时间就在回答两件事："如果……就……"（条件）和"对每一个……都做一遍"（循环）。这两样学会了，你的程序才开始"像程序"。

if / elif / else：让程序分岔

score = int(input("请输入分数："))
if score >= 90:
    print("优秀")
elif score >= 60:        # elif = "否则如果"，可以写很多个
    print("及格")
else:                    # 上面都不满足，才走这里
    print("不及格，加油")

读法就是按顺序从上往下问：第一个条件成立就走第一个分支，不成立再问 elif，全都不成立才走 else。只要有一个成立，后面的条件根本不会被检查——所以顺序很重要。

比较运算符与组合条件

age = 25
if age >= 18 and age <= 60:
    print("成年人，且还年轻")

for 循环：对每个元素做一遍

fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(f"我吃了 {fruit}")

# 想固定做 N 次，用 range(N)
for i in range(3):        # range(3) → 0, 1, 2
    print("第", i + 1, "次循环")

for ... in ... 读作"从右边的集合里，一个个取出元素放进左边的名字"。range(3) 生成 0、1、2 这三个整数（又一次从 0 开始）。遍历字典时，默认拿到的是"键"；要同时拿键和值，用 .items()：

person = {"name": "小明", "age": 30}
for key, value in person.items():
    print(key, "=", value)

range 与 enumerate：两个最常配循环用的工具

for idx, item in enumerate(fruits):
    print(idx, item)

列表推导式：一行生成新列表

把"循环 + 收集结果"压缩成一行，读起来像英文句子："对每个数，取它的平方，若它是偶数"：

nums = [1, 2, 3, 4, 5]
squares = [n * n for n in nums]              # [1, 4, 9, 16, 25]
evens = [n for n in nums if n % 2 == 0]      # [2, 4]，带条件的写法

while 与 break / continue：按条件反复做

count = 0
while count < 5:          # 条件为真就一直循环
    count += 1               # 等价于 count = count + 1
    if count == 3:
        continue             # 跳过本次，直接进入下一轮
    if count == 4:
        break                # 强制结束整个循环
    print(count)             # 只会打印 1 和 2

这一节的三个新手坑

08把一段逻辑打包，反复用

函数就是给一段能干的代码起个名字，以后反复调用。它让你不用重复抄代码，也让程序读起来像"步骤清单"。这是你从"写几行"到"写一个程序"的分界线。

定义一个函数并调用它

def greet(name):
    """向某人打招呼（这是 docstring，说明函数用途）"""
    message = f"你好，{name}！"
    return message              # return 把结果交回给调用处

result = greet("小明")        # 调用，把返回值存进变量
print(result)                # 你好，小明！

三个新词：def 是"定义"（define）的缩写；name 是参数，就是"调用时你传进来的东西"；return 是"把结果交回去"。没有 return 的函数，调用后拿到的是 None——想拿到结果就务必写 return，别指望 print 能传值。

参数：默认值与关键字参数

def greet(name, greeting="你好"):      # greeting 有默认值，可以省略
    return f"{greeting}，{name}！"

print(greet("小明"))                   # 你好，小明！
print(greet("小明", "晚上好"))          # 晚上好，小明！（按位置传）
print(greet(greeting="Hi", name="Tom")) # 用"名字="传参，顺序无关，可读性好

最后一行那种写法叫关键字参数：写清楚"哪个值给哪个参数"，顺序就不重要了。参数一多，它比按位置传参清楚得多。

把函数当积木：一个完整小例子

下面这段把 BMI（身体质量指数，用体重和身高算出来的一个健康参考值）拆成两个小函数，再由主流程调用。请留意它有多短、多好读：

def bmi(weight_kg, height_m):
    return weight_kg / height_m ** 2

def category(bmi_value):
    if bmi_value < 18.5:
        return "偏瘦"
    elif bmi_value < 24:
        return "正常"
    elif bmi_value < 28:
        return "偏胖"
    return "肥胖"

w = float(input("体重(公斤)："))
h = float(input("身高(米)："))
value = bmi(w, h)
print(f"你的 BMI 是 {value:.1f}，属于 {category(value)}")

** 是"乘方"，height_m ** 2 就是身高乘以身高。注意 category 里最后那行 return "肥胖" 没有跟 elif：前面三种情况都被拦掉了，能走到这里的只剩第四种。

变量作用域：函数内和外是两个世界

函数里新建的变量（叫局部变量）在函数外面看不见。想用函数算出来的东西，得用 return 把它交出来：

def double(n):
    n = n * 2        # 这里改的是一个"副本"
    return n

x = 10
double(x)
print(x)             # 仍是 10！函数里改不动外面的 x

x = double(x)        # 把返回值"接"回来才生效
print(x)             # 20

这个规则听起来绕，其实是保护你的：函数不会偷偷改掉外面的东西，出错时你只需要看函数的返回了什么。作用域这个词的意思就是"一个名字在哪些地方看得见"。

给函数写说明书：docstring 与类型注解

代码是写给人（和 AI）读的。Python 里有标准写法给函数配"说明书"：

def bmi(weight_kg: float, height_m: float) -> float:
    """根据体重(公斤)和身高(米)计算 BMI。"""
    return weight_kg / height_m ** 2

# 冒号后的 float 只是"给读者的提示"，不强制；-> float 表示"返回小数"
print(bmi(70, 1.75))    # 22.86...

入门阶段注解可写可不写。一旦函数多起来，它帮你少翻代码——而且你会发现，给 AI 的代码加上注解之后，它改出来的东西明显更准。

这一节的三个新手坑

09模块、第三方库与虚拟环境：站在别人肩膀上

Python 强大的一大原因是"别人已经写好了大多数功能，你 import 一下就能用"。但要先分清两个词：标准库是装 Python 就自带的；第三方库是别人写好、要用 pip 另外装的。

import：把现成的工具拿进来

import math
import random
from datetime import date      # 只拿 date 这一样

print(math.sqrt(16))            # 4.0 平方根
print(random.randint(1, 100))   # 1~100 之间的随机整数
print("今天是", date.today())
print(math.pi)                  # 3.141592653589793

import 的意思是"把那个工具箱搬进来"。import math 之后，用 math.sqrt 这种"工具箱.工具"的形式调用。from ... import ... 是"只拿工具箱里的某一件"。

标准库 = 买电脑时自带的应用

文件处理、CSV 表格、网络请求、JSON、随机数、日期，全都在标准库里，零安装。下面这八个是新手最值得先记住的：

用 pip 装第三方库

pip 是 Python 官方的包安装工具（"package installer for Python"）。官方文档建议在 POSIX 系统（包括 macOS）上用带版本号的 python 命令配合 -m 参数来运行它，这样能保证装到你想装的那个 Python 里：[4]

python3 -m pip install requests   # 例：requests —— 发 HTTP 请求，用代码去网上取数据
python3 -m pip list              # 看看当前装了哪些库

-m 的意思是"把这个 Python 自己的某个模块当命令来跑"。装完在代码里照常 import requests 就能用。新手常用的第三方库，按"你想干什么"对应：

别把库装进"系统 Python"：先建虚拟环境

进阶之前先立一条规矩：给每个项目建一个虚拟环境，也就是一个独立的小房间，房间里的库互不干扰。这样 A 项目要 requests 的 1.x、B 项目要 2.x，也不会打起来。三步：

python3 -m venv .venv

source .venv/bin/activate

python3 -m pip install requests
python3 -m pip freeze > requirements.txt   # 把依赖清单存下来，换电脑一键还原

这一节的三个新手坑

10报错与调试：把红字当向导

写代码报错是日常，不是意外。会读报错、会处理能预见的错误，你就已经超过大多数刚起步的人了。Python 的报错分成两大类，处理方式完全不同，先分清这一点。

语法错误 vs 运行时错误

Exception 这个词的意思是"异常"——指程序跑到一半遇到的不正常情况。它不是崩溃的同义词：异常可以被捕获，捕获住程序就能继续往下走（下面第 3 小节讲）。

怎么读一长串报错（traceback）

那一大串红字有个正式名字叫 traceback（回溯），意思是"从出错的地方一路往回追，都经过了哪些调用"。别被长度吓到，读法只有两条：

Traceback (most recent call last):
  File "temp.py", line 3, in <module>
    f = c * 9 / 5 + 32
TypeError: can't multiply sequence by non-int of type 'float'

try / except：处理"能预见到的意外"

凡是用户输入、读文件、网络请求这类"外面来的数据"，都可能出意外。用 try / except 兜住，程序就不会直接崩掉：

while True:
    raw = input("请输入一个整数：")
    try:
        n = int(raw)          # 可能失败的"危险操作"放 try 里
        break                 # 成功就跳出循环
    except ValueError:        # 只抓这一种错
        print("那不是整数，请重来")   # 出错了不崩，回头再问一次

print(f"你输入了整数 {n}，它翻倍是 {n * 2}")

n = int(input("请输入整数："))
print(10 / n)

try:
    n = int(input("请输入整数："))
    print(10 / n)
except (ValueError, ZeroDivisionError) as e:
    print("输入不对，或除数不能为 0：", e)

调试三板斧：新手最实用的三个动作

第三个招数听起来慢，其实是最快的。同时改三处然后跑通了，你并不知道是哪一处起了作用——下次遇到同样的问题，你还是不会。还有一种公认有效的技巧叫橡皮鸭调试法：把问题对着一个不会回话的东西（传统上是一只橡皮鸭）复述一遍。很多时候说着说着答案自己就出来了，因为"讲出来"逼你把模糊的直觉变成具体的句子。

让 AI 帮你排错的正确姿势

同一句报错，信息给全和不给全，得到的答案天差地别。这两种问法的对比值得记住：

我代码报错了，帮我看看：
Traceback (most recent call last):
  File ...
TypeError ...

我这段 Python 报错了（新手，只懂基础语法）：
[粘贴 temp.py 的完整代码]

运行后报错是：
[粘贴完整红色报错]

请告诉我：1) 哪一行、为什么错；
2) 用最简单写法修好并加中文注释；
3) 怎么验证修好了。

这一节的三个新手坑

11读写文件：让程序处理你的真实数据

到这里你开始做"真事"了：读电脑里的文本或 CSV 文件，算一算，再把结果存回去。本文统一用标准库里的 pathlib，它让路径处理在 macOS 和 Windows 上都正常。

读和写一个文本文件

from pathlib import Path

# 写：把内容存进 data.txt（文件不存在会自动创建）
Path("data.txt").write_text(
    "第一行内容\n第二行内容\n", encoding="utf-8"
)

# 读：整份读进来
content = Path("data.txt").read_text(encoding="utf-8")
print(content)

# 逐行处理
for line in Path("data.txt").read_text(encoding="utf-8").splitlines():
    print("读到一行：", line)

这里的 \n 是"换行符"，一个写在代码里的记号，代表"这里换一行"。encoding="utf-8" 是告诉 Python"这份文件里的文字按 UTF-8 编码来读"。

读 CSV（Excel 的"朴素版"）算平均分

CSV 就是"用逗号分隔的纯文本表格"——Excel 可以另存为它，它也能被 Excel 打开。先用文本编辑器存一个 grades.csv（第一行是表头，也就是每一列叫什么）：

姓名,分数
小明,88
小红,95
小刚,72

再写 average.py：

import csv
from pathlib import Path

rows = list(csv.DictReader(Path("grades.csv").read_text(encoding="utf-8-sig").splitlines()))
# utf-8-sig：吃掉 Excel 留下的 BOM 头，中文表头才读得对
scores = [float(row["分数"]) for row in rows]
avg = sum(scores) / len(scores)
print(f"共 {len(scores)} 人，最高 {max(scores)}，平均 {avg:.1f}")

# 把结论写进一个新文件，方便存档
Path("report.txt").write_text(
    f"平均分：{avg:.1f}", encoding="utf-8"
)

python3 average.py
共 3 人，最高 95.0，平均 85.0

看，你已经会用一整套组合了

上面这个脚本同时用到了四样东西：读文件、CSV 解析、列表推导式（第 07 节）、f-string 格式化（第 06 节），最后还写了文件。能独立跑通它，你就具备了"用 Python 处理小数据"的核心能力——这也是第 12 节三个项目的地基。

异常处理 + 文件 = 防崩组合

读文件最常见的事故是"文件不在那儿"。用 try / except 兜住，程序就能给你一句人话，而不是一屏红字：

from pathlib import Path

def read_grade(path):
    try:
        return Path(path).read_text(encoding="utf-8")
    except FileNotFoundError:
        print(f"找不到文件 {path}，请检查路径")
        return None          # 返回 None，调用方就知道"没读到"

text = read_grade("grades.csv")
if text is not None:
    print("读到了", len(text), "个字符")

注意判断写法是 if text is not None:，不是 == None。判断"是不是 None"要用 is，这是 Python 圈子的固定习惯（第 18 节有解释）。

覆盖、追加、逐行读：三个常用姿势

# 一个小日志器：程序每次运行都记一行时间
import datetime
from pathlib import Path

now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
with open("runs.log", "a", encoding="utf-8") as f:
    f.write(f"运行于 {now}\n")     # \n 是换行符
print("已在 runs.log 追加一条记录")

with ... as f: 这个写法叫"上下文管理器"，它的作用是用完之后自动帮你把文件关好，哪怕中途出错了也关。你不需要手动写关闭文件的代码——这也是为什么现在推荐 pathlib：多数场景它连 with 都省了。

这一节的三个新手坑

12三个能今晚做完的小项目

知识要到"能独立做出东西"才算学会。下面三个项目从易到难，每个都是完整可运行、自带容错的整段代码。今晚挑一个做完，你对"Python 能替我干活"就会有实感。

项目一：猜数字游戏（练循环 + 条件 + 随机数）

# guess.py —— 猜 1~100 的随机数，带次数统计
import random

secret = random.randint(1, 100)
tries = 0
print("我心中想了一个 1~100 的数字，来猜猜看！")

while True:
    raw = input("你猜是几？")
    try:
        guess = int(raw)
    except ValueError:
        print("请输入整数哦")
        continue
    tries += 1
    if guess < secret:
        print("太小了，再大点")
    elif guess > secret:
        print("太大了，再小点")
    else:
        print(f"恭喜！你用了 {tries} 次猜中。")
        break

它把第 07 节的 while / if / break / continue 全用上了，还顺手演示了"用户乱输入也不会崩"。

项目二：文本文件词频统计（练文件 + 字典 + 排序）

# wordcount.py —— 数一数一段文字里哪些词出现最多
from pathlib import Path
import re

text = Path("essay.txt").read_text(encoding="utf-8")
words = re.findall(r"[一-龥]|[a-zA-Z]+", text)   # 拆出中文单字或英文单词
counter = {}
for w in words:
    counter[w] = counter.get(w, 0) + 1              # 见过的词 +1

top = sorted(counter.items(), key=lambda item: item[1], reverse=True)[:10]
print("出现最多的前 10 个：")
for word, count in top:
    print(word, count)

还要准备一个 essay.txt：随便贴一段中文或英文文章进去就行。这个项目的输出会让你直观看到"哪种写法出现的次数最多"。

项目三：给 CSV 数据自动生成"一句话汇报"

# report.py —— 读多列成绩，输出每个字段的小结，全自动
import csv
from pathlib import Path

path = Path("scores.csv")
if not path.exists():
    print("请先准备 scores.csv（表头：姓名,语文,数学,英语）")
    raise SystemExit

rows = list(csv.DictReader(path.read_text(encoding="utf-8-sig").splitlines()))
subjects = ["语文", "数学", "英语"]
lines = [f"本次共 {len(rows)} 名同学参加。"]

for sub in subjects:
    scores = [float(row[sub]) for row in rows]
    lines.append(
        f"{sub} 平均 {sum(scores) / len(scores):.1f}，最高 {max(scores):.0f}，最低 {min(scores):.0f}"
    )

Path("报告.txt").write_text("\n".join(lines), encoding="utf-8")
print("\n".join(lines))
print("已保存到 报告.txt")

配套的 scores.csv 长这样（表头三个科目名要和代码里的 subjects 对上）：

姓名,语文,数学,英语
小明,88,92,79
小红,95,86,91
小刚,72,68,80

raise SystemExit 是"主动结束程序"——文件都没准备好，继续跑下去只会报更难懂的错。"\n".join(lines) 是把一串文字用换行符连成一段多行文本，是写多行报告最常用的写法。

项目四（选做挑战）：批量改文件名

把某个文件夹里所有 .txt 的名字加上日期前缀——这个练习最能让你体会"脚本替我做重复劳动"的感觉。这里只给需求和骨架，答案在你已经学过的知识里：

# rename.py —— 给当前文件夹所有 .txt 加上前缀"备份_"，未实现，交给你
from pathlib import Path
import datetime

today = datetime.date.today().isoformat()   # 例：2026-09-13
folder = Path(".")
# 提示：用 for f in folder.glob("*.txt") 拿到所有 .txt，再 f.rename(新名字)
# 挑战：先打印"要改哪些"，确认无误再真改，避免误伤

做完之后，这条路往哪走

13四个一开始就该养成的习惯，和怎么跟 AI 搭档

作为新手，你不需要背 PEP 8 那类完整的代码风格规范，但下面四条能帮你少踩很多坑，也让 AI 更容易接手你的代码。

四个习惯

给 AI 的提问模板（直接复制去用）

把下面这段复制给 AI，它就能产出符合你当前水平的代码：

我是 Python 零基础新手，只会变量 / if / for / 函数 / 文件读写这些。
请用最简单、我读得懂的写法帮我写一个程序，功能是：
【一句话描述需求，例如：读取 scores.csv 求每科平均分】

要求：
1. 只依赖标准库，别引入第三方库
2. 用户输入和读文件要 try/except 容错，别让程序崩溃
3. 关键行加中文注释
4. 告诉我运行它要在终端敲什么命令、怎么验证结果

下面是我的报错（如有）：【粘贴红色报错】

这份模板有效的道理很简单：它把 AI 最缺的三样信息一次补齐了——你的水平（决定代码复杂度）、约束（不用第三方库、要有容错）、验收方式（怎么跑、怎么验证）。缺了这些，AI 只能给你一份"通用答案"。

交代码之前的 30 秒自检清单

14新手必踩的七个坑

下面这些坑基本所有人都踩过。先读一遍，真遇到时能少慌很多——因为你会立刻认出"哦，是那个"。

坑 1：判断相等用了一个 =

if score = 60:
    print("刚好及格")

if score == 60:
    print("刚好及格")

坑 2：把 input 回来的文字直接当数字算

age = input("几岁？")          # 得到的是 "25"（字符串）
print(age + 1)                   # ❌ TypeError：字符串和整数不能相加

age = int(input("几岁？"))      # ✅ 用 int() 转换后再算

这是新手第一大坑，因为它不报"你错了"，而是报一个看不懂的 TypeError。记住一句话：input() 拿到的永远是文字。

坑 3：下标从 1 开始数

fruits = ["苹果", "香蕉", "橙子"]
print(fruits[1])   # 你以为第一个 → 其实是"香蕉"
print(fruits[0])   # 苹果（第 0 个才是第一个）

坑 4：忘记"列表是共享的引用"

a = [1, 2, 3]
b = a                # ❌ 这不是复制！a 和 b 指向同一个列表
b.append(4)
print(a)             # [1, 2, 3, 4] —— a 也被改了！

c = a.copy()         # ✅ 这才是真正复制一份
c.append(5)
print(a)             # [1, 2, 3, 4] 不受影响

为什么会这样？因为 b = a 复制的不是那串数字，而是"那个列表放在内存哪里"这个地址。给同一个东西起两个名字，改一个当然两边都变。这个概念叫引用——变量名是指向数据的标签，不是装着数据的盒子。

坑 5：用可变对象当函数默认参数

def add_item(item, bag=[]):      # ❌ 默认的 [] 只创建一次，会被反复污染
    bag.append(item)
    return bag

print(add_item("苹果"))          # ['苹果']
print(add_item("香蕉"))          # ['苹果', '香蕉'] —— 咦？不是应该只有香蕉吗？

改成 def add_item(item, bag=None):，然后在函数里写 if bag is None: bag = [] 就好了。这个坑的解释要牵扯到"默认值只在定义时求值一次"，有点绕，先记住"别用可变默认参数"这句话，等以后想深究再看官方文档的函数定义一节。

坑 6：浮点数算出来"不精确"

print(0.1 + 0.2)      # 0.30000000000000004 —— 不是 0.3！

这不是 Python 的 bug。官方教程专门有一章讲它：计算机用二进制表示小数，而大多数十进制小数无法用二进制精确表示，于是产生了极小的误差——所有用浮点数的语言都有这个问题。[9]

坑 7：Tab 和空格混用缩进

if True:
    print("a")     # 4 个空格
if True:
	print("b")     # 用了 Tab → IndentationError

两者看起来一样宽，计算机看起来完全不同。解决方式只有一条：让编辑器统一成"用空格"，并打开"显示空白字符"这个选项，这样混用一眼就能看出来。

终极排查口诀

15速查表：写代码卡住时回来翻

这一节是给你"用第二遍"的：每一段都能直接复制去跑。不用背，知道去哪找就行。

输入输出与类型转换

print("你好", 42, "一次打多个")   # 逗号分隔
name = input("输入：")               # 永远是字符串
n = int("25")                       # 字符串 → 整数
f = float("2.5")                    # 字符串 → 小数
s = str(42)                         # 数字 → 字符串
print(f"结果：{n * 2}")              # f-string 拼值

字符串

s = "a,b,c"
print(s.split(","))                 # ['a','b','c'] 切分
print("-".join(["a", "b"]))         # 'a-b' 合并
print("hello".upper())              # HELLO
print(s.strip())                    # 去掉首尾空格
print(len("你好"))                  # 2
print("苹果" in ["苹果", "梨"])      # True（判断在不在）

列表与字典

nums = [3, 1, 2]
nums.append(4)                        # 末尾加一个
nums.sort()                           # 原地排序 → [1,2,3,4]
print(max(nums), min(nums), sum(nums))   # 4 1 10
print([x * 2 for x in nums])            # 推导式

d = {"a": 1}
d["b"] = 2                            # 新增 / 改键
print(d.get("c", "没有"))              # '没有'（安全取值）
print("a" in d)                        # True 判断键是否存在
print(d.keys(), d.values())          # 所有键 / 所有值

条件、循环、range

if x > 0:
    pass                              # pass = 占位，先不写内容也能过

for i in range(5):                   # 0,1,2,3,4
    pass
for i in range(2, 6):                # 2,3,4,5
    pass
for i in range(0, 10, 2):            # 0,2,4,6,8（步长 2）
    pass

# range 配合下标，或直接用 enumerate 同时拿下标和值：
for idx, item in enumerate(fruits):
    pass

函数与异常

def f(a, b=1, *args, **kwargs):      # 默认值 / 不定数量参数（进阶，先眼熟）
    return a + b

try:
    risky()                           # 可能出错的代码
except Exception as e:
    print("出错：", e)                  # 兜底打印，别让程序裸奔崩掉

*args 和 **kwargs 是"接收不定数量的参数"的写法，前者收位置参数、后者收关键字参数。现在看不懂没关系，眼熟即可——你在别人的代码里一定会碰到它。

文件与最常用的标准库

from pathlib import Path
Path("out.txt").write_text("内容", encoding="utf-8")
print(Path("out.txt").read_text(encoding="utf-8"))

import random, math, json
random.choice(["剪刀", "石头", "布"])       # 随机挑一个
math.floor(2.7)                              # 2（向下取整）
json.loads('{"a": 1}')                      # 字符串 → 字典
json.dumps({"a": 1}, ensure_ascii=False)     # 字典 → 字符串（中文不乱码）

高频内置函数速查

最常报的 6 个错误对照表

16四周练习路线：把 Python 变成习惯

光看不练一定会忘。下面是一条每天约 40 分钟的四周路线：每周都有明确的"出口测试"，做完再进下一周，不赶进度。

四周的目标与出口测试

每周一道必做练习（先自己写，卡住再翻前文）

# 第 1 周：输入两个数，输出和、差、积、平均（提示：int / float 转换）
a = int(input("第一个整数："))
b = int(input("第二个整数："))
# 接下来交给你：print 出四则运算的结果

# 第 2 周：给一份分数列表，输出"高于平均分"的人（提示：第 06 节的结构）
scores = [85, 92, 58, 77, 69, 90]
avg = sum(scores) / len(scores)
# 交给你：遍历 scores，把 > avg 的都打印出来

# 第 3 周：写一个函数，输入秒数，返回"几小时几分几秒"
def fmt(seconds):
    # 交给你：h = seconds // 3600，m = ...，s = ...
    pass

# 第 4 周：读 notes.txt，统计它有多少行、多少字，写回 summary.txt
from pathlib import Path
text = Path("notes.txt").read_text(encoding="utf-8")
# 交给你：算行数、字数（提示 len(text.split())），写回 summary.txt

每个周末的自测清单（全勾上再进下一周）

17术语表：什么时候用、别当什么用

遇到看不懂的词回来查。这一节不只是翻译，第三列回答的是"在这套东西里它为什么重要、什么时候该想起它、别把它当成什么"。

18常见问题

99一句话总结

下一步动作（现在就能做）：打开终端敲 python3 --version，然后建一个 hello.py，把第 04 节第一段代码敲进去跑一遍。遇到红色报错，把整段错误加上那一行代码发给你的 AI 助手——读得懂报错，你就已经入门了。

附：速成练习三连（今晚就能做完）

# ① 打印 1~100 里所有能被 3 整除的数
for i in range(1, 101):
    if i % 3 == 0:
        print(i)

# ② 把"苹果,香蕉,橙子"拆成列表，再逐行打印
fruits = "苹果,香蕉,橙子".split(",")
for fruit in fruits:
    print(f"我喜欢 {fruit}")

# ③ 把 26 摄氏度的华氏度结果保留 1 位打印
c = 26
print(f"华氏度：{c * 9 / 5 + 32:.1f}")   # 华氏度：78.8

98参考来源与证据边界

本文的关键事实均经下列来源核对（2026-09-13 访问）。基础语法部分属于长期稳定的内容，版本号与安装细节属于会变化的内容——两者的处理方式不同，见下方的证据边界说明。

这几个链接建议收藏