Python基础应用

Python基础应用:从零构建编程能力体系

作为一门兼具简洁性与强大功能的编程语言,Python凭借其优雅的语法、丰富的标准库和活跃的社区生态,已成为全球增长最快的编程语言之一。无论是零基础新手还是其他语言开发者,掌握Python基础应用都意味着获得一把打开自动化、数据分析、人工智能等领域大门的钥匙。

本页面系统梳理了Python基础应用的核心知识点,涵盖变量、数据类型、控制结构、函数、模块、文件操作、异常处理、面向对象编程等基础模块,并通过真实场景案例展示其实际应用价值。所有内容均以“能用、好用、实用”为原则,拒绝空洞理论,注重实践指导。

页面采用模块化设计,每个区块聚焦一个核心主题,配合交互式选项卡、时间轴和对比表格,帮助您高效获取所需信息。无论您是为求职考试打基础,还是为项目开发补知识,这里都能提供清晰、完整、可落地的学习路径。

本页面所有代码示例均基于Python 3.10+,确保与主流开发环境兼容,建议在本地安装Python后同步练习,加深理解。

语法基础:构建程序的砖石

变量与数据类型

Python采用动态类型系统,变量无需声明类型,赋值即创建。常见基础类型包括:整数(int)、浮点数(float)、字符串(str)、布尔值(bool)和空值(NoneType)。

  • x = 42:整数赋值,可参与数学运算
  • y = 3.14159:浮点数,注意精度问题(如0.1+0.2≠0.3)
  • name = "Python基础应用":字符串支持单/双/三引号
  • flag = True:布尔值,用于条件判断

运算符与表达式

运算符是构建逻辑的核心组件。基础运算符包括:

类型 示例 结果
算术 7 // 3 2(整除)
比较 "py" in "python" True
逻辑 not (True and False) True
赋值 a += 5 a = a + 5

控制结构

控制结构决定程序执行流程,是逻辑实现的关键:

  • if-elif-else:多分支判断,支持嵌套
  • for循环:遍历可迭代对象(列表、字符串、range等)
  • while循环:条件满足时重复执行
# 打印1到10的奇数
for i in range(1, 11):
    if i % 2 == 1:
        print(i, end=" ")
# 输出:1 3 5 7 9

输入与输出:人机交互的起点

基础输入输出是程序与用户交互的第一步。使用input()获取用户输入(返回字符串),配合print()输出结果:

# 示例:简单计算器(整数加法)
a = input("请输入第一个整数:")
b = input("请输入第二个整数:")
try:
    result = int(a) + int(b)
    print(f"结果:{a} + {b} = {result}")
except ValueError:
    print("输入错误!请输入有效整数。")

注意:直接对输入使用int()转换可能引发异常,需配合异常处理机制,确保程序健壮性。

数据结构:组织信息的骨架

列表(List):动态数组

列表是Python中最常用的数据结构,支持增删改查、切片、排序等操作:

  • 创建:fruits = ["苹果", "香蕉", "橙子"]
  • 追加:fruits.append("葡萄")
  • 插入:fruits.insert(1, "梨")
  • 切片:fruits[1:3] → ["梨", "香蕉"]
  • 排序:sorted([3,1,2]) → [1,2,3]
列表是可变类型,修改操作直接影响原列表;切片操作返回新列表,不影响原数据。

元组(Tuple):不可变序列

元组与列表类似,但元素不可修改,适用于固定数据集(如坐标、配置项):

point = (10, 20)  # 坐标点
config = ("localhost", 8080, "admin")  # 服务器配置
# 解包操作
host, port, user = config
print(f"主机:{host},端口:{port}")

元组可作为字典的键(列表不可),常用于函数返回多值:

def get_stats(nums):
    return min(nums), max(nums), sum(nums)/len(nums)
min_val, max_val, avg = get_stats([1,3,5,7])
print(f"最小值:{min_val},最大值:{max_val},平均值:{avg:.2f}")

字典(Dict):键值对映射

字典是Python的核心数据结构,支持快速查找,适用于配置管理、JSON解析等场景:

user = {
    "name": "张三",
    "age": 28,
    "skills": ["Python", "SQL", "数据分析"]
}
# 访问与修改
user["email"] = "zhangsan@example.com"
print(user.get("skills", []))  # 安全获取,避免KeyError
# 遍历
for key, value in user.items():
    print(f"{key}: {value}")

