小编max*_*max的帖子

是否有任何习惯用于从字典中获取任意键,值对而不删除它们？(P3K)

编辑:

抱歉这个令人困惑的措辞.

在某种意义上我使用了任意一词,我不关心我得到的东西.

它与随机不同,我关心的是我得到的东西(即,我需要选择每个项目的概率相同).

我没有钥匙可以使用; 如果我这样做,我认为它将属于RTFM类别,并且不值得回答SO.

编辑:

不幸的是在P3K中,.items()返回一个dict_items对象,不像Python 2返回了一个迭代器:

ActivePython 3.1.2.4 (ActiveState Software Inc.) based on
Python 3.1.2 (r312:79147, Sep 14 2010, 22:00:46) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> d = {1:2}
>>> k,v = next(d.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: dict_items object is not an iterator

我正在运行ActiveState Python 3.2,并得到这个神秘的错误:

D:\code>python
ActivePython 3.2.1.2 (ActiveState Software Inc.) based on
Python 3.2.1 (default, Jul 18 2011, 14:31:09) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import numpy as np
>>> x = np.array([[1, 1], [2, 1], [3, 1]])
>>> y = np.array([3, 4, 5])
>>> be = np.linalg.lstsq(x,y)

MKL ERROR: Parameter 5 was incorrect on entry to DGELSD

MKL ERROR: Parameter 5 was incorrect on entry to DGELSD
>>>

有谁知道可能会发生什么？

在Python 3中,如何检查对象是否是容器(而不是只允许一次传递的迭代器)？

这是一个例子:

def renormalize(cont):
    '''
    each value from the original container is scaled by the same factor
    such that their total becomes 1.0
    '''
    total = sum(cont)
    for v in cont:
        yield v/total

list(renormalize(range(5))) # [0.0, 0.1, 0.2, 0.3, 0.4]
list(renormalize(k for k in range(5))) # [] - a bug!

显然,当renormalize函数接收到生成器表达式时,它不能按预期工作.它假设它可以多次遍历容器,而生成器只允许一次通过它.

理想情况下,我想这样做:

def renormalize(cont):
    if not is_container(cont):
      raise ContainerExpectedException
    # ...

我该如何实施is_container？

我想我可以检查参数是否为空,因为我们正在开始第二次通过它.但是这种方法不适用于更复杂的功能,在第二次传递开始的时候并不明显.此外,我宁愿将验证放在函数入口处,而不是放在函数内部(并在修改函数时将其移动).

我当然可以renormalize使用一次通过迭代器重写函数以正常工作.但这需要将输入数据复制到容器中.复制数以百万计的大型列表"以防它们不是列表"的性能影响是荒谬的.

编辑:我的原始示例使用了一个weighted_average函数:

def weighted_average(c):
    '''
    returns weighted average …

当我替换这段代码时,我认为我提高了性能:

def f(a, b):
  return math.sqrt(a) * b
result = []
a = 100
for b in range(1000000):
  result.append(f(a, b))

有:

def g(a):
  def f(b):
    return math.sqrt(a) * b
  return f
result = []
a = 100
func = g(a)
for b in range(1000000):
  result.append(func(b))

我假设自从a在执行闭包时修复,解释器将预先计算所涉及的所有内容,a因此math.sqrt(a)将重复一次而不是1000000次.

根据实施情况,我的理解总是正确的,或总是不正确,或正确/不正确？

我注意到代码对象func是在运行时之前构建的(至少在CPython中),并且是不可变的.然后代码对象似乎使用全局环境来实现闭包.这似乎表明我希望的优化不会发生.

docs(python 3.4)解释说spawn,"子进程只会继承运行进程对象run()方法所需的那些资源".

但哪些对象是"必要的"？我读它的方式告诉我,从内部可以到达的所有对象run()都是"必要的",包括传递args给的参数Process.__init__,加上存储在全局变量中的任何东西,以及在全局范围内定义的类,函数及其属性.但是,这是不正确的; 以下代码确认不会继承存储在全局变量中的对象:

# running under python 3.4 / Windows
# but behaves the same under Unix
import multiprocessing as mp

x = 0
class A:
    y = 0

def f():
    print(x) # 0
    print(A.y) # 0

def g(x, A):
    print(x) # 1
    print(A.y) # 0; really, not even args are inherited?

def main():
    global x
    x = 1
    A.y = 1
    p = mp.Process(target = f)
    p.start()
    q …

我正在阅读输入模块代码,并查看mypy以了解它是如何进行类型检查的.对我来说不幸的是,mypy构建一个非常智能的树,其中包含我仍然不理解的类型表达式,并且它都基于静态分析.

我想在Python中实现一个动态(无静态分析)的类型检查系统.假设调用执行类型检查的函数check_type,我想完成以下操作:

>>> import typing
>>>
>>> check_type(1, int)
True
>>> check_type(1, float)
False
>>> check_type([1], typing.List[int])
True
>>> check_type([1], typing.List[float])
False
>>> check_type([1], typing.List[typing.Any])
True
>>> check_type((1,), typing.Tuple[int])
True

我考虑过从其值重新创建对象类型,例如:

>>> get_type([1])
typing.List<~T>[int]

但这不适用于issubclass:

>>> issubclass(typing.List[int], typing.List[typing.Any])
False

我没有看到在Python中检查类型的简单方法,而没有假设很多关于stdlib模块内部的typing东西(例如,访问__args__或__tuple_params__).

如何正确实现check_type适用于之前列出的案例的功能？我使用的是Python 2.7.

在Windows 10 Build 14393下使用Docker 1.13.0(9795)时,我试图运行最新的python图像(这将是3.6)时"设备上没有剩余空间":

> docker run -it python
Unable to find image 'python:latest' locally
latest: Pulling from library/python
5040bd298390: Pull complete
fce5728aad85: Pull complete
76610ec20bf5: Pull complete
52f3db4b5710: Extracting [==================================================>] 129.8 MB/129.8 MB
45b2a7e03e44: Download complete
75ef15b2048b: Download complete
e41da2f0bac3: Download complete
C:\Program Files\Docker\Docker\Resources\bin\docker.exe: failed to register layer: Error processing tar file(exit status
 1): write /usr/share/doc/libfreetype6/reference/ft2-type1_tables.html: no space left on device.
See 'C:\Program Files\Docker\Docker\Resources\bin\docker.exe run --help'.

硬盘驱动器上有超过20 GB的可用空间,因此我认为问题出在Docker的虚拟机中.如何访问它以调查磁盘使用情况并在需要时进行清理？

docker images并docker ps -a没有发现任何大的东西:

> docker images …

我注意到一个小的重构产生了一个奇怪的性能损失,它通过max在递归函数内调用内置函数来替换一个循环.

这是我可以制作的最简单的复制品:

import time

def f1(n):
    if n <= 1:
        return 1
    best = 0
    for k in (1, 2):
        current = f1(n-k)*n
        if current > best:
            best = current
    return best

def f2(n):
    if n <= 1:
        return 1
    return max(f2(n-k)*n for k in (1, 2))


t = time.perf_counter()
result1 = f1(30)
print('loop:', time.perf_counter() - t) # 0.45 sec

t = time.perf_counter()
result2 = f2(30)
print('max:', time.perf_counter() - t) # 1.02 sec

assert result1 == result2

两者 …

我需要一个样本,无需替换,来自所有可能的数字元组range(n).也就是说,我有一个(0,0),(0,1),...,(0,n),(1,0),(1,1),...,(1,n)的集合),...,(n,0),(n,1),(n,n),我试图得到这些元素的k个样本.我希望避免明确构建此集合.

我知道random.sample(range(n), k)如果我需要一系列数字而不是数字元组的样本,那么它是简单而有效的.

当然,我可以显式构建包含所有可能(n * n = n^2)元组的列表,然后调用random.sample.但如果k比小得多,那可能效率不高n^2.

我不确定Python 2和3中的效率是否与效率相同; 我使用Python 3.

我需要确保程序中的所有随机性都是完全可复制的.我应该在哪里拨打random.seed()？

我认为它应该在我的main.py模块中,但它会导入其他碰巧使用随机函数的模块.

我可以仔细浏览我的导入,看看哪一个是第一个执行,但是当我改变我的代码结构时,我将不得不记得再次重做这个分析.

有没有简单安全的解决方案？