爆肝2w字👏🏻👏🏻👏🏻
还愁要自己总结知识点？有这一篇就足够👌🏻
干货满满不看后悔👍👍👍
📝个人主页→数据挖掘博主ZTLJQ的主页
个人推荐python学习系列：
☄️爬虫JS逆向系列专栏 – 爬虫逆向教学
☄️python系列专栏 – 从零开始学python
目录
数据类型和变量
👑1、数字类型（int）
1.浮点数类型（float）
2.复数类型（complex）
3.字符串类型（str）
4.浮点数类型（float）
👑2、字符串类型及其操作
1、字符串的创建和基本操作
2、字符串的切片操作
3、字符串的常用方法
4、格式化字符串
👑3、列表、元组和字典的使用
1、列表(List)的使用
2、元组(Tuple)的使用
3、字典(Dictionary)的使用
👑4、变量的定义和命名规范
1、变量的定义
2、变量的命名规范
3、变量的使用注意事项
条件和循环语句
👑1、if语句及其嵌套
1、if语句的基本使用
2、if-else语句的使用
3、if-elif-else语句的使用
4、if语句的嵌套使用
👑2、for循环和while循环
1、for循环的使用
2、遍历字符串
3、遍历字典
4、while循环
5、用户输入循环
6、条件控制循环
👑3、break和continue语句的使用
1、break语句
2、跳出循环
3、结合条件判断
4、continue语句
5、结合条件判断
函数和模块
👑1、函数的定义和调用
1、函数的定义
2、无参数函数
3、带参数函数
4、返回值函数
5、函数的调用
6、调用带参数函数
7、使用返回值
👑2、函数参数和返回值
1、位置参数
2、默认参数
3、可变长参数：
4、返回值的多样化应用
👑3、模块的导入和使用
1、导入标准库模
2、导入第三方模块
3、自定义模块的导入和使用
4、使用别名导入模块
文件操作
👑1、打开、读取和写入文件
1、文件的打开
2、文件的读取
3、文件的写入
4、使用上下文管理器
👑2、文件指针和文件的关闭
1、文件指针的定位
2、文件指针的移动
3、文件的自动关闭
👑3、异常处理和文件操作的错误处理
1、异常的捕获与处理
2、文件操作错误处理
3、异常处理与文件操作的结合
4、自定义异常
面向对象编程
👑1、类和对象的概念
1、类的定义与实例化
2、对象属性与方法的访问
3、错误处理与类的结合
👑2、属性和方法的定义
1、属性的定义与访问
2、方法的定义与调用：
3、错误处理与属性方法的结合
👑3、继承和多态的实现
1、类的继承与重写
2、多态的实现
3、继承和多态的应用场景
数据类型和变量
👑1、数字类型（int）
整数类型表示整数，可以进行基本的数学运算
代码案例：
# 整数类型定义和操作
num1 = 10
num2 = 5
print(num1 + num2) # 输出：15
print(num1 - num2) # 输出：5
print(num1 * num2) # 输出：50
print(num1 / num2) # 输出：2.0（注意：整数相除得到的是浮点数）
print(num1 // num2) # 输出：2（地板除法，得到整数结果）
print(num1 % num2) # 输出：0（取余数）
print(num1 ** num2) # 输出：100000（幂运算）
1.浮点数类型（float）
浮点数类型表示带有小数部分的数，支持浮点数运算。
代码案例：
# 浮点数类型定义和操作
num1 = 3.14
num2 = 2.7
print(num1 + num2) # 输出：5.84
print(num1 - num2) # 输出：0.44
print(num1 * num2) # 输出：8.478
print(num1 / num2) # 输出：1.162962962962963
print(num1 ** num2) # 输出：13.815511826682914（幂运算）
2.复数类型（complex）
复数类型表示实部和虚部组成的复数，可以进行复数运算。
代码案例：
# 复数类型定义和操作
num1 = 2 + 3j
num2 = 4 + 2j
print(num1 + num2) # 输出：(6+5j)
print(num1 - num2) # 输出：(-2+1j)
print(num1 * num2) # 输出：(8+14j)
print(num1 / num2) # 输出：(0.7+0.4j)
print(num1.real) # 输出：2.0（获取实部）
print(num1.imag) # 输出：3.0（获取虚部）
print(num1.conjugate()) # 输出：(2-3j)（求共轭复数）
3.字符串类型（str）
字符串类型表示文本数据，由字符组成，可以进行字符串操作和处理。
# 整数类型定义和操作
num1 = 10
num2 = 5
print(num1 + num2) # 输出：15
print(num1 - num2) # 输出：5
print(num1 * num2) # 输出：50
print(num1 / num2) # 输出：2.0（注意：整数相除得到的是浮点数）
print(num1 // num2) # 输出：2（地板除法，得到整数结果）
print(num1 % num2) # 输出：0（取余数）
print(num1 ** num2) # 输出：100000（幂运算）
4.浮点数类型（float）
浮点数类型表示带有小数部分的数，支持浮点数运算。
# 浮点数类型定义和操作
num1 = 3.14
num2 = 2.7
print(num1 + num2) # 输出：5.84
print(num1 - num2) # 输出：0.44
print(num1 * num2) # 输出：8.478
print(num1 / num2) # 输出：1.162962962962963
print(num1 ** num2) # 输出：13.815511826682914（幂运算）
👑2、字符串类型及其操作
1、字符串的创建和基本操作
可以使用单引号或双引号创建字符串。下面是一些基本的字符串操作示例：
# 创建字符串
str1 = 'Hello, World!'
str2 = "Python Programming"
# 访问字符串中的字符
print(str1[0]) # 输出：H
print(str2[7]) # 输出：P
# 字符串长度
print(len(str1)) # 输出：13
print(len(str2)) # 输出：18
# 字符串拼接
str3 = str1 + " " + str2
print(str3) # 输出：Hello, World! Python Programming
# 字符串重复
str4 = str1 * 3
print(str4) # 输出：Hello, World!Hello, World!Hello, World!
2、字符串的切片操作
切片是指从字符串中获取部分字符子串的操作。通过指定起始位置和结束位置的索引，可以截取需要的子串。
str5 = "Python Programming"
# 切片操作
print(str5[0:6]) # 输出：Python
print(str5[7:]) # 输出：Programming
print(str5[:6]) # 输出：Python
print(str5[-11:-1]) # 输出：Programmin
# 步长切片
print(str5[0:10:2]) # 输出：Pto rg
3、字符串的常用方法
Python提供了许多有用的字符串方法，用于处理字符串。以下是一些常用的方法示例：
str6 = " Hello, World! "
# 去除字符串两端的空格
print(str6.strip()) # 输出：Hello, World!
# 大小写转换
print(str6.lower()) # 输出： hello, world!
print(str6.upper()) # 输出： HELLO, WORLD!
# 查找子串的位置
print(str6.find("World")) # 输出：9
print(str6.find("Python")) # 输出：-1
# 替换子串
print(str6.replace("World", "Python")) # 输出： Hello, Python!
# 字符串分割
print(str6.split(",")) # 输出：[' Hello', ' World! ']
4、格式化字符串
Python提供了多种字符串格式化的方法，用于将变量的值插入到字符串中。
name = "Alice"
age = 20
# 使用占位符
print("My name is %s and I am %d years old." % (name, age))
# 使用f-string
print(f"My name is {name} and I am {age} years old.")
👑3、列表、元组和字典的使用
1、列表(List)的使用
列表是一个有序的可变数据类型，可以存储多个元素，并且允许元素重复。下面是一些基本的列表操作示例：
# 创建列表
list1 = [1, 2, 3, 4, 5]
list2 = ['apple', 'banana', 'orange']
# 访问列表中的元素
print(list1[0]) # 输出：1
print(list2[2]) # 输出：orange
# 列表长度
print(len(list1)) # 输出：5
print(len(list2)) # 输出：3
# 列表的切片操作
print(list1[1:4]) # 输出：[2, 3, 4]
print(list2[:2]) # 输出：['apple', 'banana']
# 列表的修改和添加
list1[0] = 10
list2.append('grape')
print(list1) # 输出：[10, 2, 3, 4, 5]
print(list2) # 输出：['apple', 'banana', 'orange', 'grape']
# 列表的删除
del list1[2]
list2.remove('banana')
print(list1) # 输出：[10, 2, 4, 5]
print(list2) # 输出：['apple', 'orange', 'grape']
2、元组(Tuple)的使用
元组是一个有序的不可变数据类型，类似于列表，但元组的元素不能修改。下面是一些基本的元组操作示例：
# 创建元组
tuple1 = (1, 2, 3, 4, 5)
tuple2 = ('apple', 'banana', 'orange')
# 访问元组中的元素
print(tuple1[0]) # 输出：1
print(tuple2[2]) # 输出：orange
# 元组长度
print(len(tuple1)) # 输出：5
print(len(tuple2)) # 输出：3
# 元组的切片操作
print(tuple1[1:4]) # 输出：(2, 3, 4)
print(tuple2[:2]) # 输出：('apple', 'banana')
# 元组的拼接
tuple3 = tuple1 + tuple2
print(tuple3) # 输出：(1, 2, 3, 4, 5, 'apple', 'banana', 'orange')
3、字典(Dictionary)的使用
字典是一个无序的可变数据类型，由键-值对(key-value)组成，用于存储和查找数据。下面是一些基本的字典操作示例：
# 创建字典
dict1 = {'name': 'Alice', 'age': 20, 'country': 'USA'}
dict2 = {'apple': 1.0, 'banana': 0.5, 'orange': 0.8}
# 访问字典中的元素
print(dict1['name']) # 输出：Alice
print(dict2['apple']) # 输出：1.0
# 字典长度
print(len(dict1)) # 输出：3
print(len(dict2)) # 输出：3
# 修改字典中的元素
dict1['age'] = 21
dict2['orange'] = 1.0
print(dict1) # 输出：{'name': 'Alice', 'age': 21, 'country': 'USA'}
print(dict2) # 输出：{'apple': 1.0, 'banana': 0.5, 'orange': 1.0}
# 添加新的键-值对
dict1['gender'] = 'female'
dict2['grape'] = 0.7
print(dict1) # 输出：{'name': 'Alice', 'age': 21, 'country': 'USA', 'gender': 'female'}
print(dict2) # 输出：{'apple': 1.0, 'banana': 0.5, 'orange': 1.0, 'grape': 0.7}
# 删除字典中的元素
del dict1['age']
dict2.pop('banana')
print(dict1) # 输出：{'name': 'Alice', 'country': 'USA', 'gender': 'female'}
print(dict2) # 输出：{'apple': 1.0, 'orange': 1.0, 'grape': 0.7}
👑4、变量的定义和命名规范
1、变量的定义
在Python中，变量的定义是通过给变量名赋予一个值来创建变量。下面是一些基本的变量定义示例：
# 定义整数变量
x = 5
y = 10
# 定义浮点数变量
pi = 3.14159
radius = 5.0
# 定义字符串变量
name = "Alice"
greeting = "Hello, world!"
# 定义列表变量
numbers = [1, 2, 3, 4, 5]
fruits = ['apple', 'banana', 'orange']
# 定义字典变量
student = {'name': 'Alice', 'age': 20, 'country': 'USA'}
prices = {'apple': 1.0, 'banana': 0.5, 'orange': 0.8}
2、变量的命名规范
在命名变量时，需要遵循一定的规范，以保证代码的可读性和可维护性。以下是Python中变量命名的一些规范：
变量名只能包含字母、数字和下划线，不能包含空格和特殊字符。
变量名不能以数字开头，可以以字母或下划线开头。
变量名区分大小写，例如count和Count是不同的变量。
变量名应具有描述性，能够清晰表达变量所表示的含义。
变量名通常使用小写字母，多个单词之间可以用下划线分隔，例如first_name。
避免使用Python的关键字作为变量名，例如if、for等。
下面是一些符合命名规范的变量示例：
# 定义变量并遵循命名规范
first_name = "Alice"
age = 20
num_students = 100
# 使用多个单词并用下划线分隔
total_sales = 5000.0
student_count = 50
# 避免使用关键字作为变量名
my_list = [1, 2, 3]
for item in my_list:
print(item)
3、变量的使用注意事项
在使用变量时，需要注意以下几点：
变量在使用之前需要进行定义，即给变量赋予一个值。
变量可以被重新赋值，新的值会覆盖旧的值。
变量的作用域是在其被定义的块内有效，超出该块的范围无法访问该变量。
# 变量的重新赋值
x = 5
print(x) # 输出：5
x = 10
print(x) # 输出：10
# 变量作用域的示例
def my_function():
y = 20
print(y) # 输出：20
my_function()
print(y) # 报错，无法访问函数内部的变量y
条件和循环语句
👑1、if语句及其嵌套
1、if语句的基本使用
if语句用于在满足条件时执行特定的代码块。下面是一个基本的if语句示例：
# 基本的if语句
x = 10
if x > 5:
print("x大于5")
# 在上述示例中，当变量x的值大于5时，if语句的条件为真，执行打印语句。否则，不执行任何操作。2、if-else语句的使用
if-else语句允许根据条件的真假执行不同的代码块。下面是一个if-else语句的示例：
# if-else语句
x = 3
if x > 5:
print("x大于5")
else:
print("x小于等于5")
# 在上述示例中，如果变量x的值大于5，则执行第一个代码块；否则，执行第二个代码块。3、if-elif-else语句的使用
if-elif-else语句允许根据多个条件的真假执行不同的代码块。elif是”else if”的缩写，用于检查额外的条件。下面是一个if-elif-else语句的示例：
# if-elif-else语句
x = 7
if x > 10:
print("x大于10")
elif x > 5:
print("x大于5，小于等于10")
else:
print("x小于等于5")
# 在上述示例中，首先检查变量x是否大于10，如果是，则执行第一个代码块；
# 如果不满足第一个条件，那么检查是否大于5，如果是，则执行第二个代码块；否则，执行第三个代码块。4、if语句的嵌套使用
在Python中，if语句可以相互嵌套，以构建更复杂的条件判断逻辑。下面是一个if语句的嵌套示例：
# if语句的嵌套使用
x = 15
if x > 10:
print("x大于10")
if x > 15:
print("x大于15")
else:
print("x小于等于15")
else:
print("x小于等于10")
# 在上述示例中，首先检查变量x是否大于10，如果是，则执行第一个代码块；
# 在第一个代码块中，又嵌套了一个if语句，检查变量x是否大于15，根据条件的真假执行相应的代码块。
👑2、for循环和while循环
1、for循环的使用
for循环用于遍历序列（如列表、字符串等）或其他可迭代对象，并按顺序执行特定的代码块。下面是一个for循环的示例：
# for循环遍历列表
fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
print(fruit)
# 在上述示例中，for循环遍历了列表fruits中的每一个元素，并将其赋值给变量fruit，然后执行打印语句。
# 循环会一直执行，直到遍历完所有的元素。2、遍历字符串
我们也可以使用for循环遍历字符串中的每个字符。
message = "Hello, World!"
for char in message:
print(char)
3、遍历字典
在遍历字典时，我们可以使用items()方法来获取键值对，并使用for循环遍历它们。
student_scores = {"Alice": 85, "Bob": 72, "Charlie": 90}
for name, score in student_scores.items():
print(name, score)
4、while循环
while循环用于在满足特定条件时重复执行一段代码。它会在每次迭代之前检查条件，只要条件为真，就会继续执行循环。
以下是while循环的基本语法：
while 条件:
# 执行的代码块
# 更新条件
计数器循环
while循环常用于实现计数器循环，即在一定条件下重复执行固定次数的操作。
count = 0
while count < 5:
print("Count:", count)
count += 1
5、用户输入循环
我们可以使用while循环和条件语句来实现根据用户输入进行循环的功能。
user_input = ""
while user_input != "quit":
user_input = input("请输入内容（输入'quit'退出）：")
print("输入内容：", user_input)
6、条件控制循环
while循环还可以通过条件控制来灵活地实现各种不同的需求。
num = 1
sum = 0
while num <= 10:
sum += num
num += 1
print("Sum:", sum)
👑3、break和continue语句的使用
1、break语句
break语句用于终止循环，并跳出循环体执行循环之后的代码。当某个条件满足时，我们可以使用break语句立即退出循环，无论循环还有多少次迭代。
以下是break语句的基本语法：
for 变量 in 可迭代对象:
if 条件:
break
# 执行的代码块
2、跳出循环
我们可以使用break语句来跳出for循环或while循环。
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
if fruit == "banana":
break
print(fruit)
3、结合条件判断
break语句通常与条件判断结合使用，以满足特定条件时跳出循环。
count = 0
while True:
print("Count:", count)
count += 1
if count == 5:
break
4、continue语句
continue语句用于跳过当前迭代，并继续执行下一次迭代。当某个条件满足时，我们可以使用continue语句跳过当前循环体的剩余代码，直接进入下一次循环。
以下是continue语句的基本语法：
for 变量 in 可迭代对象:
if 条件:
continue
# 执行的代码块
跳过特定迭代
我们可以使用continue语句来跳过特定的迭代。
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
if fruit == "banana":
continue
print(fruit)
5、结合条件判断
continue语句通常与条件判断结合使用，以满足特定条件时跳过当前迭代。
count = 0
while count < 5:
count += 1
if count == 3:
continue
print("Count:", count)
函数和模块
👑1、函数的定义和调用
1、函数的定义
函数是一段完成特定任务的代码块，它可以接收输入参数并返回输出结果。通过定义函数，我们可以将一段代码封装成一个独立的逻辑单元，供程序的其他部分重复使用。
以下是函数的基本定义语法：
def 函数名(参数1, 参数2, ...):
# 函数体
# 执行的代码块
return 返回值
2、无参数函数
我们可以定义一个不接收任何参数的函数。
def say_hello():
print("Hello, World!")
# 调用函数
say_hello()
3、带参数函数
我们可以定义一个接收参数的函数，并在函数体内使用这些参数。
def greet(name):
print("Hello, " + name + "!")
# 调用函数
greet("Alice")
4、返回值函数
def add_numbers(a, b):
return a + b
# 调用函数并打印返回值
result = add_numbers(3, 5)
print("Sum:", result)
5、函数的调用
函数的调用是指使用函数名称和适当的参数来执行函数体内的代码。
调用无参数函数
我们可以直接调用不接收任何参数的函数。
def say_hello():
print("Hello, World!")
# 调用函数
say_hello()
6、调用带参数函数
在调用带参数的函数时，我们需要提供相应的参数值。
def greet(name):
print("Hello, " + name + "!")
# 调用函数
greet("Alice")
7、使用返回值
在调用返回值函数时，我们可以将返回值赋给一个变量，并在后续代码中使用。
def add_numbers(a, b):
return a + b
# 调用函数并打印返回值
result = add_numbers(3, 5)
print("Sum:", result)
👑2、函数参数和返回值
1、位置参数
位置参数是最常见的函数参数类型。它们按照函数定义中的参数顺序进行传递，并且在调用函数时必须提供相应的参数值。下面是一个计算两个数之和的函数示例：
def add_numbers(a, b):
return a + b
result = add_numbers(3, 5)
print(result) # 输出：8
2、默认参数
默认参数在函数定义时给参数赋予一个默认值，如果调用函数时没有提供该参数的值，则使用默认值。默认参数可以减少函数调用时的必要参数个数。以下是一个带有默认参数的函数示例：
def greet(name, message="Hello"):
print(message, name)
greet("Alice") # 输出：Hello Alice
greet("Bob", "Hi") # 输出：Hi Bob
3、可变长参数：
有时候我们无法确定函数需要接收多少个参数，这时候可变长参数非常有用。在Python中，有两种类型的可变长参数：*args和kwargs。*args用于接收任意数量的位置参数，而kwargs用于接收任意数量的关键字参数。下面是一个使用可变长参数的函数示例：
def calculate_total(*args):
total = 0
for num in args:
total += num
return total
result = calculate_total(1, 2, 3, 4, 5)
print(result) # 输出：15
4、返回值的多样化应用
函数可以返回不同类型的值，包括单个值、多个值和空值。返回值可以被存储、传递给其他函数或用于进行进一步的计算。以下是几个返回值多样化应用的示例：
返回单个值：
def square(number):
return number * number
result = square(5)
print(result) # 输出：25
返回多个值：
def calculate_sum_and_average(numbers):
total = sum(numbers)
average = total / len(numbers)
return total, average
result = calculate_sum_and_average([1, 2, 3, 4, 5])
print(result) # 输出：(15, 3.0)
返回空值
def print_message():
print("Hello, World!")
result = print_message()
print(result) # 输出：None
👑3、模块的导入和使用
1、导入标准库模
Python标准库是Python安装时默认包含的一组模块，它们提供了各种常用的功能和工具。通过导入标准库模块，我们可以直接使用这些功能。下面是一个使用math模块计算圆的面积的示例：
import math
radius = 5
area = math.pi * math.pow(radius, 2)
print(area) # 输出：78.53981633974483
2、导入第三方模块
除了标准库模块外，Python还有一个庞大的第三方模块生态系统，可以通过pip等工具进行安装和使用。导入第三方模块需要先安装该模块，然后使用import语句导入。以下是一个使用requests模块发送HTTP请求的示例：
import requests
response = requests.get("https://www.example.com")
print(response.status_code) # 输出：200
3、自定义模块的导入和使用
除了使用现有的模块，我们还可以自己编写模块来组织和重用代码。自定义模块通常由一个.py文件组成，其中包含函数、类和变量等。下面是一个自定义模块的示例：
calculation.py 文件内容：
def add_numbers(a, b):
return a + b
def multiply_numbers(a, b):
return a * b
主程序文件中导入自定义模块并使用其中的函数
import calculation
result = calculation.add_numbers(3, 5)
print(result) # 输出：8
result = calculation.multiply_numbers(3, 5)
print(result) # 输出：15
4、使用别名导入模块
在导入模块时，我们可以使用别名来简化模块名的使用。这在模块名过长或存在冲突时特别有用。以下是使用别名导入模块的示例：
import math as m
radius = 5
area = m.pi * m.pow(radius, 2)
print(area) # 输出：78.53981633974483
文件操作
👑1、打开、读取和写入文件
1、文件的打开
在Python中，我们使用open()函数来打开文件，并返回一个文件对象，以便后续操作。在打开文件时，我们需要指定文件的路径和打开模式。以下是几种常见的文件打开模式：
“r”：只读模式，用于读取文件内容。
“w”：写入模式，用于清空文件并写入新内容。
“a”：追加模式，用于在文件末尾追加新内容。
“x”：创建模式，用于创建新文件并写入内容。
下面是打开文件并读取其中内容的示例：
file = open("data.txt", "r")
content = file.read()
print(content)
file.close()
2、文件的读取
一旦文件被打开，我们可以使用不同的方法来读取文件中的内容。常见的方法包括：
read()：读取整个文件内容。
readline()：逐行读取文件内容。
readlines()：将文件内容按行读取并返回一个列表。
以下是使用不同方法读取文件内容的示例：
# read()
file = open("data.txt", "r")
content = file.read()
print(content)
file.close()
# readline()
file = open("data.txt", "r")
line = file.readline()
while line:
print(line)
line = file.readline()
file.close()
# readlines()
file = open("data.txt", "r")
lines = file.readlines()
for line in lines:
print(line)
file.close()
3、文件的写入
除了读取文件内容，我们还可以将数据写入文件中。在打开文件时，我们需要使用写入模式（”w”）或追加模式（”a”）来写入数据。以下是将数据写入文件的示例：
# 写入模式（"w"）
file = open("data.txt", "w")
file.write("Hello, World!")
file.close()
# 追加模式（"a"）
file = open("data.txt", "a")
file.write("\nWelcome to Python!")
file.close()
4、使用上下文管理器
为了更加方便和安全地操作文件，我们可以使用上下文管理器来自动管理文件的打开和关闭。通过使用with语句，可以确保文件在使用完毕后自动关闭，而无需手动调用close()方法。以下是使用上下文管理器进行文件读取的示例：
with open("data.txt", "r") as file:
content = file.read()
print(content)
👑2、文件指针和文件的关闭
1、文件指针的定位
在文件中，文件指针是一个标记，指示当前读取或写入的位置。文件指针默认指向文件开头。我们可以使用seek()函数将文件指针定位到指定位置。以下是一个将文件指针定位到文件开头的示例：
file = open("data.txt", "r")
file.seek(0)
content = file.read()
print(content)
file.close()
2、文件指针的移动
文件指针不仅可以定位到文件的开头，还可以根据需要进行移动。使用seek()函数和偏移量（以字节为单位），我们可以将文件指针相对于当前位置进行前进或后退。以下是一个将文件指针后退一行的示例：
file = open("data.txt", "r")
file.readline() # 读取并忽略第一行
file.seek(-len(file.readline()), 1) # 后退一行
content = file.read()
print(content)
file.close()
3、文件的自动关闭
在文件操作完成后，我们需要确保正确关闭文件，以释放系统资源。为了避免忘记关闭文件，可以使用上下文管理器的方式操作文件。通过使用with语句，文件在使用完毕后会自动关闭，无需手动调用close()方法。以下是使用上下文管理器进行文件操作的示例：
with open("data.txt", "r") as file:
content = file.read()
print(content)
👑3、异常处理和文件操作的错误处理
1、异常的捕获与处理
在Python中，我们可以使用try-except语句来捕获和处理异常。try块中的代码尝试执行，如果出现异常，则会跳转到对应的except块，并执行相应的异常处理代码。以下是一个捕获除零错误的示例：
try:
x = 10 / 0
except ZeroDivisionError:
print("除零错误发生！")
2、文件操作错误处理
在文件操作中，可能会出现诸如文件不存在、权限错误等错误情况。为了处理这些错误，我们可以使用try-except语句捕获相应的异常，并执行适当的错误处理代码。以下是一个处理文件打开错误的示例：
try:
file = open("data.txt", "r")
except FileNotFoundError:
print("文件不存在！")
3、异常处理与文件操作的结合
在文件操作中，我们可以结合异常处理来处理文件的读取和写入操作。通过捕获文件操作可能出现的异常，我们可以在发生错误时进行适当的处理，避免程序崩溃或数据丢失。以下是一个读取文件并处理文件不存在异常的示例：
try:
with open("data.txt", "r") as file:
content = file.read()
print(content)
except FileNotFoundError:
print("文件不存在！")
4、自定义异常
除了内置的异常类型，我们还可以自定义异常类型来满足特定的错误处理需求。通过继承Python的Exception类，我们可以定义自己的异常类，并在需要时引发自定义异常。以下是一个自定义异常的示例：
class MyCustomException(Exception):
pass
try:
raise MyCustomException("自定义异常被引发！")
except MyCustomException as e:
print(e)
面向对象编程
👑1、类和对象的概念
1、类的定义与实例化
在Python中，我们使用class关键字来定义类，类中包含属性和方法。通过实例化类，我们可以创建对象，并访问对象的属性和调用对象的方法。以下是一个简单的人类（Person）类的定义和实例化示例：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
print("Hello, my name is", self.name)
person1 = Person("Alice", 20)
person1.greet()
2、对象属性与方法的访问
在Python中，我们可以通过点运算符来访问对象的属性和调用对象的方法。对象属性存储对象的状态信息，而对象方法用于定义对象的行为。以下是访问对象属性和调用对象方法的示例：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
print("Hello, my name is", self.name)
person1 = Person("Alice", 20)
print(person1.name) # 访问对象属性
person1.greet() # 调用对象方法
3、错误处理与类的结合
在类和对象的使用过程中，可能会出现各种错误情况。为了保证程序的健壮性，我们可以结合错误处理来捕获和处理可能发生的异常。以下是一个在类方法中使用错误处理的示例：
class Calculator:
def divide(self, num1, num2):
try:
result = num1 / num2
print("结果：", result)
except ZeroDivisionError:
print("除零错误发生！")
calculator = Calculator()
calculator.divide(10, 0)
👑2、属性和方法的定义
1、属性的定义与访问
在Python类中，我们可以使用__init__方法初始化对象的属性，并使用self关键字来访问和设置属性的值。以下是一个简单的人类（Person）类的属性定义和访问示例：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
person1 = Person("Alice", 20)
print(person1.name) # 访问属性值
person1.age = 25 # 设置属性值
print(person1.age)
2、方法的定义与调用：
在Python类中，我们可以定义方法来实现对象的行为。方法可以访问对象的属性，并在需要时进行相应的操作。以下是一个简单的人类（Person）类的方法定义和调用示例：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
print("Hello, my name is", self.name)
person1 = Person("Alice", 20)
person1.greet() # 调用方法
3、错误处理与属性方法的结合
在属性和方法的使用过程中，可能会出现各种错误情况。为了保证程序的健壮性，我们可以结合错误处理来捕获和处理可能发生的异常。以下是一个在方法中使用错误处理的示例：
class Calculator:
def divide(self, num1, num2):
try:
result = num1 / num2
print("结果：", result)
except ZeroDivisionError:
print("除零错误发生！")
calculator = Calculator()
calculator.divide(10, 0)
👑3、继承和多态的实现
1、类的继承与重写
在Python中，我们可以通过继承来创建一个新类，该新类继承了父类的属性和方法。子类可以使用父类的属性和方法，并可以重写父类的方法以实现自己的行为。以下是一个简单的动物（Animal）类和狗（Dog）类的继承与重写示例：
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print("动物发出叫声...")
class Dog(Animal):
def __init__(self, name):
super().__init__(name)
def speak(self):
print("狗发出汪汪叫声！")
dog = Dog("旺财")
dog.speak() # 输出："狗发出汪汪叫声！"
2、多态的实现
在Python中，多态可以通过方法的重写和对象的动态绑定来实现。不同的子类对象可以对相同的方法进行不同的实现。以下是一个简单的形状（Shape）类和矩形（Rectangle）类的多态实现示例：
class Shape:
def calculate_area(self):
pass
class Rectangle(Shape):
def __init__(self, length, width):
self.length = length
self.width = width
def calculate_area(self):
return self.length * self.width
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def calculate_area(self):
return 3.14 * self.radius * self.radius
shapes = [Rectangle(5, 10), Circle(3)]
for shape in shapes:
area = shape.calculate_area()
print("面积：", area)
3、继承和多态的应用场景
继承和多态在实际开发中有广泛的应用。通过继承，我们可以从现有的类构建出更具体的子类，以实现代码的重用和扩展。而多态则使得我们可以针对不同的对象类型使用相同的方法名，从而简化了代码的编写和维护。这种灵活性使得我们能够更好地应对不同的业务需求。
版权声明：本文为博主作者：ZTLJQ原创文章，版权归属原作者，如果侵权，请联系我们删除！
原文链接：https://blog.csdn.net/SUEJESDA/article/details/131043586
