Python入门教程：从零开始学编程

Python 超详细入门教程

第一章：Python 入门准备

1.1 Python 简介

Python 是一种解释型、面向对象、动态数据类型的高级编程语言，由吉多・范罗苏姆（Guido van Rossum）于 1991 年创建。它具有以下特点：

• 语法简洁清晰：强制用空白符（White Space）作为语句缩进，代码可读性强。
• 丰富的标准库：提供了大量实用的模块和工具，可用于文件处理、网络编程、数据分析等。
• 跨平台：可在 Windows、macOS、Linux 等多种操作系统上运行。
• 广泛的应用领域：Web 开发、数据分析、人工智能、自动化脚本、科学计算等。

1.2 安装 Python

1.2.1 下载 Python

访问 Python 官方网站：https://www.python.org/downloads/，根据你的操作系统选择对应的安装包下载（建议下载最新的稳定版本，如 Python 3.12.x）。

1.2.2 安装 Python（以 Windows 为例）

1.2.3 验证安装

打开命令提示符（Windows：Win+R，输入 cmd；macOS/Linux：打开终端），输入以下命令：

python –version

如果显示 Python 的版本号（如 Python 3.12.0），说明安装成功。

1.3 选择代码编辑器

推荐以下几款常用的 Python 代码编辑器：

• PyCharm：功能强大的 Python IDE，适合大型项目开发，有社区版（免费）和专业版（付费）。
• VS Code：轻量级编辑器，通过安装 Python 插件可实现代码高亮、智能提示、调试等功能，免费且开源。
• Jupyter Notebook：以网页形式展示代码和运行结果，适合数据分析、机器学习等场景。

本教程以 VS Code 为例，你可以从 https://code.visualstudio.com/ 下载安装，并在扩展商店中搜索 "Python" 安装官方插件。

1.4 第一个 Python 程序

print("Hello, World!")

python hello.py

终端将输出：

Hello, World!

恭喜你，成功运行了第一个 Python 程序！

第二章：Python 基础语法

2.1 变量与赋值

2.1.1 变量的定义

在 Python 中，变量不需要声明类型，直接赋值即可创建变量。赋值使用 = 运算符：

# 定义变量
name = "Alice" # 字符串类型
age = 25 # 整数类型
height = 1.65 # 浮点数类型
is_student = True # 布尔类型

2.1.2 变量命名规则

• 变量名只能包含字母、数字和下划线（_），不能以数字开头。
• 变量名不能是 Python 的关键字（如 if、for、class 等）。
• 变量名应具有描述性，如 user_name 比 u 更易读。
• 变量名区分大小写，Name 和 name 是两个不同的变量。

2.1.3 多变量赋值

# 同时给多个变量赋值
a, b, c = 1, 2, 3
print(a, b, c) # 输出：1 2 3

# 给多个变量赋相同的值
x = y = z = 10
print(x, y, z) # 输出：10 10 10

2.2 数据类型

Python 常见的数据类型包括：整数（int）、浮点数（float）、字符串（str）、布尔值（bool）、列表（list）、元组（tuple）、字典（dict）、集合（set）等。

2.2.1 整数和浮点数

# 整数
num1 = 10
num2 = -5
print(type(num1)) # 输出：<class 'int'>

# 浮点数
num3 = 3.14
num4 = 2.0
print(type(num3)) # 输出：<class 'float'>

