VAKAawaking的博客

原创 【Python】super() 函数和 MRO 顺序的实例剖析

在这个例子中，C.__init__() 调用 B1.__init__()，然后 B1.__init__() 通过 super().__init__() 调用了 B2.__init__()，而不是直接调用 A.__init__()。在 B2.__init__() 中，调用 super().__init__()，Python 会继续按照 MRO 顺序找到 A.__init__() 并调用它。在 B1.__init__() 中，super().__init__() 触发了 B2.__init__()。

原创 请帮开餐馆的小花开发一个点餐程序，要求如下。

比如，如果用户输入 `"1 2 3"`，则 `dishes` 列表将包含 `['1', '2', '3']`。- 如果用户选择了编号为 `1` 的菜品“洋葱炒牛肉”，则创建 `Onion` 和 `Beef` 的实例，并分别设定它们的数量（`num = 1`）。- 创建 `Potato`、`Radish` 和 `Mutoon`（羊肉）的实例，设置它们的数量，并将它们加入订单列表。- `Meet` 和 `Vegetable` 类分别是肉类和蔬菜的基类，派生类如 `Egg`、`Beef` 等具体表示不同的食材。

原创 【Python】类与对象:self在其中的作用，面向对象的优势，函数和方法的区别

总结来说，self 是类内部方法中用来引用实例对象的关键字，方法与函数的主要区别在于方法是绑定到对象的，而函数是独立的；每个类的方法第一个参数通常是 self，它用于引用当前对象本身，这使得我们能够访问类中的属性和其他方法。多态意味着不同类的对象可以通过相同的方法名来调用不同的实现。子类继承父类的方法时，可以通过 self 调用父类的方法，甚至可以在子类中重写父类的方法。调用类中的其他方法：在一个类的内部，self 让你能够调用同一类中的其他方法，例如 self.some_method()。

原创 【Python递归】下面代码利用递归实现将嵌套列表的各个元素进行相加

`i = [4, 5, [6, 7, 8, [9, 10]]]]`，是列表，递归调用 `sumtree([4, 5, [6, 7, 8, [9, 10]]])`- `i = [6, 7, 8, [9, 10]]`，是列表，递归调用 `sumtree([6, 7, 8, [9, 10]])`最终，`sumtree([1, 2, 3, [4, 5, [6, 7, 8, [9, 10]]]])` 返回 `55`。- 遍历列表 `[1, 2, 3, [4, 5, [6, 7, 8, [9, 10]]]]`

原创 【Python 递归函数】下面代码利用递归实现将列表的各个元素进行相加

如果 `x` 是空的，`if not x` 为 `True`，此时返回 0，表示递归的基准情况，即递归结束条件。- 这一行的目标是返回当前列表 `x` 的第一个元素与递归调用 `recsum(x[1:])` 的结果之和。- 对于非空列表，取列表的第一个元素 `x[0]`，然后递归计算剩余元素 `x[1:]` 的和，最后将两者相加。- 代码中的错误主要出在不明的变量 `0`，需要修正为 `x[0]` 以正确访问列表的第一个元素。- 第四次调用：`x = [4]`，返回 `4 + recsum([])`

原创 【Python装饰器】添加一个检测对象类型是否正确的装饰器

使用 `@type_check(int)` 时，`correct_type` 会被赋值为 `int`，因此在调用 `double` 函数时，会检查传入参数的类型是否为 `int`。- `double("2")` 被传入的参数是字符串 `"2"`，类型是 `str`，不符合 `type_check(int)` 的要求。- `inner` 是实际执行类型检查的地方。- `@type_check(str)` 应用于 `upper(s)` 函数，`correct_type` 被赋值为 `str`。

原创 【Python装饰器】编写一个装饰器，并将其放到适当的位置，目的是让代码 1 秒钟打印一个结果

3. 由于 `func` 被 `@delay` 装饰器装饰，每次调用 `f()` 时，都会先执行 `time.sleep(1)`，然后执行 `func()`。- `fib()` 定义了两个局部变量 `back1` 和 `back2`，它们分别表示斐波那契数列的第一个和第二个数字，初始值分别为 `0` 和 `1`。- `get_fib(n)`：调用 `get_fib()` 函数，传入用户输入的 `n`，开始打印前 `n` 个斐波那契数，并在每次输出时延迟 1 秒。

原创 【Python函数】对 LEGB 规则以及 nonlocal 和 global 语法的掌握