字典推导式可高效生成新字典:

squares = {x: x**2 for x in range(1, 6)}
# 结果:{1:1, 2:4, 3:9, 4:16, 5:25}

集合(Set):去重与关系运算

集合是无序、不重复元素的组合,支持交集、并集、差集等数学运算:

users_a = {"Alice", "Bob", "Charlie"}
users_b = {"Bob", "David", "Eve"}
# 交集(共同用户)
common = users_a & users_b  # {"Bob"}
# 并集(所有用户)
all_users = users_a | users_b  # {"Alice","Bob","Charlie","David","Eve"}
# 差集(仅A有)
only_a = users_a - users_b  # {"Alice","Charlie"}

常用于数据去重:

items = [1, 2, 2, 3, 3, 3]
unique_items = list(set(items))  # [1,2,3]

列表在自动化办公中的应用

处理Excel数据时,列表常用于存储行记录。以下示例模拟读取订单数据并筛选高价值订单:

orders = [
    {"id": "A001", "amount": 150, "status": "completed"},
    {"id": "A002", "amount": 80, "status": "pending"},
    {"id": "A003", "amount": 320, "status": "completed"}
]
# 筛选已完成且金额>100的订单
high_value_orders = [o for o in orders
                     if o["status"] == "completed" and o["amount"] > 100]
for order in high_value_orders:
    print(f"订单{order['id']}:金额{order['amount']}元")

输出:

A001:金额150元
A003:金额320元

字典在日志分析中的应用

统计HTTP请求状态码分布,字典是理想工具:

status_codes = [200, 404, 200, 500, 200, 403, 404]
counts = {}
for code in status_codes:
    counts[code] = counts.get(code, 0) + 1
# 按出现次数降序排列
sorted_counts = sorted(counts.items(), key=lambda x: x[1], reverse=True)
for code, count in sorted_counts:
    print(f"状态码 {code}:{count} 次")

输出:

状态码 200:3 次
状态码 404:2 次
状态码 500:1 次
状态码 403:1 次

列表+字典:用户行为分析

分析用户点击事件,构建行为路径:

events = [
    {"user": "Alice", "page": "home", "action": "click"},
    {"user": "Bob", "page": "product", "action": "view"},
    {"user": "Alice", "page": "cart", "action": "click"},
    {"user": "Charlie", "page": "home", "action": "scroll"}
]
# 统计各页面点击次数
clicks = {}
for event in events:
    if event["action"] == "click":
        page = event["page"]
        clicks[page] = clicks.get(page, 0) + 1
# 按点击量排序
top_pages = sorted(clicks.items(), key=lambda x: x[1], reverse=True)
print("点击量TOP3页面:")
for page, count in top_pages[:3]:
    print(f"  {page}:{count}次")

输出:

点击量TOP3页面:
  home:1次
  cart:1次
  product:0次

函数模块:代码复用的基石

函数定义与参数传递

Python函数通过def定义,支持位置参数、关键字参数、默认参数和可变参数:

def calculate_bmi(weight, height, unit="metric"):
    """计算BMI指数(默认单位:kg/m)"""
    if unit == "imperial":
        weight = weight * 0.453592  # 磅转kg
        height = height * 0.0254    # 英寸转m
    bmi = weight / (height ** 2)
    return round(bmi, 1)
# 调用示例
print(calculate_bmi(70, 1.75))           # 默认单位
print(calculate_bmi(154, 68, "imperial")) # 英制单位

注意:文档字符串(docstring)是函数的重要组成部分,提升可读性与可维护性。

模块化设计:组织大型项目

将功能拆分为模块,避免代码混乱。例如创建math_utils.py模块:

# math_utils.py
def factorial(n):
    """计算阶乘"""
    if n < 0:
        raise ValueError("阶乘仅对非负整数定义")
    result = 1
    for i in range(2, n+1):
        result *= i
    return result
def gcd(a, b):
    """计算最大公约数(欧几里得算法)"""
    while b:
        a, b = b, a % b
    return a

在主程序中导入使用:

from math_utils import factorial, gcd
print(f"5! = {factorial(5)}")  # 120
print(f"GCD(48, 18) = {gcd(48, 18)}")  # 6

