Python程序设计课程期末总结

岁桉2024-01-032024-01-03

前言

本文属于个人总结，可能有不准的地方，欢迎指正！思维导图使用的mermaid语法，如果无法显示，请复制到支持mermaid输出显示的编辑器预览（比如Typora）。

Python程序设计–课程学习总结

1）-Python环境的安装

下载Python：从Python官方网站下载适合自己操作系统的Python版本。
安装Python：按照提示完成Python的安装过程。
验证Python安装：通过在命令行输入“python –version”来验证Python是否安装成功。（如果未勾选自动配置环境变量：手动将Python的安装路径添加到系统的环境变量中，以便在任何位置都能运行Python。）
安装IDE：选择一个适合自己的Python开发环境，如PyCharm、VS Code等。
使用pip安装库：pip是Python的包管理器，可以用来安装和管理Python库。
使用虚拟环境：为每个项目创建一个独立的虚拟环境，以避免不同项目之间的库冲突。（PyCharm默认虚拟环境）

1.1）-选择合适的IDE

使用PyCharm：PyCharm是一个强大的Python开发工具，提供了代码编辑、调试、测试、版本控制等功能。
使用VS Code：VS Code是一个轻量级的代码编辑器，支持多种编程语言，包括Python。
使用Jupyter Notebook：Jupyter Notebook是一个交互式的开发环境，可以实时查看代码运行结果。

上述仅代表个人了解的IDE，可以根据自己实际需求选择适合自己的IDE。

简单的一个思维导图

graph TD;
    A[下载Python] --> B[安装Python];
    B --> C[验证Python安装];
    C --> D[安装IDE];
    D --> E[使用pip安装库];
    E --> F[使用虚拟环境];

2）-理解Python程序语句

理解 Python 程序语句的主要内容包括以下几个方面：

1.简单条件语句：

使用 if 关键字进行条件判断，根据条件是否为真执行相应的语句块。

x = 10
if x > 0:
    print("x 是正数")  # 如果 x 大于 0，则输出 x 是正数

2.复杂条件语句：

利用 if-elif-else 结构，处理多个条件情况，依次检查条件并执行符合条件的语句块。

score = 85
if score >= 90:
    print("优秀")
elif 80 <= score < 90:
    print("良好")
else:
    print("需要努力")
# 根据分数输出相应的评价，分数大于等于 90 为优秀，80 到 89 为良好，否则需要努力

3.while 循环语句：

使用 while 关键字创建循环，当给定条件为真时，反复执行循环体内的语句。

count = 0
while count < 5:
    print(count)  # 输出当前的 count 值
    count += 1    # 将 count 值增加 1

4.while 循环的退出：

使用 break 语句可以在循环体内提前终止循环，而 continue 语句则跳过当前迭代继续下一次。

num = 1
while num <= 10:
    if num == 5:
        break  # 当 num 等于 5 时，跳出循环
    print(num)
    num += 1

5.for 循环：

利用 for 关键字遍历可迭代对象，如列表、元组等，执行循环体内的语句。

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

6.循环注意事项：

避免无限循环，确保循环条件能在某个时刻变为假。
谨慎使用全局变量，以免影响程序逻辑。

total = 0
for i in range(5):
    total += i  # 将每次循环的值累加到 total 中
print(total)  # 输出累加结果

7.循环的嵌套：

在一个循环体内嵌套另一个循环，可以处理更为复杂的逻辑。

for i in range(3):
    for j in range(2):
        print(i, j)  # 输出循环变量 i 和 j 的值

8.异常处理：

使用 try-except 结构捕获和处理异常，防止程序在出错时崩溃。
可以使用 else 子句指定在没有异常发生时执行的代码块，以及 finally 子句指定无论是否发生异常都要执行的代码块。

try:
    result = 10 / 0
except ZeroDivisionError:
    print("除数不能为零")  # 捕获除数为零的异常
else:
    print("计算结果为:", result)
finally:
    print("无论如何都会执行的代码块")  # 无论是否发生异常，都会执行的代码块

以上是 Python 程序语句的基本内容，它们为编写结构化、可维护的程序提供了强大的工具。

简单的一个思维导图

graph TD
A[理解Python程序语句] --> B[简单条件语句]
A --> C[复杂条件语句]
A --> D[while循环语句]
A --> E[while循环的退出]
A --> F[for循环]
A --> G[循环注意事项]
A --> H[循环的嵌套]
A --> I[异常处理]
B -->|if关键字| J[if条件判断]
C -->|if-elif-else结构| K[if-elif-else条件判断]
D -->|while关键字| L[while循环]
E -->|break语句| M[提前终止循环]
E -->|continue语句| N[跳过当前迭代]
F -->|for关键字| O[遍历可迭代对象]
G -->|全局变量| P[谨慎使用全局变量]
H -->|嵌套循环| Q[处理更复杂的逻辑]
I -->|try-except结构| R[捕获和处理异常]
R -->|else子句| S[没有异常时执行的代码块]
R -->|finally子句| T[无论是否发生异常都要执行的代码块]