如果你在同一个函数中同时使用 `global` 和 `nonlocal` 来声明同一个变量，则会产生 **冲突**，因为它们作用于不同的作用域（`global` 修改全局变量，而 `nonlocal` 修改外层作用域中的变量），这可能导致意外的行为或错误。2. `inner()` 中使用了 `nonlocal x` 来修改 `outer()` 中的 `x`，同时又使用 `global x` 来修改全局变量 `x`。在 innerC() 中，global x 会改变全局变量 x 的值为 520。

原创 【Python函数】设计一个斗地主的发牌程序

`result.append(target.pop(r))`: 从 `target` 列表中移除索引 `r` 的牌，并将这张牌加入 `result` 列表。每轮从洗牌后的 `new_cards` 列表中弹出一张牌，分别发给玩家 `a`、`b` 和 `c`，每个玩家最终将获得17张牌。使用玩家的名称作为键（`a`、`b`、`c`），值是对应玩家的牌列表。- 这部分代码通过 `input()` 函数接收三位玩家的名称，将其分别存储在变量 `a`、`b`、`c` 中，表示游戏的三位玩家。

原创 【Python函数】对函数局部和全局变量的一个实例

因为在函数内部 `x` 的改变只作用于局部变量，外部的 `x` 不受影响，最终 `print(x)` 输出的是原始的列表 `[1, 2, 3]`。- 在这段代码中，`invert(x)` 函数内的 `x[:] = x[::-1]` 会直接修改列表 `x` 的内容。- **第二段代码**：`x[:] = x[::-1]` 通过切片操作修改了原列表的内容，因此外部的 `x` 被修改。- **第一段代码**：`x = x[::-1]` 只是重新赋值了局部变量 `x`，并没有改变原列表。

原创 【Python】编写一个函数，将指定的罗马字符转换为数字的形式。

在最后一句代码 `print(f"转换后的结果是：{v}")` 中，`f` 是**格式化字符串（f-string）**的标志，它是 Python 3.6 引入的一个特性，用于在字符串中直接嵌入表达式的值。2. **`{v}`**：在 `f` 字符串中，`{v}` 会被替换成变量 `v` 的值。在这个例子中，`v` 是由 `roman2num(s)` 函数返回的转换后的数字。- 对于 `'I'`，`v = 1`，并且下一个字符是 `'X'`，由于 `1 < 10`，我们减去 `1`（即 `r -= 1`）。

原创 【Python】利用函数模拟创建【栈】的数据结构操作

栈是一种具有 FILO 特性的数据结构，即先放入的数据反而后取出。）和打印栈的功能分别封装为独立的函数。题目要求：将压栈命令（

原创 【Python】制作函数，并且实现【注册】【登录】功能

