class-method

protocol NoteProtocol { var body: NSString? { get set } var createdAt: NSDate? { get set } var entityId: NSString? { get set } var modifiedAt: NSDate? { get set } var title: NSString? { get set } // class methods class func insertNewNoteInManagedObjectContext(managedObjectContext: NSManagedObjectContext!) -> NoteProtocol class func noteFromNoteEntity(noteEntity: NSManagedObject) -> NoteProtocol // instance methods func update(#title: String, body: String) func deleteInManagedObjectContext(managedObjectContext: NSManagedObjectContext!) } Hi This is a piece of code I found on GitHub. In this

I have a class as follows: class MyClass(object): int = None def __init__(self, *args, **kwargs): for k, v in kwargs.iteritems(): setattr(self, k, v) def get_params(self): return {'int': random.randint(0, 10)} @classmethod def new(cls): params = cls.get_params() return cls(**params) and I would like to be able to do: >>> obj = MyClass.new() >>> obj.int # must be defined 9 I mean without creating a new instance of MyClass , but obviously it's not that simple, because calling MyClass.new() throws TypeError: unbound method get_params() must be called with MyClass instance as first argument (got

Ex. If I have something like this: class C(object): @classmethod def f(cls, x): return x + x This will work: c = C() c.f(2) 4 But is that bad form? Should I only call C.f() or c.__class__.f() Obviously, this would only make sense in cases where f doesn't interact with self/cls expecting it to be class. ? If you are tempted to call a class method from an instance you probably don't need a class method. In the example you gave a static method would be more appropriate precisely because of your last remark (no self/cls interaction). class C(object): @staticmethod def f(x): return x + x this way

I'd like to do something like this: class SillyWalk(object): @staticmethod def is_silly_enough(walk): return (False, "It's never silly enough") def walk(self, appraisal_method=is_silly_enough): self.do_stuff() (was_good_enough, reason) = appraisal_method(self) if not was_good_enough: self.execute_self_modifying_code(reason) return appraisal_method def do_stuff(self): pass def execute_self_modifying_code(self, problem): from __future__ import deepjuju deepjuju.kiss_booboo_better(self, problem) with the idea being that someone can do >>> silly_walk = SillyWalk() >>> appraise = walk() >>> is_good

The following doesn't work for some reason: >>> class foo(object): ... @property ... @classmethod ... def bar(cls): ... return "asdf" ... >>> foo.bar <property object at 0x1da8d0> >>> foo.bar + '\n' Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unsupported operand type(s) for +: 'property' and 'str' Is there a way to do this, or is my only alternative to resort to some kind of metaclass trickery? If you want the descriptor property to trigger when you get an attribute from object X, then you must put the descriptor in type(X) . So if X is a class, the