零基础学 Python——完结回顾

亲爱的亦菲彦祖们，

恭喜你们！经过一段时间的学习和实践，您已经成功完成了Python零基础的入门课程。一路走来，我们从Python的基础语法、数据容器、函数、文件操作，到面向对象编程的核心概念，再到模块与包的使用、异常处理和断点调试，全面覆盖了Python编程的基础知识。希望这些内容能够帮助您打下坚实的编程基础，为未来更深入的学习和开发打下良好的基础。

学习回顾

1. Python基础语法

我们从最基础的Python语法开始，了解了变量、数据类型、运算符、控制流（条件语句和循环）、输入输出等核心概念。通过这些内容，您已经掌握了编写简单Python程序的能力。

示例：

# 简单的Hello World程序
print("Hello, Python!")

---

2. 数据容器

数据容器是存储和组织数据的基本结构。Python提供了多种内置的数据容器，包括列表、元组、字典和集合。

2.1 列表（List）

定义：列表是有序的、可变的、可重复的数据集合。

示例：

# 创建列表
fruits = ['苹果', '香蕉', '樱桃']
print(fruits)  # 输出：['苹果', '香蕉', '樱桃']

# 添加元素
fruits.append('橘子')
print(fruits)  # 输出：['苹果', '香蕉', '樱桃', '橘子']

# 访问元素
print(fruits[1])  # 输出：香蕉

# 修改元素
fruits[0] = '梨'
print(fruits)  # 输出：['梨', '香蕉', '樱桃', '橘子']

2.2 元组（Tuple）

定义：元组是有序的、不可变的、可重复的数据集合。

示例：

# 创建元组
coordinates = (10, 20)
print(coordinates)  # 输出：(10, 20)

# 访问元素
print(coordinates[0])  # 输出：10

# 尝试修改元素（将引发错误）
# coordinates[0] = 15  # TypeError: 'tuple' object does not support item assignment

2.3 字典（Dictionary）

定义：字典是无序的、可变的、键值对的数据集合。

示例：

# 创建字典
student = {
    'name': '张三',
    'age': 20,
    'math': 85,
    'english': 90
}
print(student)  # 输出：{'name': '张三', 'age': 20, 'math': 85, 'english': 90}

# 访问值
print(student['name'])  # 输出：张三

# 添加或修改键值对
student['physics'] = 95
print(student)  # 输出：{'name': '张三', 'age': 20, 'math': 85, 'english': 90, 'physics': 95}

# 删除键值对
del student['age']
print(student)  # 输出：{'name': '张三', 'math': 85, 'english': 90, 'physics': 95}

2.4 集合（Set）

定义：集合是无序的、不重复的数据集合，主要用于成员关系测试和消除重复元素。

示例：

# 创建集合
unique_numbers = {1, 2, 3, 2, 1}
print(unique_numbers)  # 输出：{1, 2, 3}

# 添加元素
unique_numbers.add(4)
print(unique_numbers)  # 输出：{1, 2, 3, 4}

# 进行集合操作
evens = {2, 4, 6}
print(unique_numbers & evens)  # 输出：{2, 4}（交集）
print(unique_numbers | evens)  # 输出：{1, 2, 3, 4, 6}（并集）

---

3. 函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数提高了代码的模块性和代码的重复利用率。

定义函数：

def greet(name):
    """向指定的人打招呼"""
    print(f"你好，{name}！")
    
greet("李四")  # 输出：你好，李四！

带返回值的函数：

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

result = add(5, 7)
print(result)  # 输出：12

默认参数：

def greet(name, msg="你好"):
    print(f"{msg}，{name}！")
    
greet("王五")           # 输出：你好，王五！
greet("王五", "早上好")  # 输出：早上好，王五！

---

4. 文件操作

文件操作允许程序读取、写入和修改文件中的数据。Python提供了内置的open函数来处理文件。

读取文件：

try:
    with open('example.txt', 'r', encoding='utf-8') as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print("文件不存在。")

写入文件：

with open('example.txt', 'w', encoding='utf-8') as file:
    file.write("这是一个示例文本。\n欢迎学习Python！")

逐行读取：

with open('example.txt', 'r', encoding='utf-8') as file:
    for line in file:
        print(line.strip())

追加内容：

with open('example.txt', 'a', encoding='utf-8') as file:
    file.write("\n追加一行文本。")

---

5. 面向对象编程

面向对象编程（OOP）是一种编程范式，它使用“对象”来设计应用和计算机程序。OOP的核心概念包括类（Class）和对象（Object），以及封装、继承和多态等特性。

定义类和创建对象：

class Person:
    """一个简单的人类模型"""
    
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def greet(self):
        print(f"你好，我叫{self.name}，今年{self.age}岁。")
        
