Python作为当今最流行、最易学、应用最广的编程语言之一,正被广泛应用于数据分析、人工智能、Web开发、自动化运维、网络爬虫、科学计算、教育科研等领域。无论您是零基础的小白、在校学生、转行者,还是希望系统提升编程能力的职场人士,Python基础学习都是您迈出第一步的关键起点。
本页面提供全面、系统、深入的Python基础学习资源,涵盖从环境搭建、语法结构、数据类型到函数编程、模块使用、异常处理、文件操作、网络编程、爬虫开发、自动化办公、Web开发等核心模块,配合大量真实代码示例、对比表格、流程图解与学习路径建议,助您构建扎实的编程基础,形成清晰的知识体系。
我们坚持“学以致用”的理念,所有内容均基于真实项目经验提炼,强调可操作性与工程思维,拒绝空洞理论。每个章节均包含典型应用场景、常见误区、调试技巧与最佳实践,确保您在掌握语法的同时,理解Python的编程哲学与设计范式。
与其他编程语言相比,Python具有以下显著优势:
但需注意:Python并非“万能胶水语言”的替代品。对于高并发、低延迟、嵌入式等场景,仍需结合C/C++、Rust、Go等语言。**Python基础学习**的目标是建立编程思维与工程能力,而非追求极致性能。
本页面将按此逻辑展开,每个模块均含完整示例、对比分析与常见陷阱提醒。建议配合本地实践,边学边练,效果更佳。
**Python基础学习**的起点在于掌握其语法规范与编程范式。Python采用动态类型、强类型、解释型语言设计,这意味着变量类型无需声明,但类型转换必须显式;解释执行带来开发效率,但运行速度低于编译型语言。理解这些底层特性,有助于规避常见错误。
变量命名遵循“小写字母+下划线”风格(snake_case),避免使用Python关键字(如class、def、if等)。变量赋值采用“=”,但并非传统意义上的“存储”,而是绑定引用(binding)。例如:
x = 10
y = x
x = 20
print(y) # 输出:10
此处y绑定的是10的引用,修改x不会影响y。对于可变对象(如列表),则需注意引用共享问题:
a = [1, 2, 3]
b = a
a.append(4)
print(b) # 输出:[1, 2, 3, 4]
解决方法:使用浅拷贝(b = a.copy())或深拷贝(import copy; b = copy.deepcopy(a))。
Python内置六种标准数据类型:Number(数字)、String(字符串)、List(列表)、Tuple(元组)、Dict(字典)、Set(集合)。其中Number、String、Tuple为不可变类型;List、Dict、Set为可变类型。
| 类型 | 是否可变 | 典型用途 | 常见操作 |
|---|---|---|---|
| int / float | 否 | 数值计算 | +, -, *, /, //, %, ** |
| str | 否 | 文本处理 | +, *, len(), .split(), .join(), .replace() |
| list | 是 | 有序序列 | append(), insert(), pop(), sort(), sorted() |
| tuple | 否 | 固定数据集 | 索引、切片、解包 |
| dict | 是 | 键值映射 | .get(), .keys(), .values(), .items() |
| set | 是 | 去重、集合运算 | union(), intersection(), difference() |
特别提醒:字符串拼接应避免在循环中使用“+”,推荐使用str.join()或f-string(Python 3.6+)提升性能。例如:
# 低效写法
s = ""
for i in range(1000):
s += str(i)
# 高效写法
s = "".join(str(i) for i in range(1000))
# f-string写法(推荐)
name = "张三"
age = 25
msg = f"姓名:{name},年龄:{age}"
Python通过缩进(4空格)定义代码块,替代传统的大括号。常见结构包括:
示例:筛选1~100中能被3整除的偶数
# 传统写法
nums = []
for i in range(1, 101):
if i % 3 == 0 and i % 2 == 0:
nums.append(i)
# 推导式写法
nums = [i for i in range(1, 101) if i % 6 == 0]
# 输出:[6, 12, 18, ..., 96]
标准输入使用input()函数,返回字符串类型,需手动转换:
age = int(input("请输入年龄:"))
height = float(input("请输入身高(米):"))
print(f"年龄:{age},身高:{height:.2f}米")
输出使用print(),支持格式化参数:
示例:倒计时输出(不换行)
import time
for i in range(5, 0, -1):
print(f"倒计时:{i}秒...", end="\r")
time.sleep(1)
print("发射!")
**Python基础学习**中,数据结构是程序逻辑的骨架。正确选择数据类型,可大幅提升代码可读性与性能。本节将对比列表、元组、字典、集合的特性与适用场景。
列表是有序、可变的序列,支持索引、切片、追加、排序等操作。常用于存储同质数据或需要频繁修改的集合。
典型场景:
注意陷阱:
# 创建列表
scores = [95, 88, 76, 92]
names = list(("张三", "李四", "王五"))
# 修改与查询
scores[1] = 90 # 修改第二个元素
print(scores[0:2]) # 切片:[95, 90]
print(scores.index(90)) # 查找索引:1
# 追加与插入
scores.append(85)
scores.insert(0, 100) # 插入到开头
# 删除元素
removed = scores.pop() # 移除末尾
scores.remove(76) # 移除指定值
# 排序(原地)
scores.sort(reverse=True) # 降序
scores.reverse() # 反转
元组是有序、不可变的序列,常用于固定数据集、函数多返回值、字典键等场景。其不可变性带来哈希能力(可作为字典键)与内存效率。
典型场景:
注意陷阱:
point = (10, 20) # 正确
coord = (10) # 错误!实际为int类型
data = ([1, 2], [3, 4])
data[0].append(5) # 合法!元组本身未变,内部列表可变
print(data) # 输出:([1, 2, 5], [3, 4])
字典是无序、可变的键值对集合,通过哈希表实现O(1)时间复杂度的查找。键必须可哈希(不可变),值无限制。
典型场景:
注意陷阱:
# 创建字典
user = {"name": "张三", "age": 25}
config = dict(host="localhost", port=8080)
# 访问与修改
print(user["name"]) # 报错风险:若键不存在
print(user.get("email", "未填写")) # 安全:默认值
user["age"] = 26 # 修改
user["email"] = "zhangsan@example.com" # 新增
# 遍历
for key, value in user.items():
print(f"{key} = {value}")
# 统计词频
text = "Python基础学习很有趣,Python很强大"
words = text.replace(",", "").split()
freq = {}
for w in words:
freq[w] = freq.get(w, 0) + 1
print(freq) # {'Python': 2, '基础学习很有趣': 1, '很强大': 1}
集合是无序、不重复的元素集,支持交集、并集、差集等数学运算。常用于去重、成员测试、关系判断。
典型场景:
注意陷阱:
# 创建集合
tags = {"Python", "爬虫", "自动化", "Python"} # 自动去重
unique_tags = set(["Python", "爬虫", "自动化"])
# 基本操作
tags.add("数据分析")
tags.remove("爬虫") # 不存在则报错
tags.discard("不存在") # 安全删除
# 关系运算
set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}
print(set_a & set_b) # 交集:{3, 4}
print(set_a | set_b) # 并集:{1, 2, 3, 4, 5, 6}
print(set_a - set_b) # 差集:{1, 2}
# 去重应用
ids = [1, 2, 2, 3, 3, 3]
unique_ids = list(set(ids)) # 注意:顺序可能改变
| 操作 | 列表list | 字典dict | 集合set | 元组tuple |
|---|---|---|---|---|
| 索引/查找 | O(1)(按位置) | O(1)(按键) | O(1)(成员测试) | O(1) |
| 插入末尾 | O(1)均摊 | O(1) | O(1) | 不可变 |
| 插入中间 | O(n) | — | — | 不可变 |
| 删除末尾 | O(1) | O(1) | O(1) | 不可变 |
| 删除中间 | O(n) | O(1) | O(1) | 不可变 |
| 遍历 | O(n) | O(n) | O(n) | O(n) |
| 内存占用 | 中 | 高(哈希表) | 中高 | 低 |
**Python基础学习**中,函数是代码复用的核心单元。合理设计函数,可提升可维护性、可测试性与协作效率。Python支持位置参数、关键字参数、默认参数、可变参数等灵活调用方式。
函数定义使用def关键字,格式为:def 函数名(参数列表):。参数传递采用“传对象引用”,即传递的是对象的引用,而非值拷贝。
参数类型详解:
def greet(name, msg="你好", *args, **kwargs):
print(f"{msg}, {name}!")
if args:
print(f"额外信息:{', '.join(args)}")
if kwargs:
print(f"扩展信息:{kwargs}")
# 调用示例
greet("张三")
# 输出:你好, 张三!
greet("李四", "早上好", "已到岗", "今日任务:代码审查")
# 输出:早上好, 李四!
# 额外信息:已到岗, 今日任务:代码审查
greet("王五", age=28, dept="技术部", role="工程师")
# 输出:你好, 王五!
# 扩展信息:{'age': 28, 'dept': '技术部', 'role': '工程师'}
Python函数可返回单个或多个值。多返回值本质是返回元组,调用时自动解包:
def get_stats(numbers):
if not numbers:
return None, None
return min(numbers), max(numbers), sum(numbers) / len(numbers)
nums = [10, 20, 30, 40, 50]
min_val, max_val, avg = get_stats(nums)
print(f"最小值:{min_val},最大值:{max_val},平均值:{avg:.2f}")
最佳实践:优先返回结构化数据(如字典或命名元组),增强可读性与扩展性。
Python遵循LEGB规则(Local → Enclosing → Global → Built-in)查找变量。闭包(closure)是指内部函数引用外部函数变量的组合,常用于装饰器、回调等场景。
def make_counter():
count = 0
def counter():
nonlocal count # 声明使用外层变量
count += 1
return count
return counter
c1 = make_counter()
print(c1()) # 1
print(c1()) # 2
print(c1()) # 3
闭包可替代全局变量,避免命名污染,但需注意内存泄漏风险(长期持有引用)。
lambda表达式用于定义简单匿名函数,常与map、filter、sorted等高阶函数配合使用:
# map:映射
nums = [1, 2, 3, 4]
squares = list(map(lambda x: x**2, nums))
# filter:过滤
evens = list(filter(lambda x: x % 2 == 0, nums))
# sorted:排序(指定键)
students = [
{"name": "张三", "score": 88},
{"name": "李四", "score": 95},
{"name": "王五", "score": 76}
]
sorted_students = sorted(students, key=lambda s: s["score"], reverse=True)
但复杂逻辑不建议使用lambda,应定义具名函数提升可读性。
**Python基础学习**中,模块化是大型项目的基础。Python通过模块(.py文件)和包(含__init__.py的目录)组织代码,支持绝对导入与相对导入。
常见导入方式包括:
import module:导入模块,调用时需加前缀;from module import name:导入特定对象;from module import *:导入全部(不推荐,易冲突);import module as alias:重命名。示例:导入标准库time与自定义模块
# 导入标准库
import time
from datetime import datetime
# 导入自定义模块(假设在同一目录)
import utils
from utils import calculate_score
# 使用
print(time.time())
print(calculate_score(85, 90))
标准包结构如下:
project/
├── main.py
└── utils/
├── __init__.py
├── file_ops.py
└── text_utils.py
在main.py中可这样导入:
from utils.file_ops import read_file
from utils.text_utils import clean_text
# 或使用相对导入(在utils/__init__.py中)
# from .file_ops import read_file
注意:相对导入仅适用于包内模块,不可在顶层脚本中使用。
import os
from pathlib import Path
# 创建目录
Path("logs").mkdir(exist_ok=True)
# 遍历文件
for f in Path(".").glob("*.py"):
print(f"文件:{f.name},大小:{f.stat().st_size}字节")
# 环境变量
print(os.getenv("PYTHONPATH"))
import sys
# 命令行参数
print(sys.argv) # ['script.py', 'arg1', 'arg2']
# 路径搜索
print(sys.path)
# 标准输入输出
sys.stdout.write("提示:")
import json
data = {"name": "张三", "age": 25}
json_str = json.dumps(data, ensure_ascii=False)
print(json_str)
loaded = json.loads(json_str)
import re
text = "联系电话:138-1234-5678"
pattern = r"\d{3}-\d{4}-\d{4}"
match = re.search(pattern, text)
if match:
print(f"找到号码:{match.group()}")
from collections import Counter, defaultdict, deque
# 计数器
words = ["a", "b", "a", "c", "b", "a"]
counter = Counter(words)
print(counter.most_common(2)) # [('a', 3), ('b', 2)]
# 默认字典
dd = defaultdict(int)
dd["count"] += 1 # 无需初始化
# 双端队列
dq = deque([1, 2, 3])
dq.appendleft(0)
dq.append(4)
print(dq) # deque([0, 1, 2, 3, 4])
**Python基础学习**中,健壮的错误处理是专业开发的标志。Python通过try-except-finally结构处理异常,支持自定义异常类型。
系统内置异常继承自BaseException,常用子类包括:
示例:捕获并处理异常
def safe_divide(a, b):
try:
return a / b
except ZeroDivisionError:
print("警告:除数不能为零!")
return None
except TypeError:
print("错误:参数类型不匹配!")
return None
finally:
print("操作完成")
print(safe_divide(10, 0)) # 输出:警告:除数不能为零!\n操作完成\nNone
通过继承Exception类创建自定义异常,用于业务逻辑错误:
class InvalidScoreError(Exception):
def __init__(self, score):
self.score = score
super().__init__(f"无效分数:{score}(应为0-100)")
def validate_score(score):
if not 0 <= score <= 100:
raise InvalidScoreError(score)
return score
try:
validate_score(120)
except InvalidScoreError as e:
print(e) # 输出:无效分数:120(应为0-100)
高效调试是程序员核心技能,推荐以下方法:
import logging
logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s")
def process_data(data):
logging.debug(f"输入数据:{data}")
if not data:
logging.warning("数据为空!")
return []
result = [x * 2 for x in data]
logging.info(f"处理完成,结果:{result}")
return result
断言仅在调试模式有效,发布时可关闭(python -O运行):
def calculate_avg(numbers):
assert isinstance(numbers, list), "参数必须是列表"
assert len(numbers) > 0, "列表不能为空"
return sum(numbers) / len(numbers)
# 正常运行
print(calculate_avg([1, 2, 3]))
# 发布时关闭断言
# python -O script.py
**Python基础学习**中,文件I/O是数据持久化的核心。Python通过open()函数操作文件,配合with语句确保资源释放。
open()函数参数说明:
文本文件读写示例:
# 写入文本
with open("notes.txt", "w", encoding="utf-8") as f:
f.write("Python基础学习笔记\n")
f.write("今日重点:列表推导式\n")
# 读取文本
with open("notes.txt", "r", encoding="utf-8") as f:
content = f.read()
print(content)
# 按行读取
with open("notes.txt", "r", encoding="utf-8") as f:
for line in f:
print(line.strip()) # 去除换行
图片、音频、视频等二进制文件需用"rb"或"wb"模式:
# 复制图片
with open("logo.png", "rb") as src, open("logo_copy.png", "wb") as dst:
dst.write(src.read())
使用pathlib.Path统一处理跨平台路径:
from pathlib import Path
# 构建路径
data_dir = Path("data") / "2024" / "reports"
data_dir.mkdir(parents=True, exist_ok=True)
# 拼接路径
config_path = Path.home() / ".config" / "app.ini"
# 获取文件信息
file = Path("notes.txt")
print(f"文件名:{file.name}")
print(f"扩展名:{file.suffix}")
print(f"大小:{file.stat().st_size}字节")
print(f"是否存在:{file.exists()}")
with语句自动管理资源,即使发生异常也会正确关闭文件:
class FileLogger:
def __init__(self, filename):
self.filename = filename
self.file = None
def __enter__(self):
self.file = open(self.filename, "w", encoding="utf-8")
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if self.file:
self.file.close()
def log(self, msg):
if self.file:
self.file.write(f"{msg}\n")
# 使用
with FileLogger("app.log") as logger:
logger.log("程序启动")
# 即使此处报错,文件也会关闭
**Python基础学习**中,网络编程是连接外部世界的关键。Python通过socket模块实现底层通信,requests库简化HTTP请求。
服务端(server.py):
import socket
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("127.0.0.1", 8080))
server.listen(5)
print("服务器启动,等待连接...")
while True:
client, addr = server.accept()
print(f"连接来自:{addr}")
data = client.recv(1024)
client.send(f"收到:{data.decode()}".encode())
client.close()
客户端(client.py):
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(("127.0.0.1", 8080))
client.send("你好,服务器!".encode())
response = client.recv(1024)
print(f"服务器响应:{response.decode()}")
client.close()
使用requests库发送GET/POST请求:
import requests
# GET请求
response = requests.get("https://api.github.com/repos/python/cpython")
print(f"状态码:{response.status_code}")
print(f"标题:{response.headers['Content-Type']}")
print(f"内容长度:{len(response.text)}")
# 带参数GET
params = {"q": "python", "sort": "stars"}
repos = requests.get("https://api.github.com/search/repositories", params=params)
print(f"搜索结果数:{repos.json()['total_count']}")
# POST请求
payload = {"username": "test", "password": "123456"}
res = requests.post("https://httpbin.org/post", data=payload)
print(res.json()["form"])
网络请求需处理常见异常:
import requests
from requests.exceptions import RequestException, Timeout, ConnectionError
try:
response = requests.get("https://httpbin.org/delay/3", timeout=2)
print(response.json())
except Timeout:
print("请求超时!")
except ConnectionError:
print("连接失败!")
except RequestException as e:
print(f"请求异常:{e}")
**Python基础学习**中,爬虫是综合应用的典型场景。通过requests获取页面,BeautifulSoup解析HTML,配合正则表达式提取数据。
安装依赖:
pip install requests beautifulsoup4 lxml
爬虫代码:
import requests
from bs4 import BeautifulSoup
def fetch_page(url):
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
}
try:
response = requests.get(url, headers=headers, timeout=10)
response.raise_for_status()
return response.text
except requests.RequestException as e:
print(f"请求失败:{e}")
return None
def parse_news(html):
soup = BeautifulSoup(html, "lxml")
items = []
for li in soup.select("li.news-item"):
title = li.a.get_text(strip=True)
link = li.a["href"]
date = li.span.get_text(strip=True)
items.append({"title": title, "link": link, "date": date})
return items
# 使用
html = fetch_page("https://example.com/news")
if html:
news = parse_news(html)
for item in news[:5]:
print(f"[{item['date']}] {item['title']}")
常见反爬手段及对策:
注意:遵守robots.txt协议,尊重网站权益!
爬取数据可存储为:
示例:存储为CSV
import csv
with open("news.csv", "w", newline="", encoding="utf-8") as f:
writer = csv.DictWriter(f, fieldnames=["title", "link", "date"])
writer.writeheader()
writer.writerows(news)
**Python基础学习**的终极目标是提升工作效率。通过Python自动化处理Excel、Word、PDF、邮件等办公任务,释放重复劳动。
安装:pip install openpyxl
from openpyxl import Workbook, load_workbook
# 创建新工作簿
wb = Workbook()
ws = wb.active
ws.title = "成绩表"
# 写入数据
ws.append(["姓名", "语文", "数学", "英语"])
ws.append(["张三", 92, 88, 95])
ws.append(["李四", 85, 90, 88])
# 样式设置
from openpyxl.styles import Font
ws["A1"].font = Font(bold=True)
# 保存
wb.save("scores.xlsx")
# 读取已有文件
wb = load_workbook("scores.xlsx")
ws = wb["成绩表"]
for row in ws.iter_rows(min_row=2, values_only=True):
print(row) # 输出:('张三', 92, 88, 95)
安装:pip install python-docx
from docx import Document
from docx.shared import Pt
# 创建文档
doc = Document()
doc.add_heading("Python基础学习总结", 0)
# 添加段落
doc.add_heading("一、核心知识点", level=1)
doc.add_paragraph("1. 变量与数据类型")
doc.add_paragraph("2. 函数与模块化")
doc.add_paragraph("3. 文件与异常处理")
# 设置字体
from docx.enum.text import WD_ALIGN_PARAGRAPH
paragraph = doc.add_paragraph("总结:Python易学易用,适合快速开发。")
paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
# 保存
doc.save("summary.docx")
import smtplib
from email.mime.text import MIMEText
from email.header import Header
# 邮件内容
msg = MIMEText("Python基础学习完成!\n\n感谢您的关注。", "plain", "utf-8")
msg["From"] = Header("Python学习助手 ")
msg["To"] = Header("用户 ")
msg["Subject"] = Header("Python学习进度通知", "utf-8")
# 发送邮件
try:
server = smtplib.SMTP_SSL("smtp.example.com", 465)
server.login("sender@example.com", "password")
server.sendmail("sender@example.com", ["receiver@example.com"], msg.as_string())
server.quit()
print("邮件发送成功!")
except smtplib.SMTPException as e:
print(f"发送失败:{e}")
示例:批量重命名指定目录下所有.txt文件
import os
def batch_rename(folder):
for i, filename in enumerate(os.listdir(folder)):
if filename.endswith(".txt"):
old_path = os.path.join(folder, filename)
new_name = f"note_{i+1:03d}.txt"
new_path = os.path.join(folder, new_name)
os.rename(old_path, new_path)
print(f"{filename} → {new_name}")
batch_rename("notes")
**Python基础学习**的延伸方向之一是Web开发。Flask以轻量、灵活著称,适合快速构建API与小型网站。
安装:pip install flask
app.py:
from flask import Flask, render_template, request, jsonify
app = Flask(__name__)
@app.route("/")
def index():
return render_template("index.html", title="Python基础学习")
@app.route("/api/data")
def get_data():
return jsonify({
"status": "success",
"data": [{"id": 1, "name": "变量"}, {"id": 2, "name": "函数"}]
})
@app.route("/submit", methods=["POST"])
def submit():
name = request.form.get("name")
score = request.form.get("score")
return f"提交成功!姓名:{name},分数:{score}"
if __name__ == "__main__":
app.run(debug=True)
templates/index.html:
<html>
<head><title>{{ title }}</title></head>
<body>
<h1>欢迎学习Python基础!</h1>
<form method="post" action="/submit">
<input name="name" placeholder="姓名">
<input name="score" placeholder="分数">
<button type="submit">提交</button>
</form>
<div id="data"></div>
<script>
fetch("/api/data")
.then(r => r.json())
.then(d => document.getElementById("data").innerHTML = JSON.stringify(d.data));
</script>
</body>
</html>