Python入门

欢迎来到Cefler的博客
博客主页：那个传说中的man的主页
个人专栏：题目解析
推荐文章：题目大解析3

---

前言
该博客主要帮助有编程基础的童鞋快速掌握python的一些知识点，形式主要就是给出概念再配上相对应的示例便于理解并且上手实操

---

字典和集合

字典

字典是 Python 中的一种数据结构，用于存储键值对。它是一个可变的、无序的集合，其中每个元素都由一个键和一个对应的值组成。

字典的键必须是唯一的，并且只能使用不可变的数据类型作为键，例如字符串、数字或元组。值可以是任意类型的数据，包括字符串、数字、列表、字典等。

下面是一个字典的示例：

person = {
    "name": "Alice",
    "age": 25,
    "city": "New York"
}

在上面的示例中，我们创建了一个名为 person 的字典，其中包含了三个键值对。键 “name” 对应的值是 “Alice”，键 “age” 对应的值是 25，键 “city” 对应的值是 “New York”。

我们可以使用键来访问字典中的值，例如：

print(person["name"])  # 输出：Alice
print(person["age"])   # 输出：25

我们还可以使用 len() 函数获取字典中键值对的数量：

print(len(person))  # 输出：3

字典是可变的，这意味着我们可以添加、修改或删除字典中的键值对。例如，我们可以添加一个新的键值对：

person["gender"] = "female"
print(person)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'New York', 'gender': 'female'}

我们也可以修改字典中的值：

person["age"] = 26
print(person)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York', 'gender': 'female'}

最后，我们可以使用 del 关键字删除字典中的键值对：

del person["city"]
print(person)  # 输出：{'name': 'Alice', 'age': 26, 'gender': 'female'}

集合

在Python中，集合（Set）是一种无序且不重复的数据集合。集合是由一组唯一的元素组成，可以进行交集、并集、差集等操作。

以下是一些关于Python集合的重要特点和用法：

1. 创建集合：

   set1 = {1, 2, 3}  # 使用花括号创建集合
   set2 = set([4, 5, 6])  # 使用set()函数创建集合

2. 集合的元素必须是不可变的（如整数、浮点数、字符串、元组等），不能包含可变类型（如列表、字典等）。

3. 集合中的元素是无序的，不能通过索引访问。

4. 集合中的元素是唯一的，重复的元素会被自动去重。

5. 添加元素到集合：

   set1.add(4)  # 添加单个元素
   set1.update([5, 6, 7])  # 添加多个元素

6. 删除集合中的元素：

   set1.remove(3)  # 删除指定元素，如果元素不存在会抛出KeyError异常
   set1.discard(4)  # 删除指定元素，如果元素不存在不会抛出异常
   set1.pop()  # 随机删除一个元素
   set1.clear()  # 清空集合中的所有元素

7. 集合的基本操作：

   len(set1)  # 获取集合的长度
   x in set1  # 判断元素是否在集合中
   set1.union(set2)  # 返回两个集合的并集
   set1.intersection(set2)  # 返回两个集合的交集
   set1.difference(set2)  # 返回两个集合的差集
   set1.symmetric_difference(set2)  # 返回两个集合的对称差集

8. 遍历集合：

   for item in set1:
       print(item)

集合提供了一种方便的方式来处理唯一性和集合操作。它们在去重、查找、过滤等场景中非常有用。

format

format 是 Python 中用于格式化字符串的方法。它允许我们将变量的值插入到字符串中的特定位置。使用 {} 占位符来表示要插入的变量，并使用 format 方法将变量的值传递给占位符。

下面是一个示例：

name = "Alice"
age = 25
message = "我的名字是 {}，我今年 {} 岁。".format(name, age)
print(message)

输出结果为：

我的名字是 Alice，我今年 25 岁。

在上面的示例中，我们使用了两个占位符 {} 来表示要插入的变量。然后，通过 format 方法将 name 和 age 的值传递给占位符，生成最终的字符串。