# 创建对象
person1 = Person("张三", 25)
person1.greet()  # 输出：你好，我叫张三，今年25岁。

继承：

class Student(Person):
    """学生类，继承自Person"""
    
    def __init__(self, name, age, student_id):
        super().__init__(name, age)
        self.student_id = student_id
    
    def study(self):
        print(f"{self.name}正在学习。")
        
# 创建学生对象
student1 = Student("李四", 20, "S12345")
student1.greet()  # 输出：你好，我叫李四，今年20岁。
student1.study()  # 输出：李四正在学习。

多态：

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("汪汪！")

class Cat(Animal):
    def speak(self):
        print("喵喵！")

def make_animal_speak(animal):
    animal.speak()

dog = Dog()
cat = Cat()

make_animal_speak(dog)  # 输出：汪汪！
make_animal_speak(cat)  # 输出：喵喵！

---

6. 模块与包

模块和包是组织和复用代码的重要工具。

6.1 模块

定义：模块是一个包含Python定义和语句的文件，文件名以.py结尾。模块可以定义函数、类和变量，也可以包含可执行的代码。

创建模块：

# my_module.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

导入模块：

import my_module

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

6.2 包

定义：包是一个包含多个相关模块的文件夹，通过在文件夹中添加__init__.py文件来标识。

创建包：

mypackage/
├── __init__.py
├── module1.py
└── module2.py

使用包中的模块：

from mypackage import module1
from mypackage.module2 import function2

module1.function1()
function2()

示例：

# mypackage/module1.py

def function1():
    print("这是模块1中的函数。")

# mypackage/module2.py

def function2():
    print("这是模块2中的函数。")

# main.py

from mypackage import module1
from mypackage.module2 import function2

module1.function1()  # 输出：这是模块1中的函数。
function2()          # 输出：这是模块2中的函数。

---

7. 异常处理

异常处理是编写健壮程序的重要手段，它允许程序在遇到错误时进行适当的响应，而不是崩溃。

基本结构：

try:
    # 可能发生错误的代码
except ExceptionType:
    # 处理特定异常
except AnotherExceptionType as e:
    # 处理另一个异常，并获取异常信息
else:
    # 如果没有异常发生，执行的代码
finally:
    # 无论是否发生异常，都执行的代码

示例：

try:
    num = int(input("请输入一个整数："))
    result = 10 / num
except ZeroDivisionError:
    print("错误：除以零。")
except ValueError:
    print("错误：输入不是有效的整数。")
else:
    print(f"结果是：{result}")
finally:
    print("程序结束。")

自定义异常：

class PasswordTooShortError(Exception):
    """密码长度不足异常类"""
    def __init__(self, length, message="密码长度不足。"):
        self.length = length
        self.message = message
        super().__init__(self.message)

    def __str__(self):
        return f"{self.message} 当前长度：{self.length}。"

def set_password(password):
    if len(password) < 3:
        raise PasswordTooShortError(len(password))
    print("密码设置成功。")

def main():
    try:
        pwd = input("请输入密码：")
        set_password(pwd)
    except PasswordTooShortError as e:
        print(e)
    except Exception as e:
        print(f"其他错误：{e}")
    else:
        print("没有异常，程序正常运行。")

if __name__ == "__main__":
        main()

---

8. 断点调试

断点调试是定位和解决代码问题的强大工具。通过设置断点，您可以暂停程序执行，逐步查看变量值和程序流程，从而发现并修正错误。

使用PyCharm进行断点调试：

1. 设置断点：

   • 在代码行号旁的灰色边栏（gutter）单击，断点将以红色圆点显示。

2. 启动调试：

   • 点击导航栏上的“Run”菜单，选择“Debug”，或使用快捷键（通常是Shift + F9）。

3. 单步执行：

   • Step Over (F8)：执行当前行，并跳到下一行。
   • Step Into (F7)：进入函数内部，逐步执行函数中的代码。
   • Step Out (Shift + F8)：跳出当前函数，返回到调用该函数的位置。
   • Resume Program (F9)：继续执行程序，直到下一个断点或程序结束。

4. 监视变量：

   • 在“Watches”面板中添加要监视的变量名，实时查看其值。

5. 计算表达式：

   • 使用“Evaluate Expression”功能，手动输入并计算任意表达式，以验证其结果或检查变量间的关系。

示例：

# example.py

def multiply(a, b):
    return a * b

def main():
    x = 5
    y = 0
    try:
        result = multiply(x, y)
        print(f"结果是：{result}")
    except ZeroDivisionError:
        print("错误：除以零。")
    finally:
        print("程序结束。")

if __name__ == "__main__":
    main()

在调试过程中，您可以设置断点在result = multiply(x, y)这一行，逐步执行，观察变量x、y和result的变化。

---

