大学生Python期末复习冲刺(有这一篇足够)

目录

爆肝2w字👏🏻👏🏻👏🏻

还愁要自己总结知识点?有这一篇就足够👌🏻  

干货满满不看后悔👍👍👍

📝个人主页→数据挖掘博主ZTLJQ的主页

b1691e6f246947eeb06ee06469621bc2.gif

个人推荐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

共计人评分,平均

到目前为止还没有投票!成为第一位评论此文章。

(0)
心中带点小风骚的头像心中带点小风骚普通用户
上一篇 2024年1月16日
下一篇 2天前

相关推荐