除了基本的变量插入外，format 方法还支持更复杂的格式化选项，例如指定变量的宽度、精度、对齐方式等。你可以通过在占位符中使用冒号 : 来指定这些选项。

例如：

pi = 3.141592653589793
formatted_pi = "圆周率的值是：{:.2f}".format(pi)
print(formatted_pi)

print和input

print

在Python中，print 是一个内置函数，用于将文本或其他对象的值输出到控制台或文件。下面是一些常见的 print 的用法：

1. 打印文本：

   print("Hello, World!")

2. 打印变量的值：

   name = "Alice"
   age = 25
   print(name, age)

3. 格式化输出：

   name = "Alice"
   age = 25
   print("My name is {} and I am {} years old.".format(name, age))

4. 使用 f-string 进行格式化输出（Python 3.6+）：

   name = "Alice"
   age = 25
   print(f"My name is {name} and I am {age} years old.")

5. 打印多个对象，使用逗号分隔：

   name = "Alice"
   age = 25
   print(name, age)

6. 打印到文件：

   with open("output.txt", "w") as f:
       print("Hello, World!", file=f)

7. 控制打印的分隔符和结束符：

   print("Hello", "World", sep=", ", end="!")

8. 打印不换行：

   print("Hello", end="")
   print("World")

这些只是 print 函数的一些常见用法，还有其他更高级的用法，如将输出重定向到文件、使用不同的输出流等。你可以根据需要选择适合的用法。

input

在Python中，input 是一个内置函数，用于从用户获取输入。下面是一些常见的 input 的用法：

1. 获取用户输入的字符串：

   name = input("Please enter your name: ")

2. 获取用户输入的整数：

   age = int(input("Please enter your age: "))

3. 获取用户输入的浮点数：

   height = float(input("Please enter your height in meters: "))

4. 获取多个输入值，使用 split 方法分隔：

   numbers = input("Please enter a list of numbers, separated by spaces: ").split()

5. 使用 map 函数将输入的字符串转换为其他类型：

   numbers = list(map(int, input("Please enter a list of numbers, separated by spaces: ").split()))

6. 使用 eval 函数将输入的字符串作为表达式求值：

   result = eval(input("Please enter an arithmetic expression: "))

需要注意的是，input 函数返回的是一个字符串。如果需要将输入转换为其他类型，如整数或浮点数，需要使用相应的类型转换函数（如 int 或 float）。

列表和元组

列表和元组都是Python中常用的数据结构。

列表是一个有序的可变序列，可以存储任意类型的元素。列表使用方括号[]来表示，元素之间用逗号,分隔。列表可以进行增加、删除、修改和查询操作。

例如，创建一个列表：

fruits = ['apple', 'banana', 'orange']

元组也是一个有序的序列，但是与列表不同的是，元组是不可变的，即创建后不能修改。元组使用圆括号()来表示，元素之间同样用逗号,分隔。

例如，创建一个元组：

colors = ('red', 'green', 'blue')

列表和元组都可以通过索引访问其中的元素，索引从0开始。例如，访问列表中的第一个元素：

first_fruit = fruits[0]

列表和元组还支持切片操作，可以通过切片获取其中的一部分元素。例如，获取列表中的前两个元素：

first_two_fruits = fruits[:2]

总结一下，列表和元组都是用来存储多个元素的数据结构，列表是可变的，而元组是不可变的。根据具体的需求，选择使用列表还是元组来存储数据。

列表进行增加、删除、修改和查询操作

列表可以通过以下方式进行增加、删除、修改和查询操作：

1. 增加元素：使用append()方法在列表末尾添加一个元素，或使用insert()方法在指定位置插入一个元素。

示例：

   fruits = ['apple', 'banana', 'orange']
   fruits.append('grape')  # 在列表末尾添加元素
   fruits.insert(1, 'kiwi')  # 在索引为1的位置插入元素

2. 删除元素：使用remove()方法删除指定的元素，或使用del关键字删除指定位置的元素。