标准库模块(如os、datetime)和第三方库(如requests、pandas)均通过import引入。

参数传递的陷阱与最佳实践

可变参数(如列表、字典)作为默认参数可能导致意外行为:

# 危险示例!
def add_item(item, container=[]):
    container.append(item)
    return container
print(add_item("苹果"))  # ["苹果"]
print(add_item("香蕉"))  # ["苹果", "香蕉"]!

正确做法:使用None作为默认值:

def add_item(item, container=None):
    if container is None:
        container = []
    container.append(item)
    return container
print(add_item("苹果"))  # ["苹果"]
print(add_item("香蕉"))  # ["香蕉"]

此模式确保每次调用独立初始化容器,避免状态污染。

Lambda表达式:简洁的匿名函数

适用于简单逻辑的临时函数,常与map、filter、sorted结合:

numbers = [1, 2, 3, 4, 5]
# 过滤偶数
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4]
# 平方映射
squares = list(map(lambda x: x**2, numbers))
print(squares)  # [1, 4, 9, 16, 25]
# 排序(按绝对值降序)
sorted_nums = sorted(numbers, key=lambda x: abs(x), reverse=True)
print(sorted_nums)  # [5, 4, 3, 2, 1]

注意:复杂逻辑应使用具名函数,保持可读性。

装饰器:增强函数功能

装饰器在不修改原函数的前提下,动态添加功能(如日志、权限校验):

def log_calls(func):
    """记录函数调用信息"""
    def wrapper(*args, **kwargs):
        print(f"[调用] {func.__name__}({args}, {kwargs})")
        result = func(*args, **kwargs)
        print(f"[返回] {result}")
        return result
    return wrapper
@log_calls
def multiply(a, b):
    return a * b
result = multiply(3, 4)
# 输出:
# [调用] multiply((3, 4), {})
# [返回] 12

装饰器广泛用于Web框架(如Flask的@app.route)和API认证中。

面向对象编程:构建可扩展系统

类与对象:从抽象到实例

面向对象编程(OOP)通过封装、继承、多态实现代码复用与解耦。以“用户”类为例:

class User:
    """用户类:管理用户基本信息"""
    def __init__(self, name, email):
        self.name = name
        self.email = email
        self.is_active = True
    def deactivate(self):
        """停用用户"""
        self.is_active = False
    def get_profile(self):
        """返回用户简要信息"""
        status = "活跃" if self.is_active else "已停用"
        return f"{self.name} ({status})"
# 创建实例
user1 = User("李四", "lisi@example.com")
print(user1.get_profile())  # 李四 (活跃)
user1.deactivate()
print(user1.get_profile())  # 李四 (已停用)

注意:双下划线__init__是构造方法;self代表实例自身。

继承与多态:复用与扩展

子类继承父类属性和方法,并可重写(override):

class AdminUser(User):
    """管理员用户:继承User并扩展权限"""
    def __init__(self, name, email, permissions=None):
        super().__init__(name, email)
        self.permissions = permissions or ["read", "write"]
    def grant_permission(self, permission):
        """授予权限"""
        if permission not in self.permissions:
            self.permissions.append(permission)
    def get_profile(self):  # 重写父类方法
        base_profile = super().get_profile()
        return f"【管理员】{base_profile} | 权限:{', '.join(self.permissions)}"
# 实例化并使用
admin = AdminUser("王五", "admin@example.com", ["read", "admin"])
print(admin.get_profile())
# 输出:【管理员】王五 (活跃) | 权限:read, admin

多态性允许用统一接口处理不同对象:

users = [User("赵六", "zhaoliu@example.com"), admin]
for u in users:
    print(u.get_profile())  # 自动调用对应类的get_profile

属性与方法的封装控制

Python通过单下划线(_)和双下划线(__)实现伪私有:

class BankAccount:
    def __init__(self, balance=0):
        self._balance = balance  # 受保护属性(约定俗成)
        self.__account_id = id(self)  # 私有属性(名称改写)
    def deposit(self, amount):
        if amount > 0:
            self._balance += amount
    def get_balance(self):
        return self._balance
# 使用示例
account = BankAccount(100)
account.deposit(50)
print(account.get_balance())  # 150
print(account._balance)       # 可访问但不推荐
# print(account.__account_id) # AttributeError

