张问德,faopmt,回到古代做医仙
1.
1 array = [1, 8, 15] 2 g = (x for x in array if array.count(x) > 0) 3 array = [2, 8, 22]
output:
1 >>> print(list(g)) 2 [8]
2.
1 array_1 = [1,2,3,4] 2 g1 = (x for x in array_1) 3 array_1 = [1,2,3,4,5] 4 5 array_2 = [1,2,3,4] 6 g2 = (x for x in array_2) 7 array_2[:] = [1,2,3,4,5]
output:
1 >>> print(list(g1)) 2 [1,2,3,4] 3 4 >>> print(list(g2)) 5 [1,2,3,4,5]
在生成器表达式中, in
子句在声明时执行, 而条件子句则是在运行时执行.
所以在运行前, array
已经被重新赋值为 [2, 8, 22]
, 因此对于之前的 1
, 8
和 15
, 只有 count(8)
的结果是大于 0
的, 所以生成器只会生成 8
.
第二部分中 g1
和 g2
的输出差异则是由于变量 array_1
和 array_2
被重新赋值的方式导致的.
在第一种情况下, array_1
被绑定到新对象 [1,2,3,4,5]
, 因为 in
子句是在声明时被执行的, 所以它仍然引用旧对象 [1,2,3,4]
(并没有被销毁).
在第二种情况下, 对 array_2
的切片赋值将相同的旧对象 [1,2,3,4]
原地更新为 [1,2,3,4,5]
. 因此 g2
和 array_2
仍然引用同一个对象(这个对象现在已经更新为 [1,2,3,4,5]
).
下面是一个在互联网上非常有名的例子.
1 >>> a = 256 2 >>> b = 256 3 >>> a is b 4 true 5 6 >>> a = 257 7 >>> b = 257 8 >>> a is b 9 false 10 11 >>> a = 257; b = 257 12 >>> a is b 13 true
is
和 ==
的区别
is
运算符检查两个运算对象是否引用自同一对象 (即, 它检查两个运算对象是否相同).
==
运算符比较两个运算对象的值是否相等.
因此 is
代表引用相同, ==
代表值相等. 下面的例子可以很好的说明这点,
1 >>> [] == [] 2 true 3 >>> [] is [] # 这两个空列表位于不同的内存地址. 4 false
256
是一个已经存在的对象, 而 257
不是
当你启动python 的时候, 数值为 -5
到 256
的对象就已经被分配好了. 这些数字因为经常被使用, 所以会被提前准备好.
python 通过这种创建小整数池的方式来避免小整数频繁的申请和销毁内存空间.
当前的实现为-5到256之间的所有整数保留一个整数对象数组, 当你创建了一个该范围内的整数时, 你只需要返回现有对象的引用. 所以改变1的值是有可能的. 我怀疑这种行为在python中是未定义行为. :-)
1 >>> id(256) 2 10922528 3 >>> a = 256 4 >>> b = 256 5 >>> id(a) 6 10922528 7 >>> id(b) 8 10922528 9 >>> id(257) 10 140084850247312 11 >>> x = 257 12 >>> y = 257 13 >>> id(x) 14 140084850247440 15 >>> id(y) 16 140084850247344
这里解释器并没有智能到能在执行 y = 257
时意识到我们已经创建了一个整数 257
, 所以它在内存中又新建了另一个对象.
当 a
和 b
在同一行中使用相同的值初始化时,会指向同一个对象.
1 >>> a, b = 257, 257 2 >>> id(a) 3 140640774013296 4 >>> id(b) 5 140640774013296 6 >>> a = 257 7 >>> b = 257 8 >>> id(a) 9 140640774013392 10 >>> id(b) 11 140640774013488
当 a 和 b 在同一行中被设置为 257
时, python 解释器会创建一个新对象, 然后同时引用第二个变量. 如果你在不同的行上进行, 它就不会 "知道" 已经存在一个 257
对象了.
这是一种特别为交互式环境做的编译器优化. 当你在实时解释器中输入两行的时候, 他们会单独编译, 因此也会单独进行优化. 如果你在 .py
文件中尝试这个例子, 则不会看到相同的行为, 因为文件是一次性编译的.
1 # 我们先初始化一个变量row 2 row = [""]*3 #row i['', '', ''] 3 # 并创建一个变量board 4 board = [row]*3
output:
1 >>> board 2 [['', '', ''], ['', '', ''], ['', '', '']] 3 >>> board[0] 4 ['', '', ''] 5 >>> board[0][0] 6 '' 7 >>> board[0][0] = "x" 8 >>> board 9 [['x', '', ''], ['x', '', ''], ['x', '', '']]
我们有没有赋值过3个 "x" 呢?
当我们初始化 row
变量时, 下面这张图展示了内存中的情况。
而当通过对 row
做乘法来初始化 board
时, 内存中的情况则如下图所示 (每个元素 board[0]
, board[1]
和 board[2]
都和 row
一样引用了同一列表.)
我们可以通过不使用变量 row
生成 board
来避免这种情况. (这个issue提出了这个需求.)
1 >>> board = [['']*3 for _ in range(3)] 2 >>> board[0][0] = "x" 3 >>> board 4 [['x', '', ''], ['', '', ''], ['', '', '']]
1 #python学习群592539176 2 funcs = [] 3 results = [] 4 for x in range(7): 5 def some_func(): 6 return x 7 funcs.append(some_func) 8 results.append(some_func()) # 注意这里函数被执行了 9 10 funcs_results = [func() for func in funcs]
output:
1 >>> results 2 [0, 1, 2, 3, 4, 5, 6] 3 >>> funcs_results 4 [6, 6, 6, 6, 6, 6, 6]
即使每次在迭代中将 some_func
加入 funcs
前的 x
值都不相同, 所有的函数还是都返回6.
再换个例子
1 >>> powers_of_x = [lambda x: x**i for i in range(10)] 2 >>> [f(2) for f in powers_of_x] 3 [512, 512, 512, 512, 512, 512, 512, 512, 512, 512]
当在循环内部定义一个函数时, 如果该函数在其主体中使用了循环变量, 则闭包函数将与循环变量绑定, 而不是它的值. 因此, 所有的函数都是使用最后分配给变量的值来进行计算的.
可以通过将循环变量作为命名变量传递给函数来获得预期的结果. 为什么这样可行? 因为这会在函数内再次定义一个局部变量.
1 #python学习群592539176 2 funcs = [] 3 for x in range(7): 4 def some_func(x=x): 5 return x 6 funcs.append(some_func)
output:
1 >>> funcs_results = [func() for func in funcs] 2 >>> funcs_results 3 [0, 1, 2, 3, 4, 5, 6]
如对本文有疑问,请在下面进行留言讨论,广大热心网友会与你互动!! 点击进行留言回复
新手学习Python2和Python3中print不同的用法
Python基于os.environ从windows获取环境变量
网友评论