示例：

   fruits = ['apple', 'banana', 'orange']
   fruits.remove('banana')  # 删除指定元素
   del fruits[0]  # 删除索引为0的元素

3. 修改元素：通过索引直接赋值的方式修改列表中的元素。

示例：

   fruits = ['apple', 'banana', 'orange']
   fruits[1] = 'kiwi'  # 修改索引为1的元素

4. 查询元素：使用索引来访问列表中的元素，或使用in关键字判断元素是否存在于列表中。

示例：

   fruits = ['apple', 'banana', 'orange']
   print(fruits[0])  # 访问索引为0的元素
   if 'banana' in fruits:  # 判断元素是否存在于列表中
       print("Banana is in the list.")

条件语句

条件语句是编程中用于根据不同条件执行不同代码块的结构。在Python中，常用的条件语句有if语句和if-else语句。

if语句用于在满足特定条件时执行一段代码。它的基本语法如下：

if 条件:
    # 如果条件为真，则执行这里的代码

if-else语句在满足条件时执行一段代码，否则执行另一段代码。它的基本语法如下：

if 条件:
    # 如果条件为真，则执行这里的代码
else:
    # 如果条件为假，则执行这里的代码

除了if-else语句，还可以使用if-elif-else语句来处理多个条件。elif关键字用于检查额外的条件。它的基本语法如下：

if 条件1:
    # 如果条件1为真，则执行这里的代码
elif 条件2:
    # 如果条件2为真，则执行这里的代码
else:
    # 如果以上条件都不满足，则执行这里的代码

条件语句中的条件可以使用比较运算符（如==、<、>等）和逻辑运算符（如and、or、not）进行组合。这些运算符可以帮助我们对变量或表达式进行比较和判断。

循环语句

ython中有两种常用的循环语句：for循环和while循环。

for循环用于遍历一个可迭代对象（如列表、元组、字符串等）中的元素。它的语法如下：

for 变量 in 可迭代对象:
    # 执行循环体代码

在每次循环中，变量会依次取到可迭代对象中的一个元素，然后执行循环体中的代码。当所有元素都被遍历完毕后，循环结束。

while循环用于在满足一定条件的情况下重复执行一段代码。它的语法如下：

while 条件:
    # 执行循环体代码

range

range 是 Python 中的一个内置函数，用于生成一个整数序列。它可以接受一个或多个参数，包括起始值、结束值和步长。

range 函数的语法如下：

range(start, stop, step)

• start：可选参数，表示序列的起始值，默认为 0。
• stop：必需参数，表示序列的结束值，但不包含该值。
• step：可选参数，表示序列中相邻两个值之间的步长，默认为 1。

range 函数返回一个可迭代对象，可以通过循环来遍历该序列，或者将其转换为列表。

下面是一些示例：

# 生成一个从 0 到 4 的整数序列
for i in range(5):
    print(i)

# 生成一个从 1 到 10 的整数序列，步长为 2
for i in range(1, 11, 2):
    print(i)

# 将序列转换为列表
numbers = list(range(1, 6))
print(numbers)  # 输出 [1, 2, 3, 4, 5]

在每次循环开始时，会先判断条件是否为真。如果条件为真，则执行循环体中的代码；如果条件为假，则跳出循环。

random

rand是Python中的一个随机数生成函数。它可以用来生成指定范围内的随机整数。rand函数属于random模块，需要先导入该模块才能使用。

以下是使用rand函数生成随机整数的示例代码：

import random

# 生成0到9之间的随机整数
num = random.randint(0, 9)
print(num)

上述代码会输出一个0到9之间的随机整数。每次运行代码，输出的结果都可能不同

math

math 是 Python 中的一个内置模块，提供了许多数学运算的函数和常量。你可以使用 import math 来导入这个模块。

以下是 math 模块中一些常用的函数和常量：