3）Python函数与模块

1. Python函数：

函数是一组执行特定任务的代码块，通过使用 def 关键字定义。函数可以接受参数，执行特定操作，并返回结果。

# 定义一个简单的函数，接受两个参数并返回它们的和
def add_numbers(a, b):
    result = a + b
    return result

# 调用函数并输出结果
sum_result = add_numbers(3, 5)
print("和为:", sum_result)

2. Python变量范围：

变量的范围指的是变量在程序中的可访问性。局部变量只能在其被定义的函数内部访问，而全局变量在整个程序中都可访问。

# 全局变量
global_var = 10

# 函数内部定义的局部变量
def example_function():
    local_var = 5
    print("局部变量:", local_var)

# 调用函数
example_function()

# 在函数外部访问全局变量
print("全局变量:", global_var)

3. 函数调用：

通过函数名和参数列表调用函数，传递参数以执行特定的任务。

# 定义一个简单的函数
def greet(name):
    print("你好，" + name + "！")

# 调用函数
greet("小明")

4. 函数的默认参数：

函数可以定义具有默认值的参数，调用时如果不提供相应参数的值，则使用默认值。

# 定义带有默认参数的函数
def greet_with_default(name, greeting="你好"):
    print(greeting + "，" + name + "!")

# 调用函数
greet_with_default("小红")  # 使用默认的问候语
greet_with_default("小明", "早上好")  # 提供自定义的问候语

5. 函数与异常：

在函数中使用异常处理可以有效地处理错误，确保程序不会因为异常而崩溃。

# 定义一个函数，尝试除以零并捕获异常
def divide_numbers(a, b):
    try:
        result = a / b
        print("结果:", result)
    except ZeroDivisionError:
        print("除数不能为零")

# 调用函数
divide_numbers(10, 2)  # 正常情况
divide_numbers(5, 0)   # 引发除零异常

6. Python模块：

模块是包含 Python 代码的文件，可以通过导入模块来使用其中定义的函数和变量。

# 创建一个名为 my_module.py 的模块，包含一个简单的函数
# my_module.py 文件内容：
# def greet(name):
#     print("Hello, " + name + "!")

# 在另一个文件中导入模块并使用函数
import my_module

my_module.greet("Alice")

简单的一个思维导图

graph TD
A[Python函数与模块] --> B[1. Python函数]
A --> C[2. Python变量范围]
A --> D[3. 函数调用]
A --> E[4. 函数的默认参数]
A --> F[5. 函数与异常]
A --> G[6. Python模块]
B --> B1[定义一个简单的函数]
B --> B2[接受两个参数并返回它们的和]
B --> B3[在函数内部定义的局部变量]
B --> B4[在函数外部访问全局变量]
C --> C1[全局变量]
C --> C2[局部变量]
D --> D1[定义一个简单的函数]
D --> D2[调用函数并输出结果]
E --> E1[带有默认参数的函数]
E --> E2[提供自定义的问候语]
F --> F1[尝试除以零并捕获异常]
F --> F2[正常情况]
F --> F3[引发除零异常]
G --> G1[创建一个名为 my_module.py 的模块]
G --> G2[包含一个简单的函数]
G --> G3[在另一个文件中导入模块并使用函数]

4）Python序列数据

1. 字符串类型：

字符串是由字符组成的序列，可以使用单引号或双引号括起来。字符串是不可变的，即不能直接修改其内容。

# 定义一个字符串
my_string = "Hello, World!"

# 输出字符串
print(my_string)

2. 字符串函数：

字符串有许多内建函数可用于处理文本，包括查找子串、切片、转换大小写等。

# 使用字符串函数进行文本处理
text = "Python is powerful!"
substring = "is"

# 查找子串的位置
position = text.find(substring)
print("子串在位置:", position)

# 将字符串转换为大写
uppercase_text = text.upper()
print("大写字符串:", uppercase_text)

3. 列表类型：

列表是一种有序的可变序列，可以包含不同类型的元素。列表使用方括号定义，并可以进行增删改查操作。

# 定义一个列表
my_list = [1, 2, 3, "apple", "banana"]

# 输出列表
print(my_list)

# 列表操作：添加元素
my_list.append("orange")
print("添加元素后的列表:", my_list)

4. 元组类型：

元组是一种有序的不可变序列，用于存储多个元素。元组使用圆括号定义，一旦创建，其内容不可更改。

# 定义一个元组
my_tuple = (1, 2, "apple", "banana")

# 输出元组
print(my_tuple)

5. 字典类型：

字典是一种无序的键值对集合，用于存储和检索数据。字典使用花括号定义，每个键值对用冒号分隔。

# 定义一个字典
my_dict = {"name": "John", "age": 25, "city": "New York"}

# 输出字典
print(my_dict)

# 字典操作：获取值
print("姓名:", my_dict["name"])

6. 字典与函数：

字典可以作为函数的参数和返回值，通过字典传递多个参数或处理多个返回值。