学习成果展示

1. 学生信息管理系统分析与实现

为了检验和巩固所学知识，我们设计并实现了一个学生信息管理系统。通过这个项目，您不仅复习了面向对象编程、模块与包、异常处理和调试技巧，还体验了将理论应用到实际项目中的过程。

项目功能包括：

• 添加学生信息：录入学生的姓名、语文成绩、数学成绩、英语成绩，并计算总分。
• 删除学生信息：根据姓名删除学生记录。
• 修改学生信息：根据姓名修改学生的成绩或姓名。
• 查询学生信息：根据姓名查询学生信息。
• 显示所有学生信息：展示所有学生的详细信息。
• 数据持久化：将学生信息保存到students.json文件，实现数据的持久化。

项目结构：

student_management/
├── __init__.py
├── student.py
└── manager.py

模块内容：

# student.py

class Student:
    """学生信息类"""
    def __init__(self, name, chinese, math, english):
        """
        初始化方法
        :param name: 姓名
        :param chinese: 语文成绩
        :param math: 数学成绩
        :param english: 英语成绩
        """
        self.name = name
        self.chinese = chinese
        self.math = math
        self.english = english
        self.total = chinese + math + english  # 总分

    def __str__(self):
        return f"{self.name}\t{self.chinese}\t{self.math}\t{self.english}\t{self.total}"

# manager.py

import json
from .student import Student

class StudentManager:
    """学生信息管理系统类"""
    def __init__(self):
        # 存储学员数据 -- 列表
        self.student_list = []

    # 程序入口函数
    def run(self):
        # 加载文件里面的学员数据
        self.load_student()

        while True:
            # 显示功能菜单
            self.show_menu()
            # 用户输入目标功能序号
            action = input('请选择您想要进行的操作（0-退出）：')

            # 根据用户输入的序号执行不同的功能
            if action == '1':
                # 新建学生信息
                self.add_student()
            elif action == '2':
                # 显示全部信息
                self.show_student()
            elif action == '3':
                # 查询学生信息
                self.search_student()
            elif action == '4':
                # 删除学生信息
                self.del_student()
            elif action == '5':
                # 修改学生信息
                self.modify_student()
            elif action == '0':
                # 退出系统
                self.save_student()
                print('欢迎再次使用【学生信息管理系统】！再见！')
                break
            else:
                print('输入错误，请重新选择！')

    # 显示功能菜单
    @staticmethod
    def show_menu():
        str_info = """**************************************************
欢迎使用【学生信息管理系统】V1.0
请选择你想要进行的操作
1. 新建学生信息
2. 显示全部信息
3. 查询学生信息
4. 删除学生信息
5. 修改学生信息

0. 退出系统
**************************************************"""
        print(str_info)

    # 添加学生信息
    def add_student(self):
        print('---------- 新建学生信息 ----------')
        name = input('请输入姓名：').strip()
        if not name:
            print('姓名不能为空！')
            return
        try:
            chinese = int(input('请输入语文成绩：'))
            math = int(input('请输入数学成绩：'))
            english = int(input('请输入英语成绩：'))
        except ValueError:
            print('成绩必须是整数！')
            return

        # 检查是否已有该学生
        if any(stu.name == name for stu in self.student_list):
            print(f'学生{name}已存在，无法重复添加！')
            return

        # 创建学生对象并添加到列表
        student = Student(name, chinese, math, english)
        self.student_list.append(student)
        print(f'成功添加学生：{student.name}')

    # 显示全部学生信息
    def show_student(self):
        print('---------- 显示全部学生信息 ----------')
        if not self.student_list:
            print('当前没有学生信息。')
            return
        print('姓名\t语文\t数学\t英语\t总分')
        print('-' * 30)
        for stu in self.student_list:
            print(stu)

    # 查询学生信息
    def search_student(self):
        print('---------- 查询学生信息 ----------')
        search_name = input('请输入要查询的学生姓名：').strip()
        if not search_name:
            print('姓名不能为空！')
            return
        for stu in self.student_list:
            if stu.name == search_name:
                print('姓名\t语文\t数学\t英语\t总分')
                print('-' * 30)
                print(stu)
                return
        print(f'未找到名为"{search_name}"的学生。')

    # 删除学生信息
    def del_student(self):
        print('---------- 删除学生信息 ----------')
        del_name = input('请输入要删除的学生姓名：').strip()
        if not del_name:
            print('姓名不能为空！')
            return
        for stu in self.student_list:
            if stu.name == del_name:
                confirm = input(f'确定要删除学生"{del_name}"吗？（y/n）：').strip().lower()
                if confirm == 'y':
                    self.student_list.remove(stu)
                    print(f'成功删除学生：{del_name}')
                else:
                    print('删除操作已取消。')
                return
        print(f'未找到名为"{del_name}"的学生。')

    # 修改学生信息
    def modify_student(self):
        print('---------- 修改学生信息 ----------')
        modify_name = input('请输入要修改的学生姓名：').strip()
        if not modify_name:
            print('姓名不能为空！')
            return
        for stu in self.student_list:
            if stu.name == modify_name:
                print('请输入新的信息（留空表示不修改）：')
                new_name = input(f'姓名（当前：{stu.name}）：').strip()
                new_chinese = input(f'语文成绩（当前：{stu.chinese}）：').strip()
                new_math = input(f'数学成绩（当前：{stu.math}）：').strip()
                new_english = input(f'英语成绩（当前：{stu.english}）：').strip()

                if new_name:
                    # 检查新姓名是否已存在
                    if any(s.name == new_name for s in self.student_list):
                        print(f'姓名"{new_name}"已存在，无法修改！')
                        return
                    stu.name = new_name
                if new_chinese:
                    try:
                        stu.chinese = int(new_chinese)
                    except ValueError:
                        print('语文成绩必须是整数，修改失败！')
                        return
                if new_math:
                    try:
                        stu.math = int(new_math)
                    except ValueError:
                        print('数学成绩必须是整数，修改失败！')
                        return
                if new_english:
                    try:
                        stu.english = int(new_english)
                    except ValueError:
                        print('英语成绩必须是整数，修改失败！')
                        return
                # 重新计算总分
                stu.total = stu.chinese + stu.math + stu.english
                print(f'学生"{stu.name}"的信息已更新。')
                return
        print(f'未找到名为"{modify_name}"的学生。')

    # 保存学生信息
    def save_student(self):
        print('---------- 保存学生信息 ----------')
        try:
            with open('students.json', 'w', encoding='utf-8') as f:
                # 将学生对象转换为字典列表
                final_stu_list = [{
                    "name": stu.name,
                    "chinese": stu.chinese,
                    "math": stu.math,
                    "english": stu.english,
                    "total": stu.total
                } for stu in self.student_list]
                # 写入JSON文件
                json.dump(final_stu_list, f, ensure_ascii=False, indent=4)
            print('学生信息已保存到"students.json"。')
        except Exception as e:
            print(f'保存失败：{e}')