• math.sqrt(x): 返回 x 的平方根。
• math.ceil(x): 返回大于或等于 x 的最小整数。
• math.floor(x): 返回小于或等于 x 的最大整数。
• math.pow(x, y): 返回 x 的 y 次幂。
• math.sin(x): 返回 x 的正弦值。
• math.cos(x): 返回 x 的余弦值。
• math.pi: 圆周率 π 的近似值。

函数

函数是一段可重复使用的代码块，用于执行特定的任务。在Python中，函数由关键字def定义，并且可以接受零个或多个参数。函数可以执行一系列操作，并且可以返回一个值。

以下是一个简单的Python函数的示例：

def greet(name):
    print("你好，" + name + "！")

greet("小明")

在上面的示例中，greet是一个函数，它接受一个参数name。当我们调用greet(“小明”)时，函数将打印出你好，小明！。

函数还可以返回一个值。例如：

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

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

在上面的示例中，add函数接受两个参数a和b，并返回它们的和。我们将函数的返回值赋给变量result，然后打印出结果。

函数还可以有默认参数和可变参数，以及可以返回多个值。但是这些是函数的高级特性，需要更深入的学习。

statistics

statistics 是 Python 中用于统计分析的标准库。它提供了许多函数和工具，用于计算各种统计量，例如平均值、中位数、标准差等。

要使用 statistics 库，首先需要导入它：

import statistics

然后，你可以使用该库中的函数来执行各种统计计算。例如，要计算一组数据的平均值，可以使用 mean 函数：

data = [1, 2, 3, 4, 5]
mean_value = statistics.mean(data)
print(mean_value)

除了平均值，statistics 还提供了许多其他函数，如 median（中位数）、stdev（标准差）、variance（方差）等。你可以根据需要选择适当的函数来执行相应的统计计算。

我们发现每次调用库函数都要带上模块的名字，感觉这样很冗余，有没有解决方法呢？

from import

from import 是 Python 中用于导入模块或模块中的特定函数、类或变量的语法。它允许我们从一个模块中选择性地导入需要的内容，而不必导入整个模块。

使用 from import 的一般语法是：

from 模块名 import 对象名

其中，模块名 是要导入的模块的名称，对象名 是要导入的特定函数、类或变量的名称。

例如，如果我们想要导入 Python 内置的 math 模块中的 sqrt 函数，可以这样写：

from math import sqrt

这样，我们就可以直接使用 sqrt 函数，而不需要在调用时使用模块名作为前缀。

如果我们想要导入多个对象，可以使用逗号分隔它们的名称，例如：

from 模块名 import 对象1, 对象2, 对象3

另外，我们也可以使用 as 关键字给导入的对象起一个别名，以便在代码中更方便地使用，例如：

from 模块名 import 对象名 as 别名

如果想导入所有库函数，可以有：

from 模块名 import *

python如何下载第三方库？

要下载 Python 的第三方库，你可以使用 pip 工具。pip 是 Python 的包管理器，它可以帮助你方便地安装、升级和卸载第三方库。

以下是下载第三方库的步骤：

1. 打开终端或命令提示符。
2. 输入以下命令来检查是否已安装 pip：

   pip --version

如果已经安装了 pip，你将看到它的版本号。如果没有安装，你需要先安装 pip。
3. 使用以下命令来安装第三方库：

   pip install 库名

将 库名 替换为你要下载的第三方库的名称。例如，要下载 requests 库，你可以运行：

   pip install requests

pip 将自动从 Python 包索引（PyPI）下载并安装该库及其依赖项。
4. 安装完成后，你就可以在 Python 代码中导入并使用该库了。

如果你想安装特定版本的库，可以使用 == 运算符指定版本号。例如：

pip install 库名==版本号

如果你想升级已安装的库，可以使用 --upgrade 参数。例如：

pip install --upgrade 库名

————————————————————进阶

类

Python 中的类是一种用于创建对象的蓝图或模板。类定义了对象的属性和方法，它们定义了对象的行为和特征。