1. `bstr = bytes(plaintext, "utf-8")`：将字符串 `plaintext` 转换为字节串（`utf-8` 编码），因为 `hashlib.md5()` 需要字节串作为输入。2. `print("1. 注册")`、`print("2. 登录")`、`print("3. 退出")`：显示可供用户选择的操作菜单。1. `print("=====================")`：打印一行分隔符，增加界面的可读性。= '3':`：当用户选择退出（即指令为 3）时，循环结束。

原创 【离散数学】邻接矩阵的幂乘的定义，分析，并举几个例子

对于一个有 \( n \) 个顶点的图，邻接矩阵 \( A \) 是一个 \( n \times n \) 的矩阵，其中矩阵中的元素 \( A[i][j] \) 表示从顶点 \( i \) 到顶点 \( j \) 的边的权重。这里，\( A^2 \) 的 \( (1, 3) \) 元素是 1，表示顶点 1 可以通过两步到达顶点 3，\( A^2 \) 的 \( (2, 2) \) 元素是 2，表示顶点 2 可以通过两步回到自己（即有两条路径：1 → 2 → 1 和 2 → 3 → 2）。

原创 【离散数学】多重图在无向图和有向图中的表现是否有区别

有向图中，边具有方向性，即从一个节点指向另一个节点。在有向多重图中，除了可以有多个从一个节点指向另一个节点的边之外，也可以允许多个相反方向的边，即同一对节点可以有多个方向的边。- **有向边的多重性**：可以存在多个从节点A指向节点B的边，或者多个从节点B指向节点A的边。- **节点对之间的多重边**：每一对节点之间可以有多条边，表示不同的连接关系。- **自环**：自环是指边连接一个节点自身，在无向多重图中也可以允许多个自环。- **有向多重图**：同一对节点之间允许多条有向边，且可以有不同方向的边。

原创 【离散数学】拉格朗日定理的分析和例子

我们有 ∣H∣=2|H| = 2 和 ∣G∣=6|G| = 6，根据拉格朗日定理，∣G∣=6|G| = 6 应该是 HH 的阶 ∣H∣=2|H| = 2 的倍数，且 [Z6:H]=6/2=3[\mathbb{Z}_6 : H] = 6 / 2 = 3。根据拉格朗日定理，∣S3∣=6|S_3| = 6 应该是 HH 的阶 ∣H∣=2|H| = 2 的倍数，且 [S3:H]=6/2=3[S_3 : H] = 6 / 2 = 3。这些陪集是 GG 中的元素按 HH 的元素构成的不同等价类。

原创 【离散数学】右陪集划分的分析和例子

如果 \( G \) 是一个群，\( H \) 是 \( G \) 的一个子群，那么 \( G \) 的 **右陪集**（right coset）是通过将 \( H \) 的每个元素与 \( G \) 的某个固定元素 \( g \in G \) 相乘来得到的一个集合。假设 \( G = S_3 \)（对称群，包含 3 个元素的排列）和 \( H = \langle (12) \rangle \) 是 \( S_3 \) 的子群。设 \( G \) 为一个群，\( H \) 为 \( G \) 的一个子群。

原创 【离散数学】求左陪集划分的过程和例子分析

左陪集划分是群论中的一个概念，用于研究群的商群结构。它通过对群元素按照左陪集进行分类，帮助我们理解群的分解方式。下面我将简要解释左陪集划分的过程，并给出一个具体例子。### 1. 左陪集划分的基本概念对于一个群 \( G \) 和它的一个子集 \( H \)（通常是一个子群），左陪集是由群 \( G \) 中每个元素与 \( H \) 中的元素通过左乘得到的集合。具体来说，左陪集的定义是：对于群 \( G \) 和子群 \( H \)，任意 \( g \in G \)，左陪集定义为：\[gH

原创 置换的定义：偶置换和奇置换的定义和分析

三次对称群 S3S_3 包含6个元素，其中3个是偶置换（ee, (123)(123), (132)(132)），3个是奇置换（(12)(12), (13)(13), (23)(23)）。这个置换是偶置换，因为它可以表示为两个交换：(12)(23)(12)(23)。(12)∘(13)(12) \circ (13) 先进行 (13)(13) 置换，再进行 (12)(12) 置换。两个交换置换（或叫换位置换） (12)(12), (13)(13), (23)(23)：这些置换交换两个元素的位置。

原创 【离散数学】详细分析一下全序集、良序集、拓扑排序的定义

实数集合 \(\mathbb{R}\) 上的“\(\leq\)”关系：对于任意的两个实数 \(a\) 和 \(b\)，要么 \(a \leq b\)，要么 \(b \leq a\)。- **传递性**：对于任意的元素 \(a\)、\(b\) 和 \(c\)，如果 \(a \leq b\) 且 \(b \leq c\)，则 \(a \leq c\)。- **反对称性**：对于任意的元素 \(a\) 和 \(b\)，如果 \(a \leq b\) 且 \(b \leq a\)，则 \(a = b\)。

原创 【离散数学】关于商集的例题的解析【2】

对于任意的 \( i \neq j \)，如果 \( \langle a_i, a_j \rangle \in R_{ij} \)，那么 \( \langle a_j, a_i \rangle \in R_{ij} \) 也成立，这意味着 \( a_i \) 和 \( a_j \) 互相关联。R_{ij} = I_A \cup \{\langle a_i, a_j \rangle, \langle a_j, a_i \rangle\} \quad \text{(其中 \( i \neq j \))}

原创 【离散数学】集合关于其上等价关系的商集【1】

*问题**：设集合 \( S = \{1, 2, 3, 4, 5\} \)，定义等价关系 \( \sim \)，其规则是两个数 \( x \) 和 \( y \) 在 \( S \) 中等价，当且仅当 \( x \) 和 \( y \) 的差是偶数。**问题**：设集合 \( A = \{1, 2, 3, 4\} \)，定义等价关系 \( \sim \)，其规则是 \( x \sim y \) 当且仅当 \( x \) 和 \( y \) 的差是3的倍数。求商集 \( A / \sim \)。

原创 【离散数学】详细解析模三运算

您的数轴表示也清晰准确。其中，\( a \) 是被除数，\( r \) 是余数，且 \( r \in \{0, 1, 2\} \) 是模3的结果。2. 根据公式：`-4 = 3 × (-2) + r`，得到 `r = -4 - (-6) = -4 + 6 = 2`。2. 根据公式：`-5 = 3 × (-2) + r`，得到 `r = -5 - (-6) = -5 + 6 = 1`。这种方法在模3的情况下是可行的，但需要注意的细节是，计算余数的规则是基于**商的整数部分**，而不仅仅是直接计算。

原创 【离散数学】关系闭包运算的性质

最终的复合闭包（自反-对称-传递闭包）是 R∗={(1,2),(2,3),(2,1),(3,2),(1,1),(2,2),(3,3),(1,3),(3,1)}R^* = \{(1, 2), (2, 3), (2, 1), (3, 2), (1, 1), (2, 2), (3, 3), (1, 3), (3, 1)\}。对于每一对 \( (a, b) \) 和 \( (b, c) \)，如果 \( (a, c) \) 不在关系中，则添加 \( (a, c) \)。

原创 【离散数学】转置矩阵的分析

矩阵 \( A \) 的元素 \( a_{ij} \) 会转置成矩阵 \( A^T \) 中的元素 \( a_{ji} \)，即 \( A^T \) 中的第 \( i \) 行第 \( j \) 列的元素等于矩阵 \( A \) 中的第 \( j \) 行第 \( i \) 列的元素。- 例如，\( A \) 是 \( 2 \times 3 \) 矩阵，转置后的矩阵 \( A^T \) 就是一个 \( 3 \times 2 \) 矩阵。我们来计算它的转置矩阵 \( A^T \)。

原创 【离散数学】复合运算的矩阵表示！！！

原创 【离散数学】关系 传递性

在数学和逻辑中，关系的**传递性**是指一个关系 \( R \) 在某个集合 \( A \) 上，如果对于集合中的任意元素 \( a, b, c \in A \)，当 \( a \) 与 \( b \) 有关系，且 \( b \) 与 \( c \) 也有关系时，必定有 \( a \) 与 \( c \) 有关系。根据传递性，如果 \( A \) 是 \( B \) 的朋友，且 \( B \) 是 \( C \) 的朋友，那么我们可以推断 \( A \) 是 \( C \) 的朋友。假设朋友关系是传递的。

原创 【离散数学】关系的自反关系和反自反关系

2. **反自反性（Irreflexive）**：关系 \( R \) 在集合 \( A \) 上是反自反的，如果对于集合中每个元素 \( a \in A \)，没有 \( (a, a) \in R \)。1. **自反性（Reflexive）**：关系 \( R \) 在集合 \( A \) 上是自反的，如果对于集合中每个元素 \( a \in A \)，都有 \( (a, a) \in R \)。例如，"等于"关系在实数集上是自反的，因为对于任何实数 \( x \)，总有 \( x = x \)。

原创 【离散数学】特殊关系的矩阵表示

单位矩阵是一个方阵（行数和列数相等），它的主对角线元素都是1，其他元素都是0。全0矩阵是指所有元素都是0的矩阵。全1矩阵是指所有元素都是1的矩阵。全0矩阵、全1矩阵和单位矩阵是线性代数中常见的矩阵类型。作为矩阵加法的“极端”之一，全1矩阵有时用于表示一种均匀的常数矩阵。对于矩阵乘法，如果与其他矩阵相乘，结果通常依赖于矩阵的维度和内容。作为乘法的单位元素：任何矩阵与单位矩阵相乘，结果是原矩阵本身。加法恒等元素：任何矩阵加上全0矩阵，结果是原矩阵本身。矩阵乘法时，任何矩阵与全0矩阵相乘，结果是全0矩阵。

原创 【离散数学】笛卡尔积和幂集的区别

笛卡尔积的元素数量是两个集合元素数量的乘积，而幂集的元素数量是集合元素数量的2的幂。笛卡尔积的元素数量是 \(m \times n\)，也就是每个集合的元素数量相乘。笛卡尔积的元素数量为 \(2 \times 2 = 4\)。笛卡尔积的元素数量为 \(3 \times 2 = 6\)。幂集的元素数量是 \(2^m\)，即集合中元素的个数的二次方。#### 例2：集合 \(A = \{1, 2, 3\}\)#### 例1：集合 \(A = \{1, 2\}\)幂集的元素数量为 \(2^2 = 4\)。

原创 离散数学【关系】中的一些特殊关系

如果集合 A={1,2,3}A = \{1, 2, 3\}，那么全域关系 UA={(1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)}U_A = \{(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)\}。如果集合 B={a,b}B = \{a, b\}，恒等关系 IB={(a,a),(b,b)}I_B = \{(a, a), (b, b)\}。

原创 为啥需要MD5加密的时候用str（i）而不是“i”

2. `bytes(str(i), "utf-8")`：将字符串 `"5"` 转换为 UTF-8 编码的字节串（例如 `"5"` 转换成 `b"5"`），这是因为 `hashlib.md5()` 函数要求输入必须是字节串。总结一下：`str(i)` 主要是为了将整数 `i` 转换成字符串，然后再转换为字节串，确保能够传递给 `hashlib.md5()`。1. `str(i)`：将整数 `i` 转换为字符串（例如 `i = 5` 转换成 `"5"`）。为什么不能直接使用 "i"？

原创 既然有了 set() 集合，为什么还要创造 frozenset() 来冻结集合（换句话说，frozenset() 的优势是什么）？

答：这就像既有可变的列表，还是创造了不可变的元组一样，它们各自都有存在的理由。使用冻结的集合，主要也是为了防止内容被肆意修改，起到一个保护的作用。对象，才可以创建嵌套集合（因为集合内部的元素必须是可哈希的）。另外还有重要的一点，就是只有使用。

原创 为什么字典和集合，要比列表更高效

字典和集合高效背后的玄机 缘起 前段时间，小甲鱼在【奇技淫巧】版块中分享了一个小技巧 —— 仅需要简单地添加一行代码，即可将代码的执行效率提高10000倍以上（传送门） 很多鱼油看了答案之后啧啧称奇，因为只是简单地将列表对象转换成集合对象，执行效率立马是天上和地下之别。 为什么列表变成集合之后，效率竟然提高了这么多呢？ 其真相是由于集合的背后是有散列表的支持，而列表却没有！ 所以，列表每次的查找运算都是需要从头到尾进行扫描，而集合则只需要简单地进行查表即可。

原创 如何检测一个集合是否包含另外一个集合呢？

如果要检测一个字符串是否另一个字符串的子字符串，可以使用in运算符，但同样的方式却不适用于集合（如下面代码所示），那么请问应该如何检测一个集合是否包含另外一个集合呢？>>> "FishC" in "FishC.com.cn"True>>> set("FishC") in set("FishC.com.cn")False可以用issubset()方法：ga7s^0`z3WVC;<hA]YPb>eXksrGH(?} -6{&

原创 f(f-string)和format（）函数的相同点和不同点

f`（f-string）和`format()`函数都是用来格式化字符串的工具，但它们的使用方法和特点有所不同。- `f`字符串（f-string）直接在字符串前加上 `f`，并使用大括号 `{}` 包含变量或表达式。- `format()` 是一个方法，调用时需要使用大括号 `{}` 占位，并传入参数来替换这些占位符。1. **都可以在字符串中插入变量**：两者都能够插入变量或表达式，并将其格式化到字符串中。2. **都支持格式化选项**：例如指定数字的精度、对齐方式等。

原创 浅拷贝和深拷贝的逻辑剖析

浅拷贝指的是创建一个新的对象，但是对于对象中包含的可变类型（如列表、字典等），它们的引用不会被复制，而是引用原始对象中的元素。- 使用 `deepcopy()` 后，原始列表 `original` 和拷贝列表 `deep_copy` 中的嵌套对象是完全独立的。- **浅拷贝** `shallow_copy` 是对原始列表 `original` 进行了拷贝，但是嵌套列表（如 `[1, 2, 3]`）仍然是引用相同的对象。- **深拷贝** 会递归地复制所有对象，包括嵌套的可变对象，从而创建完全独立的副本。

原创 创建字典时，键名不能是数字

这段代码也有错误，`dict()` 不支持这种混合语法，即既有字典形式的参数 `{99:"吕布", 90:"关羽"}` 又有关键字参数形式 `60="刘备"`。**错误原因**：关键字参数 `60="刘备"` 不能与字典 `{99:"吕布", 90:"关羽"}` 一起使用。### 4. `d = dict([(99, "吕布"), (90, "关羽"), (60, "刘备")])`### 8. `i = dict(zip([99, 90, 60], ["吕布","关羽","刘备"]))`

原创 空集合和空字典的区别 表示方式不一样

创建空集合的方式是：`set()` （注意：`{}` 是一个空字典的表示方式，而不是空集合）- 空集合通过 `set()` 创建，不能使用 `{}`（因为它会被解释为空字典）。1. **空字典**：字典是一个由键值对组成的无序集合。空字典表示没有任何键值对。2. **空集合**：集合是一个无序、不重复的元素的集合。- 创建空字典的方式是：`{}` 或 `dict()`# 空集合不能用 {} 来创建，因为 {} 是空字典的表示。- 空字典通过 `{}` 或 `dict()` 创建。

原创 Python 实现双重加密（先执行凯撒加密，再执行莫斯加密）

【代码】Python 实现双重加密（先执行凯撒加密，再执行莫斯加密）