Python 语言完整入门指南

2026/07/014 分钟阅读1,379 字

Python 是一种高级、解释型、动态类型、面向对象的通用编程语言。它以语法清晰、简洁和高可读性著称，在数据分析、机器学习、自动化测试（测开）以及 Web 后端开发中得到了极其广泛的应用。

1. Python 简介与环境搭建

1.1 核心特点

语法优雅简洁：使用缩进（Indentation）来划分代码块，没有大括号 {}，可读性极强。
解释型语言：无需手动编译，代码由 Python 解释器逐行执行，开发反馈周期短。
动态强类型：变量不需要声明类型，运行时自动确定，但不同类型之间不能隐式转换（如字符串不能直接加数字）。
极其庞大的生态系统：拥有丰富的第三方库（如测试领域的 Pytest, Web 领域的 FastAPI/Django/Flask）。

1.2 环境搭建

从 Python 官方网站下载对应系统的安装包安装，或使用 macOS 的 brew install python。

安装完成后，在终端运行命令验证：

python3 --version
pip3 --version # Python 的包管理工具

1.3 编写第一个程序 (Hello World)

创建 hello.py 文件：
```
# hello.py
print("Hello, World!")
```
在终端运行该程序：
```
python3 hello.py
```

2. 变量、常量与基本数据类型

2.1 变量声明

Python 声明变量非常直接，无需任何关键字：

x = 10          # 整数 (int)
y = 3.14        # 浮点数 (float)
name = "Python" # 字符串 (str)
is_active = True # 布尔值 (bool: True/False)

2.2 基本类型与转换

Python 支持动态类型，你可以使用 type() 检查变量类型，并进行强制转换：

age = "25"
age_num = int(age) # 转换为整型
price = float("19.9") # 转换为浮点型
text = str(100) # 转换为字符串

3. 核心数据结构

Python 内置了四种非常强大的数据结构：列表、元组、集合、字典。

3.1 列表 (List) —— 有序、可变

fruits = ["apple", "banana", "orange"]
fruits.append("grape")  # 追加元素
fruits[1] = "pear"      # 修改索引 1 的元素
print(fruits[0:2])      # 切片操作，输出: ['apple', 'pear']

3.2 元组 (Tuple) —— 有序、不可变

元组一旦创建，其元素不能被修改或添加。常用于返回多个值或作为不可变配置。

coordinates = (10.0, 20.0)
# coordinates[0] = 30.0  # 报错：元组不可修改

3.3 集合 (Set) —— 无序、无重复

用于去重和集合运算（交、并、差）。

tags = {"QA", "Dev", "QA"} # 自动去重为 {"QA", "Dev"}
tags.add("Ops")

3.4 字典 (Dictionary) —— 键值对、可变

user = {
    "name": "Bob",
    "age": 27,
    "role": "QA"
}
user["email"] = "bob@example.com" # 新增键值对
print(user.get("name"))           # 获取值，输出: Bob

4. 控制结构

Python 使用 严格缩进（通常为 4 个空格）来区分代码块。

4.1 条件分支 (if-elif-else)

score = 85

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
else:
    print("及格")

4.2 循环结构 (for, while)

for...in 循环 (用于遍历序列或范围)：

# 遍历列表
for fruit in ["apple", "banana"]:
    print(fruit)

# 循环特定次数 (0 到 4)
for i in range(5):
    print(i)

while 循环：

count = 0
while count < 3:
    print(count)
    count += 1

5. 函数与模块化

5.1 函数定义

使用 def 关键字定义函数。Python 支持默认参数、关键字参数以及可变参数：

# 带默认参数的函数
func greet(name, message="Hello"):
    return f"{message},{name}!"

# 可变参数 (args) 与 关键字参数 (kwargs)
def print_info(*args, **kwargs):
    print("位置参数:", args)
    print("键值参数:", kwargs)

print_info(1, 2, 3, status="active", code=200)

5.2 模块与导入

Python 文件本身就是模块。你可以使用 import 引入其他模块或第三方库：

import math
from datetime import datetime

print(math.sqrt(16)) # 4.0
print(datetime.now())

6. 面向对象编程 (OOP)

Python 支持完整的面向对象编程，使用 class 关键字：

class Animal:
    # 构造函数，self 类似于其他语言的 this，必须显式作为第一个参数
    def __init__(self, name):
        self.name = name # 成员变量

    def speak(self):
        return f"{self.name} 正在发出声音"

# 继承 Animal 类
class Dog(Animal):
    def speak(self):
        return f"{self.name} 汪汪叫"

my_dog = Dog("旺财")
print(my_dog.speak()) # 旺财 汪汪叫

7. 错误与异常处理

Python 使用 try...except...finally 块来捕获和处理运行期异常：

try:
    num = 10 / 0
except ZeroDivisionError as e:
    print("捕获到除以零错误:", e)
except Exception as e:
    print("捕获到其他错误:", e)
finally:
    print("无论是否发生异常，此代码都会执行")