要定义一个类，可以使用 class 关键字，后面跟着类的名称。类名通常以大写字母开头，遵循驼峰命名法。

以下是一个简单的类的示例：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
//在Python的类中，可以使用构造函数 __init__ 来声明成员变量。构造函数是在创建对象时自动调用的特殊方法，用于初始化对象的属性。
//在构造函数中，可以使用 self 关键字来引用当前对象，并使用点号 . 来访问和设置对象的属性。
    def say_hello(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

# 创建一个 Person 对象
person = Person("Alice", 25)

# 调用对象的方法
person.say_hello()
# 访问对象的成员变量
print(person1.name)  # 输出 "Alice"
print(person1.age)   # 输出 25

在上面的示例中，我们定义了一个名为 Person 的类。它有两个属性 name 和 age，以及一个方法 say_hello()。_ init () 方法是一个特殊的方法，用于初始化对象的属性。在类的方法中，第一个参数通常是 self，它表示对象本身。
注意：构造函数只能用 init _() 方法
要创建类的实例（也称为对象），我们可以使用类名后面跟着括号，并传递所需的参数。然后，我们可以使用对象的属性和方法来访问和操作对象的状态和行为。

类提供了一种封装数据和功能的方式，使代码更加模块化和可维护。通过创建多个对象，我们可以使用相同的类定义来创建具有不同属性和行为的多个实例。

与c++类的对比

相同点：

1. 都是面向对象编程的概念，用于创建对象和定义对象的属性和方法。
2. 都支持封装、继承和多态的特性。
3. 都可以使用构造函数来初始化对象。
4. 都可以使用访问修饰符来控制成员的可访问性。

不同点：
5. 语法不同：Python 使用 class 关键字来定义类，而 C++ 使用 class 关键字或 struct 关键字来定义类。
6. 内存管理：Python 使用自动垃圾回收机制来管理对象的内存，而 C++ 需要手动管理内存，包括对象的创建和销毁。
7. 方法定义：Python 中的方法默认是动态绑定的，即在运行时确定调用的方法，而 C++ 中的方法默认是静态绑定的，即在编译时确定调用的方法。
8. 继承方式：Python 支持单继承和多继承，一个类可以继承自一个或多个父类；而 C++ 支持单继承和多继承，但是多继承需要注意解决菱形继承问题。
9. 方法重载：C++ 支持方法重载，即在同一个类中可以定义多个同名但参数列表不同的方法；而 Python 不支持方法重载，后定义的方法会覆盖前面的方法。
10. 异常处理：C++ 使用 try-catch 块来处理异常，而 Python 使用 try-except 块来处理异常。
11.

继承

在Python中，继承是一种面向对象编程的重要概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。

通过继承，子类可以获得父类的特性，并且可以添加自己的特性或覆盖父类的特性。这样可以实现代码的重用和层次化的组织。

下面是一个简单的示例，展示了如何在Python中使用继承：

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)
    
    def speak(self):
        print("Dog barks")

# 创建一个Animal对象
animal = Animal("Animal")
animal.speak()  # 输出 "Animal speaks"

# 创建一个Dog对象
dog = Dog("Dog")
dog.speak()  # 输出 "Dog barks"

在上面的示例中，我们定义了一个父类 Animal，它有一个方法 speak()，表示动物的叫声。然后我们创建了一个子类 Dog，它继承了 Animal 类，并重写了 speak() 方法。

通过使用 super() 函数，子类可以调用父类的构造函数和方法。在子类的构造函数中，我们使用 super()._ init _(name) 来调用父类的构造函数。

当我们创建 Animal 对象时，它调用了父类的 speak() 方法。当我们创建 Dog 对象时，它调用了子类的 speak() 方法，覆盖了父类的实现。

继承允许我们构建类的层次结构，从而实现代码的重用和组织。子类可以继承父类的属性和方法，并可以添加自己的特性或覆盖父类的特性。

