相关疑难解决方法(0)

我创建了这样的Enum对象:

class Gender(Enum):
    FEMALE = 'female'
    MALE = 'male'
    RANDOM = random.choice([FEMALE, MALE])

我想每次都获得真正的随机值,但它不起作用:

>>> class Gender(Enum):
...    MALE = 'male'
...    FEMALE = 'female'
...    RANDOM = choice([MALE, FEMALE])
... 
>>> Gender.RANDOM
<Gender.MALE: 'male'>
>>> Gender.RANDOM
<Gender.MALE: 'male'>
>>> Gender.RANDOM
<Gender.MALE: 'male'>
>>> Gender.RANDOM
<Gender.MALE: 'male'>

我也试过使用lambda,但看起来不太好,虽然它有效:

Gender.RANDOM()

是否有其他方法可以每次获取随机值,而不使用lambda表达式？

我们使用这个枚举对象作为某个方法的参数的默认值,这就是为什么它应该是属性而不是函数,因为当我们使用Gender.FEMALE它时它不是一个函数,它是一个属性,也Gender.RANDOM应该是一个属性:

def full_name(gender=Gender.FEMALE):
    ...


def full_name(gender=Gender.RANDOM):
    ...

我正在学习Python,同时实现构建脚本等.目前一切都运行良好,因为脚本做了他们需要做的事情.但我一直觉得我错过了一些东西,比如"The Python Way".我知道构建脚本和胶水脚本并不是最令人兴奋的开发工作,可能很难成为揭示Python真正力量的候选者,但我仍然希望有机会让我的思绪受到重创.我主要用C#开发,我发现我的Python代码在结构和样式上看起来与我的很多C#代码非常相似.换句话说,我觉得我在用C#思考,但用Python编写.

我真的错过了什么吗？

(注意:我意识到这不是一个编程问题而且它是相当广泛的,并且可能没有明确的答案,所以如果必须的话,请将其归结为遗忘.)

如何在Python中动态创建对象？我经常想把信息传递给我的Django模板,格式如下:

{'test': [a1, a2, b2], 'test2': 'something else', 'test3': 1}

这使模板看起来不整洁.所以我认为最好只创建一个对象,如:

class testclass():
    self.test = [a1,a2,b2]
    self.test2 = 'someting else'
    self.test3 = 1
testobj = testclass()

所以我可以这样做:

{{ testobj.test }}
{{ testobj.test2 }}
{{ testobj.test3 }}

而不是调用字典.

因为我只需要一次该对象,是否可以在不先写一个类的情况下创建它？有没有简写代码？可以这样做,还是糟糕的Python？

所以我有这个问题,我希望以这种方式得到一个python类的名称:

class TestClass():
    myName = (get class name here automatically)
    saveDirectory = os.path.join(saveDir, myName) # so i can save it in unique location
    def __init__(self):
        pass # do something

但是,似乎__class__.__name__在myName创建时尚未实际存在.所以我被迫将它放入__init__()函数中,如下所示:

class TestClass():
    def __init__(self):
        self.myName = self.__class__.__name__
        saveDirectory = os.path.join(saveDir, self.myName) # so i can save it in unique location
        pass # do something

但是这有一个很大的问题,因为在我实例化类之前我无法得到类的名称,我想为每个要保存在saveDirectory中的类的实例创建几千兆字节的数据,所以它可以重新以后用过.所以我实际上并不想继续使用我目前的解决方案.

反正有没有按照我的意图获得课程名称？还是我只是在做梦？

编辑:

谢谢你们的好建议.我将花一点时间来看看Metaclasses.否则,我可能会全局创建一个字典,而是引用这些实例化的类.

我想创建一个类MyClass,其中bool(MyClass)返回False.可能吗？

我希望这个行为与类本身,而不是该类的对象.对于那个班级的对象,我知道我可以return False进入__bool__(self).

我的proto文件如下：

syntax = "proto3";
option csharp_namespace = "Proto";

message FileListRequest {
    repeated File Files = 1;
}

message File {
    string Path = 1;
}

message ImageFile {
    File File = 1;
    Size Size = 2;
    bytes Content = 3;
}

message Size {
    int32 Width = 1;
    int32 Height = 2;
}

message SendNextFile {
    
}

我用以下命令编译它：

protoc --proto_path=. -I . --python_out=..\..\python\Modules\PreloadingIteratorWrapper\ .\filelist.proto