# 定义一个函数，接受字典作为参数
def display_info(person_info):
    print("姓名:", person_info["name"])
    print("年龄:", person_info["age"])
    print("城市:", person_info["city"])

# 调用函数并传递字典
person_data = {"name": "Alice", "age": 30, "city": "London"}
display_info(person_data)

简单的一个思维导图

graph LR
A[Python序列数据] --> B[字符串类型]
A --> C[字符串函数]
A --> D[列表类型]
A --> E[元组类型]
A --> F[字典类型]
A --> G[字典与函数]

5）Python面向对象

1. 类与对象：

在 Python 中，类是一种用于创建对象的蓝图，而对象是类的实例。类定义了对象的属性和方法。

# 定义一个简单的类
class Dog:
    # 类属性
    species = "Canine"

    # 类方法
    def bark(self):
        print("Woof!")

# 创建类的实例（对象）
my_dog = Dog()

# 访问类属性和调用类方法
print("狗的种类:", my_dog.species)
my_dog.bark()

2. 类的方法：

类的方法是在类中定义的函数，用于执行特定的操作。方法的第一个参数通常是 self，表示对象本身。

# 定义一个类，包含方法
class Calculator:
    # 初始化方法
    def __init__(self, value=0):
        self.result = value

    # 加法方法
    def add(self, x):
        self.result += x

    # 减法方法
    def subtract(self, x):
        self.result -= x

# 创建计算器对象并使用方法
my_calculator = Calculator()
my_calculator.add(5)
my_calculator.subtract(3)
print("计算结果:", my_calculator.result)

3. 对象初始化：

对象初始化是通过特殊的 __init__ 方法来进行的，该方法在对象创建时自动调用，用于设置对象的初始状态。

# 定义一个带有初始化方法的类
class Person:
    # 初始化方法
    def __init__(self, name, age):
        self.name = name
        self.age = age

# 创建对象时传递参数进行初始化
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

# 访问对象的属性
print("姓名:", person1.name, "年龄:", person1.age)
print("姓名:", person2.name, "年龄:", person2.age)

4. 类的继承：

继承是面向对象编程的重要概念，允许一个类继承另一个类的属性和方法。子类可以重写或扩展父类的方法。

# 定义一个父类
class Animal:
    def speak(self):
        print("动物发出声音")

# 定义一个子类，继承父类
class Dog(Animal):
    # 重写父类方法
    def speak(self):
        print("狗叫：汪汪汪")

# 创建子类的对象并调用方法
my_dog = Dog()
my_dog.speak()

简单的一个思维导图

graph TD
A[Python面向对象] --> B[类与对象]
A --> C[类的方法]
A --> D[对象初始化]
A --> E[类的继承]
B --> F[定义类]
B --> G[创建对象]
C --> H[定义方法]
C --> I[调用方法]
D --> J[初始化方法]
E --> K[定义父类]
E --> L[定义子类]
E --> M[继承关系]
E --> N[重写或扩展方法]

6）Python文件操作

1. 写文本文件：

在 Python 中，使用内建的 open() 函数以及文件对象的 write() 方法可以方便地写入文本文件。

# 打开文件以写入模式
with open("example.txt", "w") as file:
    # 写入文本内容
    file.write("Hello, this is a text file.\n")
    file.write("Writing some more text.")
    
# with 语句块内的文件写入和读取操作完成后，文件会自动关闭。这样做更加安全，因为它确保在任何情况下都会关闭文件，即使发生异常。

2. 读文本文件：

通过 open() 函数以及文件对象的 read() 或 readline() 方法，可以读取文本文件中的内容。

# 打开文件以读取模式
with open("example.txt", "r") as file:
    # 读取整个文件内容
    content = file.read()
    print("文件内容:\n", content)

    # 逐行读取文件内容
    file.seek(0)  # 将文件指针重置到文件开头
    lines = file.readlines()
    print("逐行读取:\n", lines)

3. 文件编码：

在打开文件时，可以指定文件的编码格式，以确保正确地处理文本文件中的字符集。

# 打开文件时指定编码格式
with open("example.txt", "r", encoding="utf-8") as file:
    content = file.read()
    print("文件内容:\n", content)

4. 文件指针：

文件指针是一个标记，指示文件中当前读取或写入位置的位置。在 Python 中，可以使用 seek() 方法来移动文件指针的位置。

# 打开文件以读取模式
with open("example.txt", "r") as file:
    # 读取整个文件内容
    content = file.read()
    print("文件内容:\n", content)

    # 逐行读取文件内容
    file.seek(0)  # 将文件指针重置到文件开头
    lines = file.readlines()
    print("逐行读取:\n", lines)

    # 使用文件指针进行定位
    file.seek(20)  # 将文件指针定位到第20个字符处
    partial_content = file.read(10)  # 读取接下来的10个字符
    print("部分内容:\n", partial_content)

简单的一个思维导图

graph TD
A[Python文件操作] --> B[写文本文件]
A --> C[读文本文件]
A --> D[文件编码]
A --> E[文件指针]