运行项目：

# main.py

from student_management.manager import StudentManager

if __name__ == "__main__":
    manager = StudentManager()
    manager.run()

通过这个项目，您不仅复习了Python的基础知识，还学会了如何组织和管理代码，处理异常，以及进行调试，确保程序的稳定性和可靠性。

---

未来学习计划：迈向爬虫世界

学习永无止境，编程之路更是如此。接下来，我们将进入一个全新的领域——Python爬虫。爬虫技术在数据采集、自动化任务和信息检索等方面有着广泛的应用。通过学习爬虫，您将能够：

• 理解HTTP协议：掌握网络通信的基础，了解请求和响应的工作机制。
• 使用第三方库：学习如何使用requests库进行网络请求，使用BeautifulSoup和lxml进行网页解析，使用Scrapy框架构建复杂的爬虫项目。
• 数据存储与处理：将爬取的数据存储到数据库或文件中，进行数据清洗和分析。
• 应对反爬机制：学习如何绕过网站的反爬虫措施，提升爬虫的稳定性和效率。

下一个学习模块将涵盖：

1. 网络基础：HTTP协议、URL结构、请求方法等。
2. 使用requests进行网络请求。
3. 解析网页内容：使用BeautifulSoup和lxml。
4. 构建高效爬虫：使用Scrapy框架。
5. 数据存储：将爬取的数据保存到CSV、JSON或数据库中。
6. 应对反爬策略：处理验证码、IP封禁、动态网页等。

我们将通过详细的教程和实战项目，带领您一步步掌握Python爬虫技术，开启数据采集的新篇章。

---

结束语

亲爱的亦菲彦祖们，恭喜您完成了Python零基础的学习！您的努力和坚持值得赞赏。掌握编程不仅是为了应对当前的学习任务，更是为了在未来的职业生涯中拥有更多的可能性和选择。

记住：

• 持续学习：编程世界日新月异，保持学习的热情，不断探索新的技术和工具。
• 多动手实践：通过项目实践巩固所学知识，提升实际开发能力。
• 积极思考：遇到问题时，勇于思考和尝试，培养解决问题的能力。
• 交流合作：与其他编程爱好者交流心得，参与开源项目，共同进步。

在未来的学习中，我们将继续陪伴您，提供丰富的学习资源和实用的编程技巧。期待在Python爬虫的学习旅程中，与您一起探索更广阔的编程世界！

祝学习愉快，编程顺利！

期待在下一个学习模块中，与您一起探索Python爬虫的精彩世界！