8. 包管理与虚拟环境 (venv)

在实际开发中，不同的项目可能需要不同版本的依赖包。Python 推荐使用虚拟环境来隔离项目依赖。

8.1 创建和激活虚拟环境

# 在项目目录下创建名为 .venv 的虚拟环境
python3 -m venv .venv

# 激活虚拟环境 (Windows 使用 .venv\Scripts\activate)
source .venv/bin/activate

8.2 安装第三方库

激活虚拟环境后，使用 pip 安装包，依赖会被安装在 .venv 内，不影响全局系统：

# 安装 pytest 测试框架
pip install pytest

# 保存项目所有依赖到 requirements.txt
pip freeze > requirements.txt

# 在新环境下安装 requirements.txt 中的所有包
pip install -r requirements.txt

💡 经典避坑与抓虫小测验

以下小测验选取了 Python 开发中最经典、最容易出错的代码陷阱。请尝试阅读并分析以下代码，预测其输出结果或找出 Bug，点击“答案与解析”查看具体原因。

测验 1：致命的可变默认参数

【题目】：预测以下代码的最终输出结果：

def add_item(item, item_list=[]):
    item_list.append(item)
    return item_list

list1 = add_item("apple")
list2 = add_item("banana")
list3 = add_item("orange", [])

print("list1:", list1)
print("list2:", list2)
print("list3:", list3)

👉 答案与解析

【输出结果】：

list1: ['apple', 'banana']
list2: ['apple', 'banana']
list3: ['orange']

【原因分析】

Python 函数的默认参数在函数被定义时（而不是被调用时）只会被求值一次

可变对象（如列表 []、字典 {} 等）

共享同一个对象

add_item("apple")

"apple"

list1

add_item("banana")

同一个

"banana"

list1

list2

[]

修改方法

None

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

测验 2：迭代列表时删除元素的悲剧

【题目】：以下这段代码的目标是删除列表中所有的奇数，运行后它能完美实现目标吗？如果不能，结果是什么？

numbers = [1, 2, 3, 4, 5, 6]
for num in numbers:
    if num % 2 != 0:
        numbers.remove(num)
print(numbers)

👉 答案与解析

【输出结果】：没有崩溃，但输出为：[2, 4, 6]？不对，它实际输出是：[2, 4, 6] 的现象是碰巧的吗？让我们仔细看：当 num 为 1 (索引0) 时，被删除。列表变为 [2, 3, 4, 5, 6]。下一轮迭代，循环继续指向索引 1，但此时索引 1 的值已经变成了 3 (因为 2 被往前挤到了索引 0)。这意味着元素 2 被跳过了！然后当 num 为 3 (索引1) 时，被删除。列表变为 [2, 4, 5, 6]。下一轮迭代指向索引 2，此时值是 5 (因为 4 挤到了索引 1)。元素 4 又被跳过了！ 5 被删除，列表变为 [2, 4, 6]。虽然这个例子中刚好删除了奇数，但如果列表是 [1, 3, 4, 5, 6] (连续奇数)，输出会是 [3, 4, 6]（漏删了 3）！ 【原因分析】：在 Python 中，绝不能在遍历一个列表的同时修改该列表的长度。因为这会破坏迭代器的索引指针，导致部分元素被跳过漏检，或者发生越界。 * 修改方法：遍历原列表的拷贝，或者使用列表推导式生成新列表： ```python # 方式一：遍历副本 for num in numbers[:]: # numbers[:] 创建了一个浅拷贝 if num % 2 != 0: numbers.remove(num)

测验 3：类变量与实例变量的混淆

【题目】：预测以下代码的最终输出结果：

class Robot:
    skills = [] # 类变量（共享）

    def __init__(self, name):
        self.name = name # 实例变量

r1 = Robot("R1")
r2 = Robot("R2")

r1.skills.append("run")
r2.skills.append("fly")

print("r1 skills:", r1.skills)
print("r2 skills:", r2.skills)

👉 答案与解析

【输出结果】：

r1 skills: ['run', 'fly']
r2 skills: ['run', 'fly']

【原因分析】

skills = []

类变量 (Class Variable)

static

所有实例共享

r1.skills.append

修改方法

__init__

实例变量 (Instance Variable)

python   class Robot:       def __init__(self, name):           self.name = name           self.skills = [] # 属于每个实例的独立列表

测验 4：闭包与延迟绑定的幽灵

【题目】：以下代码中，我们创建了一个包含 3 个函数的列表，每个函数都应该打印它的索引值。预测执行 funcs[0]() 和 funcs[1]() 的输出结果：

funcs = []
for i in range(3):
    funcs.append(lambda: i)

print(funcs[0]())
print(funcs[1]())

👉 答案与解析

【输出结果】：

2
2

【原因分析】

延迟绑定（Late Binding）

此时并没有执行函数

main

funcs[0]()

修改方法

python   funcs = []   for i in range(3):       # 将当时的 i 作为默认参数绑定给 x       funcs.append(lambda x=i: x)