当前位置：首页 > news >正文

学习日志25 python

news 2025/8/4 9:51:04

1 Python 2 和 3 除法区别

Python 2 和 Python 3 在除法运算上的区别主要体现在 / 运算符的行为上，这是两个版本之间一个重要的语法差异，具体区别如下：

/ 运算符的行为
- Python 2：
  - 当两个操作数都是整数时，/ 执行整数除法（地板除），结果会向下取整为整数。
  - 例如：5 / 2 = 2，9 / 4 = 2，10 / 3 = 3
  - 如果至少有一个操作数是浮点数，/ 会返回浮点数结果。
  - 例如：5.0 / 2 = 2.5，9 / 4.0 = 2.25
- Python 3：
  - 无论操作数是整数还是浮点数，/ 始终执行真除法，结果为浮点数。
  - 例如：5 / 2 = 2.5，9 / 4 = 2.25，10 / 3 = 3.333...
// 运算符（地板除）
- 两个版本中，// 的行为一致，均执行地板除（向下取整），结果的类型取决于操作数：
- 若操作数都是整数，结果为整数；若有浮点数，结果为浮点数。
- 例如：
  - Python 2 和 Python 3 中均有：5 // 2 = 2，9 // 4 = 2，5.0 // 2 = 2.0

总结来说，核心差异就是 \ 运算符在处理整数除法时的行为：Python 2 中整数相除会截断为整数，而 Python 3 中整数相除也会返回浮点数。如果需要在两个版本中都实现地板除功能，使用 // 是统一的方式。

这个区别在代码迁移或跨版本兼容时需要特别注意，避免因除法行为不同导致计算错误。

2 Python 中字符串的`find()`方法的用法

在Python3中关于下列字符串程序运行结果为（ ）
str1 = "exam is a example!" 
str2 = "exam" 
print(str1.find(str2, 7))A -1
B 14
C 0
D 10正确答案：D

这道题考查的是 Python 中字符串的find()方法的用法，我们一步步来分析：

1. 先明确`find()`方法的作用

str.find(sub, start) 表示：在字符串 str 中，从 start 索引位置开始（包含该位置），查找子字符串 sub 第一次出现的起始索引。

如果找到，返回对应的索引值；
如果没找到，返回 -1。

2. 分析题目中的变量

str1 = "exam is a example!"（字符串内容）
str2 = "exam"（要查找的子字符串）
要执行的操作：str1.find(str2, 7)，即从 str1 的索引 7 位置开始，查找 str2 第一次出现的位置。

3. 拆解`str1`的索引（关键！）

字符串的索引从 0 开始，我们逐个标记 str1 的每个字符及其索引：

字符	e	x	a	m	空格	i	s	空格	a	空格	e	x	a	m	p	l	e	!
索引	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17

4. 执行查找过程

str1.find(str2, 7) 的含义是：从索引 7 开始，找 sub="exam" 第一次出现的位置。

索引 7 对应的字符是空格，从这里往后看：
索引 10 开始的字符是 e，后续依次是 x（11）、a（12）、m（13），刚好组成 sub="exam"。

因此，"exam" 从索引 10 开始出现，所以返回 10。

答案总结

正确答案是 D。

3 有关闭包的陷阱的题目

执行下列程序，输出结果为（）def fn():t = []i = 0while i < 2:t.append(lambda x: print(i*x,end=","))i += 1return t
for f in fn():f(2)A 4,4,
B 2,2,
C 0,1,
D 0,2,正确答案：A

让我们详细分析这个程序的执行过程和结果。

首先，我们来看这个程序的结构：

定义了一个函数fn()，它会创建一个列表t并返回
在fn()中，通过while循环向列表t中添加两个 lambda 函数
最后通过for循环调用这两个函数，传入参数2

关键在于理解 lambda 函数和变量作用域的关系。

当我们在循环中执行t.append(lambda x: print(i*x,end=","))时，lambda 函数并没有立即时执行，它只是被创建并添加到列表中。这个 lambda 函数引用了变量i，但这里需要注意：lambda 函数捕获的是变量i本身，而不是它在定义时的值。

循环执行过程：

第一次循环：i=0，添加一个 lambda 函数到 t 中，此时这个函数引用的是变量 i
i 变为 1
第二次循环：i=1，再添加一个 lambda 函数到 t 中，这个函数也引用变量 i
i 变为 2，循环结束

此时，列表 t 中有两个 lambda 函数，它们都引用着同一个变量 i，而此时 i 的值已经是 2（因为循环结束条件是 i<2）。

当我们执行for f in fn(): f(2)时：

第一个函数调用：计算 i*2，此时 i=2，结果为 4
第二个函数调用：同样计算 i*2，i 仍然是 2，结果为 4

所以最终的输出结果是：4,4,

这个例子展示了 Python 中闭包（closure）的一个常见陷阱：内部函数引用外部变量时，捕获的是变量本身，而不是变量在定义时的值。如果想要捕获变量在定义时的值，需要将其作为参数传入 lambda 函数，例如：

python

运行

t.append(lambda x, i=i: print(i*x, end=","))

这样修改后，输出结果才会是0,2,。

4 Python 中闭包（closure）与变量作用域

缺少对 Python 中闭包（closure）与变量作用域 的理解，尤其是 函数对外部变量的延迟绑定 这一特性。具体来说，你可能需要补充以下知识点：

1. 闭包与变量的引用方式

闭包指的是 “嵌套在函数内部的函数，引用了外部函数的变量”。

在这个题目中：

lambda x: print(i*x, end=",") 是一个闭包，它引用了外部函数 fn() 中的变量 i。
关键误区：闭包 不会保存变量在定义时的值，而是 保存对变量本身的引用。也就是说，lambda 函数记住的是 “i 这个变量”，而**不是**它在循环中每次的具体值（0 或 1）。