super函数的意义
在Python中，super() 函数用于调用父类的方法。它在子类中的方法中使用，以便在子类中扩展或覆盖父类的方法时，仍然能够调用父类的实现。

使用 super() 函数的主要原因是确保在子类中调用父类的构造函数和方法，以便继承父类的属性和行为。这样可以避免重复编写父类的代码，并且保持代码的一致性和可维护性。

在子类的构造函数中，通过使用 super().init(…)，可以调用父类的构造函数，并传递必要的参数。这样可以确保子类对象在创建时，能够正确地初始化父类的属性。

在子类的方法中，通过使用 super().method_name(…)，可以调用父类的方法，并传递必要的参数。这样可以在子类中扩展或覆盖父类的方法，同时保留父类方法的功能。

多态

在Python中，多态是面向对象编程的一个重要概念，它允许不同的对象对相同的方法做出不同的响应。多态性使得我们可以使用统一的接口来处理不同类型的对象，从而提高代码的灵活性和可扩展性。

多态性的实现依赖于继承和方法重写。当一个类继承自另一个类，并重写了父类的方法时，我们可以通过父类的引用来调用子类的方法，从而实现多态。

以下是一个简单的示例，展示了在Python中如何实现多态性：

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

# 创建Animal、Dog和Cat对象
animal = Animal()
dog = Dog()
cat = Cat()

# 调用speak()方法
animal.speak()  # 输出 "Animal speaks"
dog.speak()  # 输出 "Dog barks"
cat.speak()  # 输出 "Cat meows"

在上面的示例中，我们定义了一个父类 Animal，以及两个子类 Dog 和 Cat。每个类都有一个 speak() 方法，但是它们的实现是不同的。

通过创建不同的对象并调用它们的 speak() 方法，我们可以看到不同的对象对相同的方法做出了不同的响应。这就是多态性的体现，即不同的对象表现出不同的行为，但是它们都是通过相同的接口进行调用。

多态性使得我们可以编写通用的代码，而不需要关心具体的对象类型。这样可以提高代码的可复用性和可扩展性，同时简化代码的逻辑。

文件

读、写文件

在Python中，文件是用于存储和处理数据的重要工具。Python提供了许多内置函数和模块，用于打开、读取、写入和关闭文件。

以下是一些常用的文件操作的示例：

1. 打开文件：

   file = open('file.txt', 'r')  # 打开文件以供读取
   file = open('file.txt', 'w')  # 打开文件以供写入
   file = open('file.txt', 'a')  # 打开文件以供追加

2. 读取文件内容：

   file = open('file.txt', 'r')
   content = file.read()  # 读取整个文件内容
   content = file.readline()  # 读取文件的一行内容
   content = file.readlines()  # 读取文件的所有行内容，并返回一个列表

3. 写入文件内容：

   file = open('file.txt', 'w')
   file.write('Hello, World!')  # 写入文本内容

4. 关闭文件：

   file = open('file.txt', 'r')
   file.close()  # 关闭文件

5. 使用上下文管理器自动关闭文件：

   with open('file.txt', 'r') as file:
       content = file.read()
   # 在代码块结束后，文件会自动关闭

6. 检查文件是否存在：

   import os

   os.path.exists('file.txt')  # 检查文件是否存在

7. 处理文件路径：

   import os

   file_path = os.path.join('path', 'to', 'file.txt')  # 拼接文件路径
   file_name = os.path.basename(file_path)  # 获取文件名
   dir_name = os.path.dirname(file_path)  # 获取文件所在目录

文件操作是处理数据的常见任务之一。通过使用Python的文件操作功能，可以读取和写入文件，处理文本和二进制数据，并进行文件的管理和操作。

with,as

在Python中，with和as是用于处理上下文的关键字。

with语句用于创建一个上下文管理器，它可以确保在代码块执行完毕后，相关资源会被正确地释放或清理。无论代码块是否发生异常，with语句都会自动关闭资源，避免资源泄漏。