# 数学运算
print(5 + 3) # 加法：8
print(5 – 3) # 减法：2
print(5 * 3) # 乘法：15
print(5 / 3) # 除法：1.666…
print(5 // 3) # 整除：1
print(5 % 3) # 取余：2
print(5 ** 3) # 幂运算：125

2.2.2 字符串

字符串是用单引号（'）、双引号（"）或三引号（'''/"""）包裹的文本。

# 字符串定义
str1 = 'Hello'
str2 = "World"
str3 = '''这是一个
多行字符串'''

# 字符串拼接
print(str1 + " " + str2) # 输出：Hello World

# 字符串重复
print(str1 * 3) # 输出：HelloHelloHello

# 字符串索引（从 0 开始）
print(str1[0]) # 输出：H
print(str1[-1]) # 输出：o（负索引从末尾开始）

# 字符串切片：[起始索引:结束索引:步长]
print(str1[1:4]) # 输出：ell（不包含结束索引）
print(str1[:3]) # 输出：Hel（从开头到索引 2）
print(str1[2:]) # 输出：llo（从索引 2 到末尾）
print(str1[::2]) # 输出：Hlo（步长为 2）

# 字符串常用方法
print(str1.upper()) # 转大写：HELLO
print(str1.lower()) # 转小写：hello
print(str1.replace("l", "x")) # 替换：Hexxo
print(str1.split("e")) # 分割：['H', 'llo']
print(" Hello ".strip()) # 去除首尾空格：Hello

2.2.3 布尔值

布尔值只有两个：True（真）和 False（假），常用于条件判断。

print(10 > 5) # 输出：True
print(10 == 5) # 输出：False
print(not True) # 输出：False
print(True and False) # 输出：False（与运算：全真才真）
print(True or False) # 输出：True（或运算：一真则真）

2.2.4 类型转换

使用 int()、float()、str()、bool() 等函数进行类型转换：

# 字符串转整数
num_str = "123"
num_int = int(num_str)
print(type(num_int)) # 输出：<class 'int'>

# 整数转浮点数
num_float = float(num_int)
print(num_float) # 输出：123.0

# 数字转字符串
str_num = str(num_int)
print(type(str_num)) # 输出：<class 'str'>

# 布尔值转换
print(bool(0)) # 输出：False（0、空字符串、空列表等为 False）
print(bool(10)) # 输出：True（非零值、非空值为 True）

2.3 输入与输出

2.3.1 输出：print ()

# 输出多个值，用逗号分隔
print("姓名:", "Alice", "年龄:", 25) # 输出：姓名: Alice 年龄: 25

# 格式化输出
name = "Bob"
age = 30
# 方式 1：使用 % 占位符
print("姓名: %s, 年龄: %d" % (name, age))
# 方式 2：使用 format() 方法
print("姓名: {}, 年龄: {}".format(name, age))
# 方式 3：f-string（推荐，Python 3.6+）
print(f"姓名: {name}, 年龄: {age}")

2.3.2 输入：input ()

input() 函数接收用户输入，返回字符串类型：

name = input("请输入你的姓名: ")
age = int(input("请输入你的年龄: ")) # 将输入转换为整数
print(f"你好，{name}，你今年 {age} 岁了！")

第三章：控制流

3.1 条件语句：if-elif-else

score = 85

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

注意：Python 使用缩进（通常 4 个空格）来表示代码块，缩进错误会导致程序报错。

3.2 循环语句

3.2.1 for 循环

for 循环用于遍历可迭代对象（如列表、字符串、range () 等）：

# 遍历字符串
for char in "Hello":
print(char)

# 遍历列表
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
print(fruit)

# 使用 range() 生成数字序列
# range(stop)：0 到 stop-1
for i in range(5):
print(i) # 输出：0 1 2 3 4

# range(start, stop)：start 到 stop-1
for i in range(2, 6):
print(i) # 输出：2 3 4 5

# range(start, stop, step)：步长为 step
for i in range(1, 10, 2):
print(i) # 输出：1 3 5 7 9

3.2.2 while 循环

while 循环在条件为 True 时重复执行代码块：

# 计算 1 到 10 的和
sum = 0
i = 1
while i <= 10:
sum += i
i += 1
print(f"1 到 10 的和为: {sum}") # 输出：55

3.2.3 循环控制语句

• break：跳出当前循环。
• continue：跳过当前循环的剩余代码，进入下一次循环。
• pass：空语句，不执行任何操作，仅作为占位符。

# break 示例
for i in range(5):
if i == 3:
break
print(i) # 输出：0 1 2

# continue 示例
for i in range(5):
if i == 3:
continue
print(i) # 输出：0 1 2 4

第四章：数据结构

4.1 列表（list）

列表是有序、可变的元素集合，用 [] 表示。

4.1.1 列表的创建与访问

# 创建列表
list1 = [1, 2, 3, "Hello", True]
list2 = [] # 空列表
list3 = list(range(5)) # 使用 list() 函数创建：[0, 1, 2, 3, 4]

# 访问列表元素（索引从 0 开始）
print(list1[0]) # 输出：1
print(list1[-1]) # 输出：True

# 列表切片
print(list1[1:4]) # 输出：[2, 3, 'Hello']

4.1.2 列表的常用操作

list1 = [1, 2, 3]

# 添加元素
list1.append(4) # 在末尾添加：[1, 2, 3, 4]
list1.insert(1, "a") # 在指定位置插入：[1, 'a', 2, 3, 4]

# 删除元素
list1.remove("a") # 删除指定元素：[1, 2, 3, 4]
list1.pop() # 删除末尾元素并返回：4，列表变为 [1, 2, 3]
list1.pop(0) # 删除指定索引元素并返回：1，列表变为 [2, 3]
del list1[0] # 删除指定索引元素：列表变为 [3]

# 修改元素
list1[0] = 10 # 列表变为 [10]

# 列表拼接与重复
list2 = [4, 5]
print(list1 + list2) # 输出：[10, 4, 5]
print(list2 * 2) # 输出：[4, 5, 4, 5]

# 列表常用方法
list3 = [3, 1, 4, 1, 5]
print(len(list3)) # 长度：5
print(list3.index(1)) # 元素第一次出现的索引：1
print(list3.count(1)) # 元素出现的次数：2
list3.sort() # 排序：[1, 1, 3, 4, 5]
list3.reverse() # 反转：[5, 4, 3, 1, 1]

4.2 元组（tuple）

元组是有序、不可变的元素集合，用 () 表示。

# 创建元组
tuple1 = (1, 2, 3, "Hello")
tuple2 = () # 空元组
tuple3 = (1,) # 单元素元组必须加逗号，否则会被当作整数

# 访问元组元素（与列表相同）
print(tuple1[0]) # 输出：1
print(tuple1[1:3]) # 输出：(2, 3)

# 元组不可修改，以下操作会报错
# tuple1[0] = 10

# 元组的常用操作（与列表类似，但无修改方法）
print(len(tuple1)) # 长度：4
print(tuple1 + (4, 5)) # 拼接：(1, 2, 3, 'Hello', 4, 5)

4.3 字典（dict）

字典是无序的 ** 键值对（key-value）** 集合，用 {} 表示，键必须唯一且不可变（如字符串、数字、元组）。

4.3.1 字典的创建与访问

# 创建字典
dict1 = {"name": "Alice", "age": 25, "is_student": True}
dict2 = {} # 空字典
dict3 = dict(name="Bob", age=30) # 使用 dict() 函数创建

# 访问字典元素
print(dict1["name"]) # 通过键访问：Alice
print(dict1.get("age")) # 通过 get() 方法访问：25
print(dict1.get("gender", "未知")) # 键不存在时返回默认值：未知

4.3.2 字典的常用操作

dict1 = {"name": "Alice", "age": 25}

# 添加/修改元素
dict1["gender"] = "女" # 添加键值对：{'name': 'Alice', 'age': 25, 'gender': '女'}
dict1["age"] = 26 # 修改键值对：{'name': 'Alice', 'age': 26, 'gender': '女'}

# 删除元素
del dict1["gender"] # 删除指定键值对：{'name': 'Alice', 'age': 26}
age = dict1.pop("age") # 删除指定键并返回值：26，字典变为 {'name': 'Alice'}

# 字典常用方法
print(dict1.keys()) # 获取所有键：dict_keys(['name'])
print(dict1.values()) # 获取所有值：dict_values(['Alice'])
print(dict1.items()) # 获取所有键值对：dict_items([('name', 'Alice')])

# 遍历字典
for key, value in dict1.items():
print(f"{key}: {value}")

4.4 集合（set）

集合是无序、唯一的元素集合，用 {} 或 set() 表示（空集合必须用 set()）。

# 创建集合
set1 = {1, 2, 3, 3} # 自动去重：{1, 2, 3}
set2 = set() # 空集合
set3 = set([1, 2, 2, 3]) # 从列表创建：{1, 2, 3}

# 集合的常用操作
set1 = {1, 2, 3}
set2 = {3, 4, 5}

print(set1 & set2) # 交集：{3}
print(set1 | set2) # 并集：{1, 2, 3, 4, 5}
print(set1 – set2) # 差集：{1, 2}

# 添加/删除元素
set1.add(4) # 添加元素：{1, 2, 3, 4}
set1.remove(2) # 删除指定元素：{1, 3, 4}
set1.discard(5) # 删除元素，不存在不报错

第五章：函数

5.1 函数的定义与调用

使用 def 关键字定义函数，语法如下：

def 函数名(参数列表):
"""函数文档字符串（可选，用于说明函数功能）"""
函数体
return 返回值（可选）

5.1.1 无参数无返回值的函数

def greet():
"""打印问候语"""
print("Hello!")

# 调用函数
greet() # 输出：Hello!

5.1.2 有参数有返回值的函数

def add(a, b):
"""计算两个数的和"""
return a + b

result = add(3, 5)
print(result) # 输出：8

5.2 函数的参数

5.2.1 位置参数

按顺序传递参数：

def introduce(name, age):
print(f"我叫 {name}，今年 {age} 岁。")

introduce("Alice", 25) # 输出：我叫 Alice，今年 25 岁。

5.2.2 关键字参数

通过参数名传递参数，顺序可以任意：

introduce(age=30, name="Bob") # 输出：我叫 Bob，今年 30 岁。

5.2.3 默认参数

定义函数时给参数设置默认值，调用时可省略该参数：

def introduce(name, age=18):
print(f"我叫 {name}，今年 {age} 岁。")

introduce("Charlie") # 输出：我叫 Charlie，今年 18 岁。
introduce("David", 20) # 输出：我叫 David，今年 20 岁。

注意：默认参数必须放在位置参数后面。

5.2.4 可变参数

• *args：接收任意数量的位置参数，以元组形式存储。
• **kwargs：接收任意数量的关键字参数，以字典形式存储。

def func(*args, **kwargs):
print("args:", args)
print("kwargs:", kwargs)

func(1, 2, 3, name="Alice", age=25)
# 输出：
# args: (1, 2, 3)
# kwargs: {'name': 'Alice', 'age': 25}

5.3 变量的作用域

• 局部变量：在函数内部定义的变量，仅在函数内部有效。
• 全局变量：在函数外部定义的变量，在整个程序中有效。

x = 10 # 全局变量

def func():
x = 20 # 局部变量
print("函数内部 x:", x)

func() # 输出：函数内部 x: 20
print("函数外部 x:", x) # 输出：函数外部 x: 10

# 使用 global 关键字在函数内部修改全局变量
def func2():
global x
x = 30

func2()
print("修改后的全局变量 x:", x) # 输出：修改后的全局变量 x: 30

5.4 lambda 函数（匿名函数）

lambda 函数是一种简洁的匿名函数，语法如下：

lambda 参数列表: 表达式

示例：

# 定义一个计算两数之和的 lambda 函数
add = lambda a, b: a + b
print(add(3, 5)) # 输出：8

# 结合 sorted() 使用，按列表元素的第二个值排序
list1 = [(1, 3), (2, 1), (3, 2)]
list1_sorted = sorted(list1, key=lambda x: x[1])
print(list1_sorted) # 输出：[(2, 1), (3, 2), (1, 3)]

第六章：模块与包

6.1 模块的导入

模块是一个包含 Python 代码的 .py 文件，可通过 import 语句导入使用。

6.1.1 导入整个模块

import math

print(math.pi) # 圆周率：3.141592653589793
print(math.sqrt(16)) # 平方根：4.0

6.1.2 导入模块中的特定函数或变量

from math import pi, sqrt

print(pi)
print(sqrt(16))

6.1.3 导入模块并起别名

import math as m

print(m.pi)
print(m.sqrt(16))

6.1.4 导入模块中的所有内容（不推荐）

from math import *

print(pi)
print(sqrt(16))

6.2 自定义模块

创建一个名为 my_module.py 的文件，内容如下：

# my_module.py
def greet(name):
print(f"Hello, {name}!")

pi = 3.14159

在另一个文件中导入并使用：

import my_module

my_module.greet("Alice") # 输出：Hello, Alice!
print(my_module.pi) # 输出：3.14159

6.3 包的使用

包是一个包含 __init__.py 文件的文件夹，用于组织多个模块。

6.3.1 创建包

创建一个名为 my_package 的文件夹，在其中创建 __init__.py（可为空）和两个模块文件：

my_package/
__init__.py
module1.py
module2.py

module1.py 内容：

def func1():
print("这是 module1 中的 func1")

module2.py 内容：

def func2():
print("这是 module2 中的 func2")

6.3.2 导入包中的模块

from my_package import module1, module2

module1.func1() # 输出：这是 module1 中的 func1
module2.func2() # 输出：这是 module2 中的 func2

6.4 常用标准库

• os：提供与操作系统交互的功能，如文件操作、目录操作。
• sys：提供与 Python 解释器交互的功能，如命令行参数、退出程序。
• random：生成随机数。
• datetime：处理日期和时间。
• json：处理 JSON 数据。

示例：使用 random 生成随机数

import random

print(random.randint(1, 10)) # 生成 1 到 10 之间的随机整数
print(random.random()) # 生成 0 到 1 之间的随机浮点数
print(random.choice(["苹果", "香蕉", "橙子"])) # 从列表中随机选择一个元素

第七章：异常处理

7.1 异常的概念

程序运行时出现的错误称为异常，如除数为零、索引越界、文件不存在等。若不处理异常，程序会崩溃并退出。

7.2 try-except 语句

使用 try-except 语句捕获并处理异常：

try:
# 可能出现异常的代码
num = int(input("请输入一个整数: "))
result = 10 / num
print(f"结果: {result}")
except ValueError:
# 处理 ValueError 异常（输入不是整数）
print("错误：请输入有效的整数！")
except ZeroDivisionError:
# 处理 ZeroDivisionError 异常（除数为零）
print("错误：除数不能为零！")
except Exception as e:
# 处理其他所有异常
print(f"发生未知错误: {e}")
else:
# 没有异常时执行
print("程序执行成功！")
finally:
# 无论是否有异常都会执行
print("程序结束。")

7.3 抛出异常

使用 raise 语句主动抛出异常：

def check_age(age):
if age < 0:
raise ValueError("年龄不能为负数！")
print(f"年龄: {age}")

try:
check_age(-5)
except ValueError as e:
print(e) # 输出：年龄不能为负数！

第八章：文件操作

8.1 打开文件

使用 open() 函数打开文件，语法如下：

open(文件路径, 打开模式, encoding='编码格式')

常用打开模式：

8.2 读取文件

# 方式 1：read() 读取全部内容
with open("test.txt", "r", encoding="utf-8") as f:
content = f.read()
print(content)

# 方式 2：readline() 逐行读取
with open("test.txt", "r", encoding="utf-8") as f:
line1 = f.readline()
line2 = f.readline()
print(line1, end="")
print(line2, end="")

# 方式 3：readlines() 读取所有行，返回列表
with open("test.txt", "r", encoding="utf-8") as f:
lines = f.readlines()
for line in lines:
print(line, end="")

注意：使用 with 语句可以自动关闭文件，无需手动调用 f.close()。

8.3 写入文件

# 方式 1：write() 写入字符串
with open("test.txt", "w", encoding="utf-8") as f:
f.write("Hello, World!\\n")
f.write("这是第二行。")

# 方式 2：writelines() 写入列表
lines = ["第一行\\n", "第二行\\n", "第三行"]
with open("test.txt", "w", encoding="utf-8") as f:
f.writelines(lines)

第九章：综合实践：简单的待办事项管理器

9.1 功能需求

• 添加待办事项
• 查看所有待办事项
• 标记待办事项为已完成
• 删除待办事项
• 退出程序

9.2 代码实现

import json

# 待办事项文件路径
TODO_FILE = "todo_list.json"

def load_todo_list():
"""从文件加载待办事项"""
try:
with open(TODO_FILE, "r", encoding="utf-8") as f:
return json.load(f)
except FileNotFoundError:
return []

def save_todo_list(todo_list):
"""保存待办事项到文件"""
with open(TODO_FILE, "w", encoding="utf-8") as f:
json.dump(todo_list, f, ensure_ascii=False, indent=4)

def add_todo(todo_list):
"""添加待办事项"""
content = input("请输入待办事项内容: ")
todo = {"content": content, "completed": False}
todo_list.append(todo)
save_todo_list(todo_list)
print("添加成功！")

def view_todo_list(todo_list):
"""查看所有待办事项"""
if not todo_list:
print("暂无待办事项。")
return
print("=" * 30)
for i, todo in enumerate(todo_list, 1):
status = "✓" if todo["completed"] else "✗"
print(f"{i}. [{status}] {todo['content']}")
print("=" * 30)

def mark_completed(todo_list):
"""标记待办事项为已完成"""
view_todo_list(todo_list)
if not todo_list:
return
try:
index = int(input("请输入要标记的待办事项编号: ")) – 1
if 0 <= index < len(todo_list):
todo_list[index]["completed"] = True
save_todo_list(todo_list)
print("标记成功！")
else:
print("无效的编号！")
except ValueError:
print("请输入有效的数字！")

def delete_todo(todo_list):
"""删除待办事项"""
view_todo_list(todo_list)
if not todo_list:
return
try:
index = int(input("请输入要删除的待办事项编号: ")) – 1
if 0 <= index < len(todo_list):
del todo_list[index]
save_todo_list(todo_list)
print("删除成功！")
else:
print("无效的编号！")
except ValueError:
print("请输入有效的数字！")

def main():
"""主函数"""
todo_list = load_todo_list()
while True:
print("\\n===== 待办事项管理器 =====")
print("1. 添加待办事项")
print("2. 查看所有待办事项")
print("3. 标记待办事项为已完成")
print("4. 删除待办事项")
print("5. 退出")
choice = input("请选择操作: ")

if choice == "1":
add_todo(todo_list)
elif choice == "2":
view_todo_list(todo_list)
elif choice == "3":
mark_completed(todo_list)
elif choice == "4":
delete_todo(todo_list)
elif choice == "5":
print("再见！")
break
else:
print("无效的选择，请重新输入！")

if __name__ == "__main__":
main()

第十章：进阶学习建议