双下划线触发名称改写(name mangling),增强封装性,但仍可通过_类名__属性名访问。

常用魔术方法:自定义对象行为

魔术方法以双下划线开头结尾,定义对象的内置行为:

方法 用途 示例
__str__ str()调用时返回字符串 print(user) → "User(name='李四')"
__len__ len()调用时返回长度 len(my_list) → 元素个数
__eq__ ==比较时定义相等逻辑 user1 == user2 → 比较属性
__getitem__ 支持索引访问(如obj[key]) book["chapter1"]
class Book:
    def __init__(self, title, chapters):
        self.title = title
        self.chapters = chapters
    def __str__(self):
        return f"《{self.title}》"
    def __len__(self):
        return len(self.chapters)
    def __getitem__(self, index):
        return self.chapters[index]
book = Book("Python基础", ["变量", "函数", "类"])
print(book)        # 《Python基础》
print(len(book))   # 3
print(book[1])     # 函数

文件操作:持久化数据的桥梁

文本文件读写:常用模式详解

Python通过open()函数处理文件,核心参数包括路径、模式和编码:

模式 说明 风险提示
"r" 只读(默认) 文件不存在时抛出FileNotFoundError
"w" 写入(覆盖原内容) 原有数据将被清空
"a" 追加写入 在文件末尾添加内容
"r+" 读写模式 文件必须存在
# 写入用户数据
users = ["张三", "李四", "王五"]
with open("users.txt", "w", encoding="utf-8") as f:
    for user in users:
        f.write(user + "\n")
# 读取并处理
with open("users.txt", "r", encoding="utf-8") as f:
    for line in f:
        name = line.strip()
        print(f"处理用户:{name}")

使用with语句确保文件自动关闭,避免资源泄漏。

JSON文件:结构化数据交换

JSON(JavaScript Object Notation)是轻量级数据交换格式,Python通过json模块处理:

import json
# 写入JSON
data = {
    "version": "1.0",
    "features": ["自动化", "数据分析", "Web开发"]
}
with open("config.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)
# 读取JSON
with open("config.json", "r", encoding="utf-8") as f:
    loaded = json.load(f)
    print(f"版本:{loaded['version']}")
    print(f"功能:{', '.join(loaded['features'])}")

输出:

版本:1.0
功能:自动化, 数据分析, Web开发

CSV文件:表格数据处理

CSV(Comma-Separated Values)是电子表格和数据库的通用格式,用csv模块操作:

import csv
# 写入CSV
with open("products.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["ID", "名称", "价格"])
    writer.writerow(["P001", "Python基础教程", "¥88.00"])
    writer.writerow(["P002", "数据分析实战", "¥128.00"])
# 读取CSV
with open("products.csv", "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"{row['ID']}:{row['名称']} - {row['价格']}")

输出:

P001:Python基础教程 - ¥88.00
P002:数据分析实战 - ¥128.00

文件操作的常见异常与解决方案

异常类型 触发场景 解决方案
FileNotFoundError 读取不存在的文件 try-except捕获,或用os.path.exists()预检查
PermissionError 无写入权限 检查文件权限,或以只读模式打开
UnicodeDecodeError 编码不匹配 指定encoding="utf-8",或用errors="ignore"跳过
def safe_read_file(filepath):
    """安全读取文件"""
    try:
        with open(filepath, "r", encoding="utf-8") as f:
            return f.read()
    except FileNotFoundError:
        print(f"错误:文件 '{filepath}' 不存在")
        return None
    except PermissionError:
        print(f"错误:无权限读取 '{filepath}'")
        return None
    except UnicodeDecodeError:
        print(f"错误:编码问题,请检查文件 '{filepath}' 编码")
        return None
content = safe_read_file("nonexistent.txt")  # 输出:错误:文件 'nonexistent.txt' 不存在

路径操作:跨平台兼容性

使用os.path或pathlib处理路径,避免硬编码分隔符:

from pathlib import Path
# 创建路径
base_dir = Path("projects")
data_dir = base_dir / "data" / "raw"  # 自动处理分隔符
# 检查与创建目录
if not data_dir.exists():
    data_dir.mkdir(parents=True)  # 创建多级目录
# 遍历文件
for file in data_dir.glob("*.csv"):
    print(f"找到文件:{file.name}")

注意:路径操作推荐使用pathlib,其面向对象设计更简洁高效。

异常处理:构建健壮程序

try-except-finally结构

异常处理确保程序在错误发生时仍能优雅降级:

def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        return "错误:除数不能为零"
    except TypeError:
        return "错误:输入必须为数字"
    else:
        # 无异常时执行
        return f"结果:{result:.2f}"
    finally:
        # 总会执行
        print("计算完成")
print(divide(10, 2))   # 计算完成\n结果:5.00
print(divide(10, 0))   # 计算完成\n错误:除数不能为零

注意:else块仅在无异常时执行;finally无论是否异常都会运行,常用于资源清理。

自定义异常:业务逻辑校验

继承Exception创建自定义异常,增强语义化:

class InvalidEmailError(Exception):
    """无效邮箱格式异常"""
    def __init__(self, email):
        self.email = email
        super().__init__(f"无效邮箱:{email}")
def validate_email(email):
    """验证邮箱格式"""
    if "@" not in email or "." not in email.split("@")[-1]:
        raise InvalidEmailError(email)
    return True
try:
    validate_email("test@example.com")  # 正常
    validate_email("invalid-email")     # 抛出异常
except InvalidEmailError as e:
    print(e)  # 无效邮箱:invalid-email

自定义异常使错误处理更精准,便于日志记录和用户提示。

异常链与上下文管理

使用raise ... from ...保留原始异常信息:

def process_data(data):
    try:
        value = int(data)
    except ValueError as e:
        raise ValueError("数据转换失败") from e
try:
    process_data("abc")
except ValueError as e:
    print(e)          # 数据转换失败
    print(e.__cause__) # invalid literal for int() with base 10: 'abc'

上下文管理器(with)自动处理资源释放,是异常安全的关键实践:

def read_config():
    try:
        with open("config.json") as f:
            return json.load(f)
    except FileNotFoundError:
        print("配置文件缺失,使用默认设置")
        return {"timeout": 30, "retries": 3}

结构化日志:定位问题的利器

使用logging模块记录异常信息,便于后期分析:

import logging
# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    handlers=[
        logging.FileHandler("app.log", encoding="utf-8"),
        logging.StreamHandler()
    ]
)
def process_file(filepath):
    try:
        with open(filepath) as f:
            return f.read()
    except Exception as e:
        logging.error("处理文件失败: %s", e, exc_info=True)
        return None
# 调用示例
process_file("missing.txt")
# 输出到日志:
# 2025-04-05 14:30:22 [ERROR] 处理文件失败: [Errno 2] No such file or directory: 'missing.txt'
# Traceback (most recent call last):
#   File "script.py", line 10, in process_file
#     with open(filepath) as f:
# FileNotFoundError: [Errno 2] No such file or directory: 'missing.txt'

注意:exc_info=True会包含完整堆栈信息,是生产环境必备配置。

调试技巧:快速定位异常

常用调试方法:

  • 断言:assert condition, "错误信息"(开发阶段启用)
  • 交互式调试:在代码中插入breakpoint()(Python 3.7+)
  • 日志跟踪:关键路径添加logging.debug()
def calculate_average(numbers):
    assert len(numbers) > 0, "列表不能为空"
    total = sum(numbers)
    avg = total / len(numbers)
    print(f"DEBUG: numbers={numbers}, total={total}, avg={avg}")
    return avg
# 使用断言
try:
    calculate_average([])
except AssertionError as e:
    print(f"断言失败:{e}")

注意:生产环境应移除或禁用breakpoint(),避免安全风险。

实战项目:从理论到应用

项目1:自动化办公脚本——批量重命名文件

场景:整理下载文件夹中命名混乱的PDF报告,统一格式为报告_YYYYMMDD_序号.pdf:

import os
from pathlib import Path
from datetime import datetime
def batch_rename_files(folder_path, prefix="报告"):
    """批量重命名文件"""
    folder = Path(folder_path)
    files = [f for f in folder.iterdir() if f.is_file() and f.suffix == ".pdf"]
    # 按修改时间排序
    files.sort(key=lambda x: x.stat().st_mtime)
    for i, file in enumerate(files, 1):
        # 生成新文件名
        date_str = datetime.fromtimestamp(file.stat().st_mtime).strftime("%Y%m%d")
        new_name = f"{prefix}_{date_str}_{i:03d}{file.suffix}"
        new_path = folder / new_name
        # 重命名
        file.rename(new_path)
        print(f"重命名:{file.name} → {new_name}")
# 使用示例
# batch_rename_files("downloads/reports")

扩展功能:添加日志记录、跳过已重命名文件、支持正则表达式匹配等。

项目2:简易网络爬虫——提取网页标题

使用requests和BeautifulSoup提取新闻列表标题:

import requests
from bs4 import BeautifulSoup
def fetch_news_titles(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()  # 检查HTTP错误
        soup = BeautifulSoup(response.text, "html.parser")
        titles = []
        # 假设标题在h2标签中
        for h2 in soup.find_all("h2"):
            title = h2.get_text(strip=True)
            if title:
                titles.append(title)
        return titles
    except requests.exceptions.RequestException as e:
        print(f"请求失败:{e}")
        return []
# 使用示例
# titles = fetch_news_titles("https://example.com/news")
# for i, title in enumerate(titles[:5], 1):
#     print(f"{i}. {title}")

注意:需遵守网站robots.txt协议,避免高频请求导致IP封禁。

项目3:数据清洗脚本——处理Excel缺失值

用pandas填充缺失数据,支持多种策略:

import pandas as pd
def clean_data(df, strategy="mean"):
    """清洗数据:处理缺失值"""
    # 数值列填充
    numeric_cols = df.select_dtypes(include="number").columns
    if strategy == "mean":
        df[numeric_cols] = df[numeric_cols].fillna(df[numeric_cols].mean())
    elif strategy == "median":
        df[numeric_cols] = df[numeric_cols].fillna(df[numeric_cols].median())
    # 字符串列填充
    string_cols = df.select_dtypes(include="object").columns
    df[string_cols] = df[string_cols].fillna("未知")
    return df
# 示例数据
data = {
    "name": ["张三", "李四", None],
    "score": [85, None, 90],
    "level": ["A", None, "B"]
}
df = pd.DataFrame(data)
# 清洗
cleaned = clean_data(df, strategy="median")
print(cleaned)

输出:

name score level
张三 85.0 A
李四 87.5 未知
未知 90.0 B

扩展:文件管理器增强功能

添加文件类型识别与分类归档:

def organize_files(folder_path):
    """按文件类型归档"""
    folder = Path(folder_path)
    extensions = {
        "image": [".jpg", ".png", ".gif"],
        "document": [".pdf", ".docx", ".txt"],
        "archive": [".zip", ".rar", ".7z"]
    }
    for ext_type, suffixes in extensions.items():
        type_dir = folder / ext_type
        type_dir.mkdir(exist_ok=True)
        for file in folder.iterdir():
            if file.is_file() and file.suffix.lower() in suffixes:
                file.rename(type_dir / file.name)
                print(f"移动:{file.name} → {ext_type}/")
# 使用
# organize_files("downloads")

输出示例:

移动:report.pdf → document/
移动:photo.jpg → image/
移动:archive.zip → archive/

扩展:Excel数据导出

将清洗后的数据导出为Excel:

import pandas as pd
# 假设cleaned为清洗后的DataFrame
cleaned.to_excel(
    "cleaned_data.xlsx",
    index=False,
    sheet_name="清洗后数据",
    engine="openpyxl"
)
# 添加条件格式(需openpyxl)
from openpyxl.styles import Font, PatternFill
wb = openpyxl.load_workbook("cleaned_data.xlsx")
ws = wb["清洗后数据"]
# 高亮空值单元格
for row in ws.iter_rows(min_row=2, max_col=3):
    for cell in row:
        if cell.value is None:
            cell.fill = PatternFill(start_color="FFFF00", fill_type="solid")
wb.save("cleaned_data.xlsx")

注意:需安装openpyxl库:pip install openpyxl

扩展:Flask API服务

提供JSON接口供前端调用:

from flask import Flask, jsonify, request
app = Flask(__name__)
@app.route("/api/analyze", methods=["POST"])
def analyze_text():
    """文本分析API"""
    data = request.get_json()
    text = data.get("text", "")
    # 简单分析:词频统计
    words = text.split()
    word_freq = {}
    for word in words:
        word_freq[word] = word_freq.get(word, 0) + 1
    return jsonify({
        "total_words": len(words),
        "unique_words": len(word_freq),
        "top_words": sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:5]
    })
if __name__ == "__main__":
    app.run(debug=True)

测试请求:

import requests
response = requests.post(
    "http://localhost:5000/api/analyze",
    json={"text": "Python基础应用非常实用,Python适合数据分析"}
)
print(response.json())

输出:

{
  "total_words": 6,
  "unique_words": 4,
  "top_words": [["Python", 2], ["基础", 1], ["应用", 1], ["非常", 1]]
}

常见问题解答(FAQ)

Q1:Python和Python2有什么区别?该学哪个?

Python 2已于2020年停止支持,所有新项目必须使用Python 3。主要区别包括:

  • print:Python 2为语句(print "Hello"),Python 3为函数(print("Hello"))
  • 整数除法:Python 2中5/2=2,Python 3中5/2=2.5
  • Unicode:Python 3默认使用Unicode,解决中文编码问题

结论:新手直接学习Python 3,无需考虑Python 2。

Q2:安装Python后如何验证成功?

打开命令行(Windows:cmd/PowerShell;macOS/Linux:终端),输入:

python --version
# 或
python3 --version

若输出Python 3.x.x则安装成功。进一步验证:

python -c "print('Hello, Python!')"

输出Hello, Python!表示环境配置正确。

Q3:为什么运行脚本时提示“ModuleNotFoundError”?

常见原因及解决方案:

原因 解决方案
未安装模块 用pip install 模块名安装(如pip install requests)
模块名拼写错误 检查import语句中的名称
路径问题 确保脚本与模块在同一目录,或设置PYTHONPATH
虚拟环境隔离 激活对应虚拟环境后再安装/运行

示例:安装requests后仍报错,可能是未在虚拟环境中安装。

Q4:如何高效记忆Python语法?

推荐方法:

  1. 刻意练习:每天写5-10行代码,坚持1个月形成肌肉记忆
  2. 项目驱动:用真实需求(如自动整理下载文件夹)倒逼学习
  3. 查漏补缺:遇到问题再查文档,针对性记忆
  4. 代码复用:保存常用片段(如文件读写、列表推导式)

关键:不必死记硬背,理解原理后查文档是专业开发者的常态。

Q5:Python适合哪些行业?就业前景如何?

根据招聘平台数据,Python相关岗位需求持续增长:

  • 互联网:后端开发(Django/Flask)、自动化测试
  • 金融:量化分析、风险建模(pandas、numpy)
  • 教育:编程教学、课程自动化
  • 科研:数据处理、实验自动化(matplotlib、scipy)

薪资参考(2024年):

经验 平均月薪 典型技能
应届生 ¥6,000-8,000 基础语法、简单自动化脚本
1-3年 ¥10,000-15,000 数据处理、Web开发、项目经验
3-5年 ¥18,000-25,000 系统设计、性能优化、AI集成

结论:掌握Python基础应用是进入高薪技术岗位的高效起点。

环境配置常见问题

Q:Windows安装后命令行无法运行python?

解决方案:

  1. 重新运行安装程序,勾选Add Python to PATH
  2. 手动添加环境变量:
    • 右键“此电脑” → 属性 → 高级系统设置
    • 环境变量 → Path → 新建 → 添加Python安装路径(如C:\Python310\)

Q:如何管理多个Python版本?

使用pyenv(macOS/Linux)或pyenv-win(Windows):

# 安装后
pyenv install 3.9.7
pyenv install 3.11.2
pyenv global 3.9.7

学习资源深度推荐

免费资源:

付费资源:

建议:免费资源入门后,选择1门付费课程深化理解。

职业发展路径详解

技术路线:

  1. 初级工程师:基础语法、自动化脚本、简单Web开发
  2. 中级工程师:数据处理(pandas)、Web框架(Flask/Django)、测试
  3. 高级工程师:系统设计、性能优化、架构选型

转型方向:

  • 数据分析师:补充SQL、统计学、pandas、matplotlib
  • 自动化测试:学习Selenium、Pytest、Jenkins集成
  • DevOps:掌握Ansible、Docker、CI/CD流程

关键建议:25岁前打牢基础,25-30岁确定细分方向,持续学习是核心竞争力。