我需要在内存中存储大量数字。然后，我需要检查成员身份。数组在存储效率上优于列表。集比成员资格检查列表要好。我都需要！所以我的问题是：
1）数组比集合的内存效率高多少？（相反，请参见下面的结果）。2）是否有数据结构可以在集合和数组之间取得更好的平衡？像带有有符号整数类型的集合？还是一些numpy的构造？
我使用以下脚本检查了成员资格计时差异。（我知道timeit更好，但是方差足够小，可以让时间变好）：
import array
import time
class TimerContext:
def __enter__(self):
self.t0 = time.time()
def __exit__(self, *args, **kwargs):
print(time.time()-self.t0)
SIZE = 1000000
l = list([i for i in range(SIZE)])
a = array.array('I', l)
s = set(l)
print(type(l))
print(type(a))
print(type(s))
with TimerContext():
x = 99999 in l
with TimerContext():
x = 99999 in a
with TimerContext():
x = 99999 in s
结果：
<class 'list'>
<class 'array.array'>
<class 'set'>
0.0012176036834716797
0.0024595260620117188
1.430511474609375e-06
因此，对于成员资格检查，设置集要快得多（请注意科学计数法）。因此，如果它们的内存占用空间与阵列没什么不同，我将更喜欢使用一组。但是我不知道如何检查内存占用量。
我还应该补充一点，比较集合和列表有很多问题。但是我没有比较数组和集合的好答案。
我的目录结构如下：
global_toolkit/
- setup.py
- MANIFEST.in
...
- global_toolkit/
- main.py
- protocol.yaml
...
该软件包使用 pypi-server 托管，然后由使用 pip 的服务安装。protocol.yaml 不在发行版中：
[Errno 2] No such file or directory: '/app/.heroku/python/lib/python3.8/site-packages/global_toolkit/protocol.yaml'
我的 MAINFEST.in （我在不同的教程上看到了不同的格式。我都尝试过......）
include global_toolkit/*.yaml
include *.yaml
recursive-include global_toolkit *
我也尝试过使用 setup.py：
files = ["global_toolkit/*"]
setuptools.setup(
...
packages=['global_toolkit'],
package_data = {'global_toolkit': files},
...
很难弄清楚什么在这里不起作用。帮助表示赞赏。
我想构建一个能够处理的服务：
我对 pre-fork 服务器的理解是会发生以下类似的事情：
我想了解的是，如果在我的 Flask 代码中处理请求时，会发生什么：
from multiprocessing import pool as ProcessPool
with ProcessPool(4) as pool:
pool.map(some_expensive_function, some_data)
特别是：
因此，我经常按照以下模式编写代码：
_list = list(range(10)) # Or whatever
_list = [some_function(x) for x in _list]
_list = [some_other_function(x) for x in _list]
等等
我现在在另一个问题上看到一条评论，它解释了这种方法每次如何创建一个新列表，最好对现有列表进行变异，如下所示：
_list[:] = [some_function(x) for x in _list]
这是我第一次看到此明确建议，我想知道其中的含义是什么：
1）突变是否节省内存？大概是在重新分配后对“旧”列表的引用将降为零，而“旧”列表将被忽略，但是在此之前会有延迟，此时我可能会使用比我使用时所需的更多内存重新分配而不是更改列表？
2）使用变异有计算成本吗？我怀疑就地更改某些内容比创建一个新列表并删除旧列表更昂贵？
在安全性方面，我编写了一个脚本对此进行测试：
def some_function(number: int):
return number*10
def main():
_list1 = list(range(10))
_list2 = list(range(10))
a = _list1
b = _list2
_list1 = [some_function(x) for x in _list1]
_list2[:] = [some_function(x) for x in _list2]
print(f"list a: {a}")
print(f"list b: {b}")
if __name__=="__main__":
main()
哪个输出：
list a: [0, …我有一个对象列表，它们有一个名为 process 的方法。在 Python 2 中可以做到这一点
map(lambda x: x.process, my_object_list)
在 Python 3 中，这将不起作用，因为 map 在遍历迭代之前不会调用该函数。可以这样做：
list(map(lambda x: x.process(), my_object_list))
但是你会用一次性列表浪费内存（如果列表很大，这是一个问题）。我也可以使用 2 行显式循环。但是这种模式对我来说太常见了，我不想或认为我应该每次都写一个循环。
在 Python 3 中是否有更惯用的方法来做到这一点？
我有一个基类，其中有两个派生自它的类。我希望基类的方法的行为有所不同，具体取决于参数是否与派生类具有相同的类型，或者只是基类的实例但类型不同。这是当前的实现：
class MyBase:
def __init__(self, foo: int):
self.foo = foo
def __eq__(self, other):
return self.foo == other.foo
class MyDerived_1(MyBase):
def __init__(self, foo: int, bar: int):
super().__init__(foo)
self.bar = bar
class MyDerived_2(MyBase):
def __init__(self, foo: int, bar: int):
super().__init__(foo)
self.bar = bar
def __eq__(self, other):
if type(other) == type(self):
return self.bar == other.bar
elif isinstance(other, MyBase):
return super().__eq__(other)
else:
return False
在倒数第四行中，我必须明确引用 MyBase。也许这很好，但我的理解是“super”关键字的一个要点是它应该允许您更改基类，而不必重新编写类中的任何内容。因此，该解决方案的一个潜在问题是，如果 MyBase 发生更改，那么init会很好，因为它调用“super”，但eq不会更新其行为。
所以我尝试用“type(super)”或“type(super())”替换“MyBase”，但这些不引用超类，它们引用对象“super”的类。
请注意，此问题不同于：
获取父类名？ 获取Python 3等中未绑定方法对象的定义类。
因为一旦对象被初始化，他们就会寻找父类。
我想我应该能够通过运行 MRO 找到超级类。但这似乎是一个糟糕的解决方案，因为我不是在寻找整个继承树，我只是想知道超类的类型。
有没有办法从“超级”中提取这些信息？
我有一个css文件home_global.css，其中包含以下内容：
body {
background-image: url("{% static 'citator/citator.jpg' %}");
}
使用以下命令加载此静态文件：
<link rel="stylesheet" href="{% static 'citator/home_global.css' %}" type="text/css">
但是，预期的背景图像的URL不会解析，而是按字面解析。我想做的是在css文件中启用Django模板语法。
请注意，静态网址等均已正确设置，此问题不涉及此问题。
这个问题与我一个月前问过的另一个问题非常相似： 如何在静态文件中使用django模板语法
但是，那里提供的答案是特定于javascript的，特别是指出“阻止此情况的基本问题是将上下文传递到视图（或该行为所表现的任何其他函数）中提到的render（）函数中提到的模板同样的方式，例如render_to-response（））。”
如果我正确理解这一点，则此处没有相同的限制。此外，我随后从Django文档中了解到可以在各种文本文档中使用Django模板语法。因此，在我看来，在这种情况下，我想在css文件中使用它，这应该是可能的。那么，我该怎么做呢？
我正在做一个 update_or_create queryset 操作，它在内部使用 get queryset 操作。我已经通读了关于 update_or_create 查询集方法的文档，但是我在理解与外键相关的部分和使用对象作为 kwargs 时遇到了一些困难。
考虑一个例子，我有模型 Book 和 Chapter ，我做这样的事情：
book = Book.objects.get(...)
kwargs = {'book': book, 'name': 'Chapter 3'}
defaults = {'text': '...'}
Chapter.objects.update_or_create(defaults=defaults, **kwargs)
现在 kwargs 将用于 'get' 方法来检查该章节是否存在。但是，既然 book 是一个对象，那么 Django 怎么知道是否有一章“匹配”的书呢？它是否检查 book 对象的所有字段是否匹配？它是否只检查唯一字段？只有书的主键？如果我有两本书具有相同的字段但主键不同，它们可以匹配吗？以这种方式在 kwargs 中使用对象是一种好习惯，还是我会冒着遇到完整性错误问题的风险？谢谢你。
我在 Django 项目中有以下代码（在 Django Rest Framework 序列化器的 create 方法中）
def create(self, validated_data):
<...>
log.info("\n\n\n")
log.info(f"django model: {self.Meta.model}")
log.info("CREATING CASE NOW .....")
case = self.Meta.model(**kwargs)
log.info(f"Case to be saved: {case}")
case.save()
log.info(f"Case object Created: {case}")
当我发布到端点时，它在 .save() 上完全冻结。这是示例输出：
2020-06-15 02:47:46,008 - serializers - INFO ===> django model: <class 'citator.models.InternalCase'>
2020-06-15 02:47:46,008 - serializers - INFO ===> django model: <class 'citator.models.InternalCase'>
2020-06-15 02:47:46,009 - serializers - INFO ===> CREATING CASE NOW .....
2020-06-15 02:47:46,009 - serializers - INFO ===> CREATING CASE NOW …Python 的重新匹配对象在匹配对象上有 .start() 和 .end() 方法。我想找到小组比赛的开始和结束索引。我怎样才能做到这一点？例子：
>>> import re
>>> REGEX = re.compile(r'h(?P<num>[0-9]{3})p')
>>> test = "hello h889p something"
>>> match = REGEX.search(test)
>>> match.group('num')
'889'
>>> match.start()
6
>>> match.end()
11
>>> match.group('num').start() # just trying this. Didn't work
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'start'
>>> REGEX.groupindex
mappingproxy({'num': 1}) # this is the index of the group in the regex, not the index of the group match, …