小编MSe*_*ert的帖子

PEP 424在“理由”中提到：

能够根据预期大小（由 估计）来预分配列表__length_hint__可能是一项重大优化。据观察，CPython 运行某些代码的速度比 PyPy 更快，这纯粹是因为存在这种优化。

所以我问自己现在在这里问的问题：基于这些知识是否可以加快某些可迭代类处理迭代器的速度（当可以正确预测它的“长度”时）？

sample = {('red', 'blue', 'purple') : 'color', 'redo' : 'again', 'bred' : 'idk', 'greeting' : ('hi', 'hello')}

def search(c):
    if c in sample.keys():
        return sample[c]

print(search('red'))

这返回None. 我知道我可以将它们分开并制作具有相同值的多个键，但如果可以的话，我真的很想避免这样做。我可以吗？

而且我还希望能够搜索值（也可能是元组）并获得相应的键。

我试图找到计算这个双for循环的每次迭代的公式（例如在 python 中）：

for i in range(5):
   for j in range(5):
       count = MYSTERIOUS_FORMULA
       print count

这里 count 的最终值应该是 25。

我试过，count=(i+1)*j但它产生0,1,2,3,4,0,2,4等。

我正在fields使用元类设置类属性：

class MyMeta(type):
    def __new__(mcs, name, bases, clsdict):

        clsdict['fields'] = {k: v
                             for k, v in clsdict.items()
                             if <my_condition>}
        return super(MyMeta, mcs).__new__(mcs, name, bases, clsdict)

class MyBaseClass(metaclass=MyMeta):
    fields = {}

以下实例化导致预期结果：

class SubClass(MyBaseClass):
    param1 = 1 # meets <my_condition>

>>> SubClass.fields
{param1: 1}

但如果我现在子类SubClass,fields是空的：

class SubSubClass(SubClass):
   pass

>>> SubSubClass.fields 
{}

我如何能够更新继承层次结构中所有类的 classdict 以便fields从基类更新变量？

我已经被困在我的代码的一行上了一段时间,我不知道为什么它会像它一样返回.

guess = 'a'
word = ['a', 'b', 'c']
board = ['_', '_', '_']
board = list(map(lambda x: guess if word[board.index(x)] == guess else x, board))

print(board)

这回来了

['a', 'a', 'a']

而我的目标是回归

['a', '_', '_']

我以前的解决方案是循环遍历列表,索引的值越来越大,并根据猜测单独检查单词中的每个条目,并在同一索引处替换单板列表,但我觉得有一个更简洁的pythonic方式使用lambda,我只是不能得到它.

有没有一种方法来检查熊猫数据框中的列的线性相关性？例如：

columns = ['A','B', 'C']
df = pd.DataFrame(columns=columns)
df.A = [0,2,3,4]
df.B = df.A*2
df.C = [8,3,5,4]
print(df)

   A  B  C
0  0  0  8
1  2  4  3
2  3  6  5
3  4  8  4

有没有一种方法可以证明该列B是的线性组合A，但是C是独立的列呢？我的最终目标是对数据集进行泊松回归，但我一直遇到LinAlgError: Singular matrix错误，这意味着我的数据框不存在任何逆，因此它包含相关列。

我想提出一种编程方式来检查每个功能并确保没有相关列。

我有以下数组:

import numpy as np
a = np.array([[2, 3, 5],
              [4, 6, 7],
              [1, 5, 7]])

我想将它扩展到这个数组:

b = [[2 2 2 3 3 3 5 5 5]
     [2 2 2 3 3 3 5 5 5]
     [2 2 2 3 3 3 5 5 5]
     [4 4 4 6 6 6 7 7 7]
     [4 4 4 6 6 6 7 7 7]
     [4 4 4 6 6 6 7 7 7]
     [1 1 1 5 5 5 7 …

演示我所要求的内容的几行代码是：

>>> x = ()
>>> for i in range(1000000):
...     x = (x,)


>>> x.__hash__()

=============================== RESTART: Shell ===============================

1000000 可能过多，但它表明在散列嵌套元组（并且我假设其他对象）时存在某种形式的限制。只是为了澄清，我没有重新启动 shell，当我尝试哈希时它会自动执行此操作。

我想知道这个限制是什么，为什么会发生（以及为什么它没有引发错误），以及是否有解决方法（以便我可以将这样的元组放入集合或字典中）。

我需要查找并计算字符串中可以找到多少个字符.我已将字符分为chars1 [a:m]和chars2 [n:z],并有两个计数器.

输出应为0/14,但它是0/1.我认为它只检查是否包含一个且只有一个项目,然后退出循环.是这样的吗？

这是代码.

string_1 = "aaabbbbhaijjjm"

def error_printer(s):
    chars1 = "abcdefghijklm"
    chars2 = "nopqrstuvwxyz"
    counter1 = 0
    counter2 = 0

    if ((c in s) for c in chars1):
        counter1 += 1
    elif ((c in s) for c in chars2):
        counter2 += 1
    print(str(counter2) + "/" + str(counter1))

error_printer(string_1)

假设我有一个模块，并且我想弃用该模块中的某些内容。这对于函数来说非常简单，本质上这可以使用装饰器来完成：

import warnings

def deprecated(func):
    def old(*args, **kwargs):
        warnings.warn("That has been deprecated, use the new features!", DeprecationWarning)
        return func(*args, **kwargs)
    return old

@deprecated
def func():
    return 10

func()

DeprecationWarning：该功能已被弃用，请使用新功能！

10

但是，如果我想弃用一个不重要的常量，则无法将装饰器应用于变量。我正在玩弄，似乎可以对模块进行子类化并用于__getattribute__发出警告：

我这里使用NumPy只是为了说明原理：

import numpy as np

class MyMod(type(np)):   # I could also subclass "types.ModuleType" instead ...
    def __getattribute__(self, name):
        if name in {'float', 'int', 'bool', 'complex'}:
            warnings.warn("that's deprecated!", DeprecationWarning)
        return object.__getattribute__(self, name)

np.__class__ = MyMod

np.float

弃用警告：已弃用！

漂浮

然而，这似乎不可能从包内完成（至少在顶层），因为我无法访问自己的模块。我必须创建另一个包来对主包进行猴子修补。

有没有更好的方法来“弃用”从包中访问变量，而不是子类化“模块”类和/或使用对另一个包的顶级模块进行猴子修补的元包？