小编use*_*ica的帖子

我有一个具有以下结构的Python项目:

testapp/
??? __init__.py
??? api
?   ??? __init__.py
?   ??? utils.py
??? utils.py

所有模块都是空的,除了testapp/api/__init__.py它有以下代码:

from testapp import utils

print "a", utils

from testapp.api.utils import x

print "b", utils

和testapp/api/utils.py其限定x:

x = 1

现在从我导入的根目录testapp.api:

$ export PYTHONPATH=$PYTHONPATH:.
$ python -c "import testapp.api"
a <module 'testapp.utils' from 'testapp/utils.pyc'>
b <module 'testapp.api.utils' from 'testapp/api/utils.pyc'>

导入的结果让我感到惊讶,因为它表明第二个import语句已被覆盖utils.然而,文档声明from语句不会绑定模块名称:

from表单不绑定模块名称:它遍历标识符列表,在步骤(1)中找到的模块中查找每个标识符,并将本地名称空间中的名称绑定到找到的对象.

事实上,当我在终端中使用from ... import ...语句时,不会引入任何模块名称:

>>> from os.path import abspath
>>> …

"学习Python,第四版." 提到:

稍后调用嵌套函数时会查找封闭的范围变量.

但是,我认为当一个函数退出时,它的所有本地引用都会消失.

def makeActions():
    acts = []
    for i in range(5): # Tries to remember each i
        acts.append(lambda x: i ** x) # All remember same last i!
return acts

makeActions()[n]每个人都是一样的,n因为变量i在调用时以某种方式查找.Python如何查找此变量？难道它根本不存在因为makeActions已经退出了吗？为什么Python不执行代码直观建议,并通过在循环运行时用for循环中的当前值替换i来定义每个函数？

从评论到THC4k:
我认为我错误地认为Python在内存中构建函数的方式.我在想,当遇到a makeActions()[n]或者a时n,Python会生成与该函数相关的所有必要的机器指令,并将其保存在内存中的某处.现在我认为它更像是将函数保存为文本字符串(并将其与闭包所需的引用捆绑在一起),并在每次调用函数时重新解析它.

没有参数的raise语句的文档说

如果不存在表达式,则raise会重新引发当前作用域中处于活动状态的最后一个异常.

我曾经认为这意味着当前的函数必须执行一个except子句.在阅读了这个问题并进行了一些实验后,我认为这意味着堆栈上的任何函数都必须执行一个except子句,但我不确定.另外,我已经意识到我不知道堆栈跟踪如何与no-arg raise一起工作:

def f():
  try:
    raise Exception
  except:
    g()

def g():
  raise

f()

产生

Traceback (most recent call last):
  File "foo", line 10, in <module>
    f()
  File "foo", line 5, in f
    g()
  File "foo", line 3, in f
    raise Exception
Exception

这看起来不像初始加注时的堆栈,或者重新加注时的堆栈,或者两个堆栈的串联,或者我能理解的任何东西.

我是否正确寻找执行except子句的堆栈上的任何函数？此外,堆栈跟踪如何在重新加载时起作用？

当我想展开一个列表时,我找到了如下方式:

>>> a = [[1, 2], [3, 4], [5, 6]]
>>> a
[[1, 2], [3, 4], [5, 6]]
>>> sum(a, [])
[1, 2, 3, 4, 5, 6]

我不知道这些行发生了什么,文档说明:

sum(iterable[, start])

资金start和一个项目iterable从左到右,并返回总.start默认为0.iterable的项通常是数字,并且start不允许该值为字符串.

对于某些用例,有很好的替代方案sum().连接字符串序列的首选快速方法是调用 ''.join(sequence).要以扩展精度添加浮点值,请参阅math.fsum().要连接一系列迭代,请考虑使用itertools.chain().

版本2.3中的新功能.

难道你不认为开始应该是一个数字？为什么[]可以写在这里？

(sum(a, []))

这个问题与来自python中的基类的Inherit namedtuple相反,其目的是从namedtuple继承子类,反之亦然.

