首页 Python学习笔记

# 前言

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

# Python 程序设计 -- 课程学习总结

# 1）-Python 环境的安装

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

# 1.1）- 选择合适的 IDE

  1. 使用 PyCharm：PyCharm 是一个强大的 Python 开发工具，提供了代码编辑、调试、测试、版本控制等功能。
  2. 使用 VS Code：VS Code 是一个轻量级的代码编辑器，支持多种编程语言，包括 Python。
  3. 使用 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[文件指针]
 更新于 
请我喝[茶]~(￣▽￣)~*
叶玖洛-星尘 微信支付
微信支付
叶玖洛-星尘 支付宝
支付宝
叶玖洛-星尘 QQ
QQ