小编max*_*max的帖子

这两个current_app和g是应用程序上下文变量，所以它们被加载并与每个请求卸载，因此存储在其上的任何数据将只在同一请求中可用。

我可以看到的唯一区别是，g每个请求的开头都是空的，而current_app开头config是从应用程序对象复制的某些属性（例如）。但这根本不能证明拥有g对象，因为可以很容易地在上存储新信息current_app。

我看不到有什么区别？

我正在尝试向MappingPython 3.4 中的子类添加泛型类型注释：

from typing import Mapping, TypeVar, Iterator, Dict

K = TypeVar('K')
V = TypeVar('V')


class M(Mapping[K, V]):
    def __init__(self) -> None:
        self.d = dict()     # type: Dict[K, V]

    def __getitem__(self, item: K) -> V:
        return self.d[item]

    def __len__(self) -> int:
        return len(self.d)

    def __iter__(self) -> Iterator[K]:
        return iter(self.d)


# Also errors, but less
# d = dict()  # type: Mapping[K, V]

我做错了什么，为什么不mypy提供更有用的错误信息？

$ python -V; mypy -V
Python 3.4.3+
mypy 0.470

$ mypy map.py …

状态的 Python 文档asyncio.create_task：

\n

重要提示：保存对此函数结果的引用，以避免任务在执行过程中消失。事件循环仅保留对任务的弱引用。未在其他地方引用的任务可能会随时被垃圾回收，甚至在它完成之前也是如此。对于可靠的 \xe2\x80\x9cfire-and-forget\xe2\x80\x9d 后台任务，请将它们收集在一个集合中：

\n

asyncio在创建的任务完成之前使用弱引用而不是强引用有什么好处？正如上面的警告所表明的那样，保留强引用肯定至少有一个好处——这意味着弱引用可能会带来抵消性的好处。请注意，对于强引用，asyncio完成后可以完全删除引用或切换到弱引用，具体取决于异步逻辑的要求。

文档警告中隐含的用例是：我们不想等待任务（特别是不使用任务的返回值），但我们确实希望给任务一个最终运行的机会。

请注意，asyncio.TaskGroup上下文确实保留了对其创建的任务的强引用。但是，它不适合上述用例，因为退出时，上下文会阻塞（它等待所有任务完成）。（此外，即使任务完成后，它也会保留对任务的强引用，因此如果上下文的生存时间比任务长得多，则会导致内存泄漏。）

对于Python中的某些类型,is运算符似乎等同于==运算符.例如:

>>> 1 is 1
True
>>> "a spoon" is "a spoon"
True
>>> (1 == 1) is (2 == 2)
True

然而,这并非总是如此:

>>> [] == []
True
>>> [] is []
False

这对于诸如列表之类的可变类型是有意义的.但是,诸如元组之类的不可变类型似乎显示相同的行为:

>>> (1, 2) == (1, 2)
True
>>> (1, 2) is (1, 2)
False

这提出了几个问题:

1. 是==/ is相关不变性等价？
2. 上面列出的行为或实现细节是？
3. 最重要的(并且基本上),我如何知道作业是否会导致正在制作的对象的副本,或者对它的引用？

更新:如果总是通过引用分配,为什么不打印以下内容2？:

>>> a = 1
>>> b = a
>>> a = 2
>>> b
1 …

我有一个知道其现有实例的类。有时我希望类构造函数返回一个现有对象而不是创建一个新对象。

class X:
    def __new__(cls, arg):
        i = f(arg)
        if i:
            return X._registry[i]
        else:
            return object.__new__(cls)
    # more stuff here (such as __init_, _registry, etc.)

当然，如果第一个分支被执行，我不需要__init__，但它无论如何都会被调用。告诉__init__什么都不做的好方法是什么？

我可能只是添加一些属性来跟踪是否__init__已运行，但也许有更好的方法？

(在Python 3中)

我有字典old.我需要改变它的一些键; 需要更改的键和相应的新键存储在字典中change.有什么好办法吗？请注意,old.keys()和之间可能存在重叠change.values(),这需要我谨慎应用更改.

以下代码(我认为)可以工作,但我希望有更简洁但更好的Pythonic:

new = {}
for k, v in old.items():
  if k in change:
    k = change[k]
  new[k] = v
old = new

我有一个datetime对象.我想打印它只是秒数(即1分30.5秒打印为90.5秒).似乎无法找到一种方法来做到这一点strftime.

我有两个功能,f和g.两者都有相同的签名:(x).我想创建一个z具有相同签名的新函数:

def z(x):
  return f(x) * g(x)

除了我想能写

z = f * g而不是上面的代码.可能吗？

我想将数字格式化为百分比,小数点后至少2位数; 此外,至少有一个有效数字.

例如,我希望0.123456看起来像'12 .34%'; 和0.00000123456看起来像'0.0001%'.

有没有一种简单的方法来实现这一目标？

原因是我的标准输出应该是一个固定的点数,后面有2位小数; 但如果数字很小,看起来像0.00%,我需要显示至少一个有效数字,以便它可以区别于真0.

我有一个类,其实例需要按照用户的指示格式化输出.有一种默认格式,可以覆盖.我这样实现了:

class A:
  def __init__(self, params):
    # ...
    # by default printing all float values as percentages with 2 decimals
    self.format_functions = {float: lambda x : '{:.2%}'.format(x)}
  def __str__(self):
    # uses self.format_functions to format output
    # ...

a = A(params)
print(a) # uses default output formatting

# overriding default output formatting
# float printed as percentages 3 decimal digits; bool printed as Y / N
a.format_functions = {float : lambda x: '{:.3%}'.format(x),
                      bool : lambda x: 'Y' if x else …