as关键字用于将上下文管理器的返回值赋值给一个变量，以便在代码块中使用。

以下是with和as的使用示例：

with open('file.txt', 'r') as file:
    content = file.read()
    # 在这里使用文件内容

# 在代码块结束后，文件会自动关闭，无需手动调用 file.close()

在上面的示例中，open(‘file.txt’, ‘r’)返回一个文件对象，它是一个上下文管理器。通过使用with语句，我们可以在代码块中使用文件对象，并在代码块结束后自动关闭文件。

as关键字将文件对象赋值给变量file，以便在代码块中使用。在代码块结束后，文件会自动关闭，无需手动调用file.close()。

with语句和as关键字的结合使用，使得资源管理更加简洁和安全，特别是在处理文件、数据库连接、网络连接等需要手动关闭的资源时非常有用。

encoding

在Python中，编码是指将字符转换为字节序列的过程，而解码则是将字节序列转换回字符的过程。由于计算机内部处理的是二进制数据，因此在进行文件读写、网络传输等操作时，需要将字符转换为字节序列进行处理。

Python中的字符串类型是Unicode字符串，它可以表示任意字符。当需要将字符串写入文件或发送到网络时，需要将其编码为字节序列。同样，当从文件或网络接收到字节序列时，需要将其解码为字符串。

Python提供了多种编码和解码的方式，常用的编码包括ASCII、UTF-8、UTF-16等。以下是一些常用的编码和解码操作的示例：

1. 编码字符串为字节序列：

   string = 'Hello, World!'
   encoded_bytes = string.encode('utf-8')  # 使用UTF-8编码字符串为字节序列

2. 解码字节序列为字符串：

   bytes = b'Hello, World!'
   decoded_string = bytes.decode('utf-8')  # 使用UTF-8解码字节序列为字符串

3. 文件读写时的编码：

   # 写入文件时编码为字节序列
   with open('file.txt', 'w', encoding='utf-8') as file:
       file.write('Hello, World!')

   # 读取文件时解码为字符串
   with open('file.txt', 'r', encoding='utf-8') as file:
       content = file.read()

4. 处理网络传输时的编码：

   import requests

   response = requests.get('https://www.example.com')
   content = response.content.decode('utf-8')  # 解码响应内容为字符串

编码是确保字符和字节序列之间正确转换的重要步骤。选择适当的编码方式可以确保数据的正确传输和处理。

捕捉异常

try、except、else、finally

在Python中，try, except, else 和finally是用于处理异常的关键字。

try 语句用于包含可能引发异常的代码块。在 try 代码块中，我们可以放置可能会出现异常的代码。

except 语句用于捕获并处理特定类型的异常。当 try 代码块中的代码引发异常时，程序会跳转到与异常类型匹配的 except 代码块，并执行相应的处理逻辑。

else 语句是可选的，用于在 try 代码块中没有引发异常时执行的代码。如果 try 代码块中的代码没有引发异常，程序会跳过 except 代码块，直接执行 else 代码块。

finally 语句也是可选的，用于包含无论是否发生异常都需要执行的代码。无论 try 代码块中的代码是否引发异常，finally 代码块中的代码都会被执行。

以下是 try, except, else 和 finally 的使用示例：

try:
    # 可能引发异常的代码
    result = 10 / 0
except ZeroDivisionError:
    # 处理 ZeroDivisionError 异常
    print("除数不能为零")
else:
    # 如果没有引发异常，执行此处的代码
    print("计算结果:", result)
finally:
    # 无论是否发生异常，都会执行此处的代码
    print("程序执行完毕")

在上面的示例中，我们尝试将 10 除以 0，这会引发 ZeroDivisionError 异常。程序会跳转到与 ZeroDivisionError 匹配的 except 代码块，并打印出 “除数不能为零”。由于发生了异常，else 代码块中的代码不会被执行。最后，无论是否发生异常，finally 代码块中的代码都会被执行，打印出 “程序执行完毕”。

