Das deutsche Python-Forum

Code: Alles auswählen

klass.header   - damit greife ich direkt auf self.header zu (auch komisch, daß ich von draußen drauf zugreifen kann, aber gut
                      Python hat keine private members.

klass.header() - ist der Methodenaufruf. Was wäre daran verboten?

Code: Alles auswählen

>>> class Spam(object):
...     def ham(self, x):
...         print x
... 
>>> s = Spam()
>>> h = s.ham
>>> h(42)
42
>>> h.__call__(42)
42

Code: Alles auswählen

>>> class Spam(object):
...     def __init__(self):
...         self.ham = None
... 
>>> def egg(x):
...     print x
... 
>>> spam = Spam()
>>> spam.ham = egg
>>> spam.ham(42)
42
>>> 

Code: Alles auswählen

>>> class A(object):
...     b = 42
...     def c(self):
...             pass
... 
>>> a = A()
>>> type(a.b)
<type 'int'>
>>> type(a.c)
<type 'instancemethod'>

Code: Alles auswählen

class Foo:

    def __init__(self):
        self.a = 42

    def b(self):
        return 17


foo=Foo()

for name in 'a', 'b':
    attr = getattr(foo, name)
    
    if callable(attr):
        value = attr()
    else:
        value = attr
        
    print('%s: %s' % (name, value))
        

Code: Alles auswählen

class Nonsense(object):
    def __init__(self):
        self._multiple = ('any_value', self.any_callable)

    def any_callable(self, value):
        pass

    @property
    def multiple(self):
        request_has_brackets, value = interpreter.please_give_it_to_me()
        if request_has_brackets:
            return self._multiple[1](value)
        return self._multiple[0]

Code: Alles auswählen

import sys
import dis
import inspect


NO_ATTRIBUTE = object()


class SeparateNamedspacedMeta(type):
    def __new__(cls, name, bases, attributes):
        _methods = {}
        for name, attribute in attributes.iteritems():
            if name.startswith('__') and name.endswith('__'):
                continue
            if inspect.isfunction(attribute):
                _methods[name] = attribute
                attributes[name] = AttributeOrMethodDescriptor(name)
        attributes['_methods'] = _methods
        return type.__new__(cls, name, bases, attributes)


class AttributeOrMethodDescriptor(object):
    def __init__(self, name):
        self.name = name
        self.attribute_value = NO_ATTRIBUTE

    def __get__(self, instance, owner):
        if instance is None or self.attribute_value is NO_ATTRIBUTE:
            return owner._methods[self.name].__get__(instance, owner)
        calling_frame = sys._getframe(1)
        next_opcode = ord(calling_frame.f_code.co_code[calling_frame.f_lasti + 3])
        if dis.opname[next_opcode] == 'CALL_FUNCTION':
            return owner._methods[self.name].__get__(instance, owner)
        return self.attribute_value

    def __set__(self, instance, value):
        self.attribute_value = value

    def __delete__(self, instance):
        self.attribute_value = NO_ATTRIBUTE


class SeparateNamespacedClass(object):
    __metaclass__ = SeparateNamedspacedMeta

    def __init__(self):
        self.spam = 'attribute'

    def spam(self):
        return 'method'


foo = SeparateNamespacedClass()
print SeparateNamespacedClass.spam # <unbound method spam.spam>
print foo.spam # attribute
print foo.spam() # method