这将创建以下文件：

# -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler.  DO …

根据Django教程,您应该使用cleaning_data字典访问表单字段.我想知道为什么我不能直接访问表单的属性？我的表单验证很好,但是当我尝试访问它时,Django抱怨该对象没有该属性.我在下面添加了一些代码,希望能帮助诊断问题.

形成:

class CustomForm(forms.Form):
    description = forms.CharField(widget = forms.TextInput(attrs = {'placeholder' : 'enter some text'}), label = "My form")

视图:

def process_form(request):
    if request.method != 'POST':
        raise Http404

    myForm = CustomForm(request.POST)

    if not myForm.is_valid():
        c = RequestContext(request)
        return render_to_response('home/index.html', {'form' : myForm }, c)

    # debug
    print 'Description: ' + myForm.description # this does NOT work
    # print 'Description: ' + myForm.cleaned_data['description'] # this does work

我收到以下错误:'CustomForm'对象没有属性'description'.我是否遗漏了文档中的某些内容,说我不能这样做？

我读过Python中的元类是什么？

我尝试从示例中复制上层元类,发现这在所有情况下都不起作用:

def upper(cls_name, cls_parents, cls_attr):                                     
    """ Make all class attributes uppper case """                               
    attrs = ((name, value) for name, value in cls_attr.items()                  
            if not name.startswith('__'))                                       
    upper_atts = dict((name.upper(), value) for name, value in attrs)           
    return type(cls_name, cls_parents, upper_atts)                              

__metaclass__ = upper #Module level
class Foo:                                                                      
    bar = 1                                                                     
f =  Foo()
print(f.BAR) #works in python2.6

我认为python3中的上述失败(带有属性错误)是很自然的,因为python3中的所有类都已经将对象作为父对象,并且元类解析进入了对象类.

问题:

如何在python3中创建模块级元类？

我有一个对象层次结构,其中几乎所有方法都是类方法.它看起来如下:

class ParentObject(object):
    def __init__(self):
        pass

    @classmethod
    def smile_warmly(cls, the_method):
        def wrapper(kls, *args, **kwargs):
            print "-smile_warmly - "+kls.__name__
            the_method(*args, **kwargs)
        return wrapper

    @classmethod
    def greetings(cls):
        print "greetings"

class SonObject(ParentObject):
    @classmethod
    def hello_son(cls):
        print "hello son"

    @classmethod
    def goodbye(cls):
        print "goodbye son"

class DaughterObject(ParentObject):
    @classmethod
    def hello_daughter(cls):
        print "hello daughter"

    @classmethod
    def goodbye(cls):
        print "goodbye daughter"

if __name__ == '__main__':
    son = SonObject()
    son.greetings()
    son.hello_son()
    son.goodbye()
    daughter = DaughterObject()
    daughter.greetings()
    daughter.hello_daughter()
    daughter.goodbye()

给定的代码输出如下:

greetings
hello son
goodbye son
greetings
hello daughter …

举一个简单的例子,取一个可以返回其属性的class 椭圆,例如面积A,周长C,长轴/短轴a/b,偏心率e等.为了得到它,显然必须提供其两个参数以获得所有其他参数,虽然作为一个特殊情况,只提供一个参数应该假设一个圆圈.三个或更多一致的参数应该产生警告但是有效,否则显然会引发异常.

所以有效Ellipses的一些例子是:

Ellipse(a=5, b=2)
Ellipse(A=3)
Ellipse(a=3, e=.1)
Ellipse(a=3, b=3, A=9*math.pi)  # note the consistency

而无效的将是

Ellipse()
Ellipse(a=3, b=3, A=7)

因此构造函数要么包含许多=None参数,

class Ellipse(object):
    def __init__(self, a=None, b=None, A=None, C=None, ...):

或者,可能更明智,一个简单的**kwargs,可能添加提供a,b作为位置参数的选项,

class Ellipse(object):
    def __init__(self, a=None, b=None, **kwargs):
        kwargs.update({key: value
                       for key, value in (('a', a), ('b', b))
                       if value is not None})

到现在为止还挺好.但现在实际实现,即确定提供哪些参数,哪些参数不是,并根据它们确定所有其他参数,或在需要时检查一致性.

我的第一种方法是许多人的简单而乏味的组合

if 'a' in kwargs:
    a = kwargs['a'] …