Besitzen str-Objekte ein Attribut 'auf sich selbst'?

[mutetella]

Hallo,

ich verwende eine Funktion, die aus Exemplaren über deren Attribute str-Objekte erhält und diese weiterverarbeitet. Zwischen diese strings wird jeweils ein weiterer string (filler) eingefügt. Der Aufruf der Funktion sieht folgendermaßen aus:

Code: Alles auswählen

region(((exemplar, 'attr-name'), (exemplar, 'attr-name'), ...), filler)
    ...

Nachdem ich nicht mit den strings direkt, sondern mit 'getattr(exemplar, 'attr-name')' arbeiten möchte, suche ich der Einfachheit wegen nach einer Möglichkeit, den string 'filler' ebenfalls mit 'getattr' abzuholen. So in der Art 'getattr(filler, 'self')' ... Quasi '__repr__' als Attribut ohne " ".

Gruß
mutetella

[snafu]

Ich weiß nicht, ob ich der einzige bin, aber ich verstehe hier nicht so ganz, was du meinst. Was genau macht dieser Filter und was macht ``region()``? Zum "Attribut auf sich selbst" hätte ich dir jetzt ``self`` geantwortet, aber das ist dir ja anscheinend schon bekannt. Von daher ist mir auch hier nicht klar, worauf du dich genau beziehst.

Quasi '__repr__' als Attribut ohne " ".

Suchst du vielleicht ``str(filler)``?

[BlackJack]

@mutetella: Die Antwort ist nein.

@snafu: Die Frage ist ob bei ``a = "foo"`` jetzt ein Attribut auf `a` existiert was wieder das Objekt selbst liefert. Wo also ``a.gesuchtes_attribut is a`` gilt. Weil man dann in dem Beispiel einfach ``(filler, 'gesuchtes_attribut')`` in die Liste schreiben könnte und das `filler`-Objekt genau so behandeln kann wie die anderen Exemplare in der Liste. Nämlich mit `getattr` das Attribut lesen und eine Zeichenkette dabei erhalten.

[deets]

@mutetella

Ich wuerde zu einem Dekorator-Muster raten. Also zb ein Bunch-Objekt, mit dem du den Filler kapselst. So etwa:

Code: Alles auswählen

class Bunch(object):

   def __init__(self, **kwargs):
         self.__dict__.update(kwargs)


filler = Bunch(attr=filler_string)

Dann kannst du da immer drauf zugreifen unter "attr".

[mutetella]

Ok, hier also die ganze Wahrheit... :
Eine mögliche Bildschirmausgabe kann sein (habe code-tag wegen mono-Schrifttyp verwendet):

Code: Alles auswählen

pril 2011                  Mai 2011
Fr Sa So Mo Di Mi Do Fr Sa So Mo Di Mi....
22 23 24 25 26 27 28 29 30  1  2  3  4.....

Die Texte für Monat/Jahr werden jeweils aus den Attributen 'month' und 'year' eines DaySheet()-Exemplares ermittelt und durch ein Leerzeichen voneinander getrennt. Um so weiter man nach links scrollt, um so weniger wird (wie in diesem Fall bei 'pril 2011') vom linken Monat/Jahr-Pärchen, um Stück für Stück Platz für das nachfolgende (in diesem Fall 'Mai 2011') MonatLeerzeichenJahr-Element zu machen.
Um später einen bestimmten Bildschirmbereich identifizieren zu können, lege ich die angezeigten Texte in Region()-Exemplaren ab. Jedes dieser Exemplare besteht aus einem oder mehreren Exemplar/Attributname-Pärchen, die durch 'filler' getrennt werden und durch 'index' beschnitten werden.
Obigen 'April 2011' übergebe ich folgendermaßen:

Code: Alles auswählen

filler = Filler(' ')
r = Region(0, 0, ((daysheet, 'month'), (daysheet, 'year')), (filler, 'string'), (1, None))

Jetzt suche ich eben nach einer Möglichkeit, auf die Filler()-Klasse verzichten zu können. Diese verwende ich ja nur, um den Parameter 'filler' innerhalb der Region()-Klasse genauso wie 'content' verarbeiten zu können.

Hier die Region()-Klasse:

Code: Alles auswählen

class Region(object):
    def __init__(self, x, y, content, filler, index):
        self.x, self.y = x, y
        self.content = self._prepare_content(content, filler, index)
        self.string = self._content2string()
        self.regions = self._merge_content()

    def _prepare_content(self, content, filler, index):
        def extract(instance, attr):
            #extract attr-value char by char to tuples of
            #(object, char, position of char)
            return [(instance, attr, char, position) for 
                position, char in enumerate(getattr(instance, attr))]

        #put 'filler' behind every element in 'content'
        whole_content = itertools.chain(*itertools.izip(
            content, itertools.repeat(filler)))
        #sliced extracted content by index
        return list(itertools.islice(
            itertools.chain(*[extract(*content) for
            content in whole_content]), *index))

    def _content2string(self):
       return ''.join([element[2] for element in self.content])

    def _merge_content(self):
        '''Return content separated by objects/instances.
        Non connected slices (for example slicing with steps) 
        of the same object are bundled as one region.'''
        regions = []
        left_x, left_y = self.x, self.y
        right_x, right_y = left_x, left_y
        grouped_content = itertools.groupby(self.content,
            lambda grouping: grouping[0])
        for _, group in grouped_content:
            group = list(group)
            obj = group[0][0]
            attr = group[0][1]
            slicer = slice(group[0][3], group[-1][3] + 1, 1)
            ext = extent(getattr(obj, attr)[slicer])
            right_x = left_x + (ext[0] - 1)
            right_y = left_y + ext[1]
            regions.append(((left_x, left_y, right_x, right_y), 
                (obj, attr, slicer)))
            left_x = right_x + 1
            left_y = right_y
        return regions

def extent(string):
    return (len(string), 0)

class Filler(object):
    def __init__(self, string):
        self.string = string

Gruß
mutetella


EDIT: Sorry, hab' wieder nicht gescheit geschaut, danke für Eure zwischenzeitlichen Antworten....

[deets]

Also machst du schon, was ich dir vorschlug. Und das ist auch das einzige, was man machen kann. Ausser du definierst die Semantik deiner Zugriffe immer ueber einen Call. Dann kannst du natuerlich sagen

getattr(filler, "__str__")()

Dann muessen die anderen Objekte aber auch immer Methoden liefern.