在正常继承中,这有效:

class Y(object):
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c


class Z(Y):
    def __init__(self, a, b, c, d):
        super(Z, self).__init__(a, b, c)
        self.d = d

[OUT]:

>>> Z(1,2,3,4)
<__main__.Z object at 0x10fcad950>

但如果基类是namedtuple:

from collections import namedtuple

X = namedtuple('X', 'a b c')

class Z(X):
    def __init__(self, a, b, c, d):
        super(Z, self).__init__(a, b, c)
        self.d = d

[OUT]:

>>> Z(1,2,3,4)
Traceback (most recent call …

有人能清楚地解释一下缓存未命中,tlb未命中和页面错误之间的区别,以及它们如何影响有效的内存访问时间？

我们已经知道函数参数曾经有255个显式传递参数的限制.但是,此行为现在已更改,因为Python-3.7没有限制,除了sys.maxsize实际上是python容器的限制.但是局部变量怎么样？

我们基本上不能以动态方式向函数添加局部变量和/或locals()不允许直接更改字典,以便人们甚至可以用暴力方式测试它.但问题是,即使您更改locals()使用compile模块或exec函数它也不会影响function.__code__.co_varnames,因此,您无法在函数内显式访问变量.

In [142]: def bar():
     ...:     exec('k=10')
     ...:     print(f"locals: {locals()}")
     ...:     print(k)
     ...:     g = 100
     ...:     
     ...:     

In [143]: bar()
locals: {'k': 10}
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-143-226d01f48125> in <module>()
----> 1 bar()

<ipython-input-142-69d0ec0a7b24> in bar()
      2     exec('k=10')
      3     print(f"locals: {locals()}")
----> 4     print(k)
      5     g = 100
      6 

NameError: name 'k' is not defined

In [144]: bar.__code__.co_varnames
Out[144]: …

>>> x = numpy.array([[1, 2],
...                  [3, 4],
...                  [5, 6]])
>>> [1, 7] in x
True
>>> [1, 2] in x
True
>>> [1, 6] in x
True
>>> [2, 6] in x
True
>>> [3, 6] in x
True
>>> [2, 3] in x
False
>>> [2, 1] in x
False
>>> [1, 2, 3] in x
False
>>> [1, 3, 5] in x
False

我不知道__contains__ndarrays是如何工作的.我找的时候找不到相关的文档.它是如何工作的？它是否记录在任何地方？

我是Python的初学者.我现在正在尝试弄清楚为什么第二个'for'循环在以下脚本中不起作用.我的意思是我只能得到第一个'for'循环的结果,但没有得到第二个循环的结果.我在下面复制并粘贴了我的脚本和数据csv.

如果你告诉我它为什么会这样,以及如何让第二个'for'循环工作也会很有帮助.

我的脚本:

import csv

file = "data.csv"

fh = open(file, 'rb')
read = csv.DictReader(fh)

for e in read:
    print(e['a'])

for e in read:
    print(e['b'])

"data.csv":

a,b,c
tree,bough,trunk
animal,leg,trunk
fish,fin,body

为了以相同的顺序打乱两个向量，很容易做类似的事情

whatever_rng_type rng2(rng1);

std::shuffle(vec1.begin(), vec1.end(), rng1);
std::shuffle(vec2.begin(), vec2.end(), rng2);

其中相同的 RNG 状态用于两个 shuffle。但是，我没有看到任何要求这些洗牌实际上在我检查的标准草案中产生相同的顺序。

std::shuffle必须使用提供的 RNG 作为其随机源，但实现也可能会执行某些操作，例如为不同的元素大小采用不同的代码路径。也许实现可能会对某些类型使用 AVX512 收集/分散指令，而对其他类型使用通用的非矢量化代码路径，这可能会影响结果排序。

使用相同的种子执行两次洗牌实际上是获得相同订单的安全方法吗？我在以后的标准版本或缺陷报告中遗漏了什么吗？