try, except, else 和 finally 的结合使用可以帮助我们处理和管理异常，使程序更加健壮和可靠。

assert

在Python中，assert是一个用于断言条件是否为真的关键字。它用于在代码中进行简单的测试和调试，以确保某个条件满足。

assert语句的语法如下：

assert condition, message

其中，condition是一个布尔表达式，用于判断某个条件是否为真。如果条件为假，assert语句会引发一个AssertionError异常，并且可选的message参数可以提供一条自定义的错误消息。

以下是一些示例，展示了assert语句的使用场景：

1. 简单断言：

   x = 5
   assert x > 0, "x must be positive"

如果x的值小于等于0，将会引发AssertionError异常，并且错误消息为"x must be positive"。

2. 调试断言：

   def divide(a, b):
       assert b != 0, "Cannot divide by zero"
       return a / b

在这个例子中，assert语句用于确保除数b不为零。如果b的值为零，将会引发AssertionError异常，并且错误消息为"Cannot divide by zero"。

assert语句在开发和调试过程中非常有用，可以帮助我们验证代码中的假设和条件，并在条件不满足时提供有用的错误信息。但是需要注意的是，assert语句在生产环境中通常会被禁用，因为它们会引发异常并中断程序的执行。

unittest

unittest是Python标准库中的一个模块，用于编写和运行单元测试。单元测试是一种软件测试方法，用于验证代码的各个组件（即单元）是否按预期工作。

以下是使用unittest模块编写和运行单元测试的一般步骤：

1. 导入unittest模块：

   import unittest

2. 创建测试类：

   class MyTestCase(unittest.TestCase):
       def test_something(self):
           # 编写测试用例
           pass

注意：

名字必须是test_开头

3. 在测试方法中编写测试用例：

   def test_something(self):
       # 编写测试用例
       self.assertEqual(2 + 2, 4)  # 断言测试结果是否符合预期

4. 运行测试：

• 在脚本中运行测试：

     if __name__ == '__main__':
         unittest.main()

• 在命令行中运行测试：

     python -m unittest test_module.py

unittest模块提供了许多断言方法，用于验证测试结果是否符合预期。一些常用的断言方法包括：

• assertEqual(a, b)：验证a和b是否相等
• assertTrue(x)：验证x是否为True
• assertFalse(x)：验证x是否为False
• assertRaises(exception, callable, *args, **kwargs)：验证调用callable时是否会引发指定的异常

通过编写和运行单元测试，可以确保代码的各个组件按预期工作，并提供一种自动化的方式来检测潜在的问题和错误。

setUP

在Python的unittest模块中，setUp方法是一个特殊的方法，用于在每个测试方法执行之前设置测试环境。

setUp方法在每个测试方法执行之前自动调用，并且不接受任何参数。它通常用于执行一些准备工作，例如创建测试所需的对象、初始化变量、连接数据库等。

以下是一个示例，展示了如何使用setUp方法：

import unittest

class MyTestCase(unittest.TestCase):
    def setUp(self):
        # 在每个测试方法执行之前的准备工作
        self.my_object = MyObject()

    def test_something(self):
        # 使用setUp方法中创建的对象进行测试
        result = self.my_object.do_something()
        self.assertEqual(result, expected_result)

    def test_another_thing(self):
        # 使用setUp方法中创建的对象进行测试
        result = self.my_object.do_another_thing()
        self.assertTrue(result)

if __name__ == '__main__':
    unittest.main()

在上面的示例中，setUp方法创建了一个MyObject对象，并将其赋值给self.my_object。这样，在每个测试方法执行之前，都可以使用self.my_object来访问和操作该对象。

通过使用setUp方法，可以避免在每个测试方法中重复创建相同的对象或执行相同的准备工作，从而使测试代码更加简洁和可维护。

---

如上便是本期的所有内容了，如果喜欢并觉得有帮助的话，希望可以博个点赞+收藏+关注❤️ ,学海无涯苦作舟,愿与君一起共勉成长