相关疑难解决方法(0)

有没有办法在Python中声明一个常量？在Java中,我们可以用这种方式创建常量值:

public static final String CONST_NAME = "Name";

Python中上述Java常量声明的等价物是什么？

我有一个脚本,需要根据文件创建和修改日期做一些事情,但必须在Linux和Windows上运行.

在Python中获取文件创建和修改日期/时间的最佳跨平台方法是什么？

我发现访问dict密钥更加方便,obj.foo而不是obj['foo'],所以我写了这个代码片段:

class AttributeDict(dict):
    def __getattr__(self, attr):
        return self[attr]
    def __setattr__(self, attr, value):
        self[attr] = value

但是,我认为必须有一些原因,Python不提供开箱即用的功能.以这种方式访问​​dict密钥有什么警告和陷阱？

可能重复:
Python中的"命名元组"是什么？

应该使用namedtuple的情况是什么？

当我查看它时,它看起来像一种让元组更像字典的方法.他们如何与字典相比？

是否只能为字典使用相同的字典类型？

任何人都可以修改namedtuple或提供替代类,以便它适用于可变对象吗？

主要是为了可读性,我想要类似于namedtuple这样做:

from Camelot import namedgroup

Point = namedgroup('Point', ['x', 'y'])
p = Point(0, 0)
p.x = 10

>>> p
Point(x=10, y=0)

>>> p.x *= 10
Point(x=100, y=0)

必须可以腌制生成的对象.并且根据命名元组的特征,当表示时,输出的排序必须与构造对象时参数列表的顺序相匹配.

请考虑以下代码:

from collections import namedtuple
point = namedtuple("Point", ("x:int", "y:int"))

上面的代码只是一种证明我想要实现的目标的方法.我想namedtuple用类型提示.

你知道如何达到预期效果的优雅方式吗？

假设我有一个带有构造函数(或其他函数)的类,它接受可变数量的参数,然后有条件地将它们设置为类属性.

我可以手动设置它们,但似乎变量参数在python中很常见,应该有一个共同的习惯用法.但我不确定如何动态地这样做.

我有一个使用eval的例子,但这几乎不安全.我想知道这样做的正确方法 - 也许是lambda？

class Foo:
    def setAllManually(self, a=None, b=None, c=None):
        if a!=None: 
            self.a = a
        if b!=None:
            self.b = b
        if c!=None:
            self.c = c
    def setAllWithEval(self, **kwargs):
        for key in **kwargs:
            if kwargs[param] != None
                eval("self." + key + "=" + kwargs[param])

我正在优化一些主要瓶颈正在运行的代码并访问一个非常大的类似结构的对象列表.目前我正在使用namedtuples,以提高可读性.但是使用'timeit'的一些快速基准测试表明,在性能是一个因素的情况下,这确实是错误的方法:

用a,b,c命名的元组:

>>> timeit("z = a.c", "from __main__ import a")
0.38655471766332994

使用__slots__a,b,c的类:

>>> timeit("z = b.c", "from __main__ import b")
0.14527461047146062

带键a,b,c的字典:

>>> timeit("z = c['c']", "from __main__ import c")
0.11588272541098377

具有三个值的元组,使用常量键:

>>> timeit("z = d[2]", "from __main__ import d")
0.11106188992948773

使用常量键列出三个值:

>>> timeit("z = e[2]", "from __main__ import e")
0.086038238242508669

具有三个值的元组,使用本地密钥:

>>> timeit("z = d[key]", "from __main__ import d, key")
0.11187358437882722

使用本地密钥列出三个值:

>>> timeit("z = e[key]", "from __main__ import e, key")
0.088604143037173344

首先,这些小timeit测试是否会使它们无效？我跑了几次,以确保没有任何随机系统事件抛出它们,结果几乎相同.

看起来字典在性能和可读性之间提供了最佳平衡,而类别排在第二位.这是不幸的,因为为了我的目的,我还需要对象是序列式的; 因此我选择了namedtuple. …

在Python 3.3中,一个ChainMap类被添加到collections模块中:

提供了一个ChainMap类,用于快速链接多个映射,以便将它们视为一个单元.它通常比创建新字典和运行多个update()调用快得多.

例:

>>> from collections import ChainMap
>>> x = {'a': 1, 'b': 2}
>>> y = {'b': 10, 'c': 11}
>>> z = ChainMap(y, x)
>>> for k, v in z.items():
        print(k, v)
a 1
c 11
b 10

它是由动机这个问题,并通过公开这一个(没有PEP创建).

据我所知,它是一个替代,有一个额外的字典,并用update()s 维护它.

问题是:

• 用例ChainMap包括哪些用例？
• 有真实世界的例子ChainMap吗？
• 它是否用于切换到python3的第三方库？

额外问题:有没有办法在Python2.x上使用它？

我在Transforming Code into Beautiful, Idiomatic PythonRayCon Hettinger的PyCon演讲中听说过它,我想将它添加到我的工具包中,但我不知道何时应该使用它.

最近在我的C肌肉上工作,并查看我一直在使用它的许多图书馆,这当然让我很好地了解了什么是好的做法.我没见过的一件事是一个返回结构的函数:

something_t make_something() { ... }

从我所吸收的,这是"正确"的方式:

something_t *make_something() { ... }
void destroy_something(something_t *object) { ... }

代码片段2中的体系结构比片段1更受欢迎.所以现在我问,为什么我会直接返回一个结构,就像在代码片段1中一样？当我在两种选择中做出选择时,我应该考虑哪些差异？

此外,该选项如何比较？

void make_something(something_t *object)