Ich stöbere gerade durchs PythonWiki auf der Suche, nach Ideen für die Weiternentwicklung des dauCMS-Wiki-Syntax-Parsers und bin da auf etwas gestoßen, was mich "anmacht"
[wiki]Meta Klassen[/wiki]
Das sieht irgentwie sehr genial aus... funtkioniert auch...
ABER
Wie kann ich aber bei Klassen, die in die Liste eingetragen werden herausfinden, ob und wenn von welcher Klasse sie irgentetwas Erben?
Das ist etwas, was ich noch nie so richtig verstanden habe... da gibet ja 'super()' -- was ich auch noch net so richtig kapiert habe,... das gibt mir ja die "Oberklasse" zurück.
Aber wie kann ich das von außerhalb aufrufen?
Einfach nur mit 'super' klappts ja net so richtig... :'(
Könnt ihr mir da ein wenig Unter die Arme greifen?
MfG EnTeQuAk
Nochma eine Frage zu Klassen
Hi, EnTe. Ja ich weiß da hilft dir nicht weiter aber möchte es dennoch gesagt haben und außerdem abonniere ich mit dem Post diesen thread -- Ich habe das ganze wirkliche Prinzip von Meta Klassen nicht begriffen oder besser gesagt, ich erkenne nicht den Sinn dahinter wofür man sowas benötigt :-[
Ich will mir daher demnächst ein Buch kaufen in dem das beschrieben ist (Hoffentlich auch exakt).
lg
EDIT: *Abo*
Ich will mir daher demnächst ein Buch kaufen in dem das beschrieben ist (Hoffentlich auch exakt).
lg
EDIT: *Abo*
-
- User
- Beiträge: 773
- Registriert: Mittwoch 5. November 2003, 18:06
- Wohnort: Schweiz
- Kontaktdaten:
Du weisst schon dass es dafür einen extra Link gibt?sape hat geschrieben:außerdem abonniere ich mit dem Post diesen thread
Ist Links unten auf der Seite und heisst "Bei Antworten zu diesem Thema benachrichtigen".
Bitte benutz den auch und mach nicht sinnlos Posts.
Gruss
- birkenfeld
- Python-Forum Veteran
- Beiträge: 1603
- Registriert: Montag 20. März 2006, 15:29
- Wohnort: Die aufstrebende Universitätsstadt bei München
Wenn man das Objektmodell von Python betrachtet -- alles ist ein Objekt -- dann müssen eben auch Klassen Instanzen einer Klasse sein. Das ist die Metaklasse.sape hat geschrieben:Ich habe das ganze wirkliche Prinzip von Meta Klassen nicht begriffen oder besser gesagt, ich erkenne nicht den Sinn dahinter wofür man sowas benötigt :-[
vllt. nicht erwähnt --> Mir ging es um das zweite Beispiel
Also um das "zählen" von bestimmten Klassen.
MfG EnTeQuAk
Also um das "zählen" von bestimmten Klassen.
MfG EnTeQuAk
- birkenfeld
- Python-Forum Veteran
- Beiträge: 1603
- Registriert: Montag 20. März 2006, 15:29
- Wohnort: Die aufstrebende Universitätsstadt bei München
Magst du nochmal beschreiben, was du eigentlich tun willst? Aus deinem OP werd ich nicht schlau.
Wenn ich dich richtig verstanden habe, dann suchst du die Superklassen einer Klasse. Diese bekommst du über das Attribut "__bases__":
in "bases" befinden sich nun eine Liste von Referenzen auf die Klassen A und B.
EDIT: Dreifache Unterstriche sind einfach falsch...
Code: Alles auswählen
class A():
pass
class B():
pass
class C(A, B):
pass
bases = C.__bases__
EDIT: Dreifache Unterstriche sind einfach falsch...
Ich möchte meinen Parser erweitern.Magst du nochmal beschreiben, was du eigentlich tun willst? Aus deinem OP werd ich nicht schlau.
So... ich habe mehrere verschiedene (immo 2 ) Token-Typen. Block und Text-Tokens.
Entsprechende Token-Klassen sollen die entprechend definierten Tokens zählen
das siehe hier so aus (ungetestet und nur bsp.haft)
Code: Alles auswählen
class TextToken(type):
registry = []
def __new__(cls, name, bases, d):
new_cls = type.__new__(cls, name, bases, d)
TextToken.registry.append(new_cls)
return new_cls
class MyClass(object):
__metaclass__ = TextToken
class AnotherClass(object):
__metaclass__ = TextToken
Das war nur ne Idee... es ginge auch über vererben. Aber da wüsste ich nicht genau, wie das geht. Obiges probiere ich gleich ma aus,.
Also in Kurzform, möchte ich zwei "Hauptklassen", die die verschiedenen Syntax-Klassen "zählen" und ich im Endefekt über diese iterieren kann um verschiedene Aktionen mit denen ausführen zu können.
hoffe, es ist nun etwas klarer formiert...
MFG EnTEQuAk
Oki Obiges funktioniert (vor meinem Post)
Hier das, was ich meinte:
Ist immo nur nen Simples Beispiel.. --> verkörpert aber ganz gut, was ich haben wollte
Vielleicht fällt ja doch noch jemandem anderen etwas "besseres" ein
(sollte es das geben)
MfG EnTeQuAk
Hier das, was ich meinte:
Code: Alles auswählen
class Registry(type):
registry = []
def __new__(cls, name, bases, d):
new_cls = type.__new__(cls, name, bases, d)
Registry.registry.append(new_cls.__bases__)
return new_cls
class BlockToken(object):
def __init__(self):
self.blck_txt = 'da'
class TextToken(object):
def __init__(self):
self.txt = 'dadadada'
class Bold(TextToken):
__metaclass__ = Registry
class Italic(TextToken):
__metaclass__ = Registry
class Noparse(BlockToken):
__metaclass__ = Registry
class List(BlockToken):
__metaclass__ = Registry
if __name__ == '__main__':
print Registry.registry
Vielleicht fällt ja doch noch jemandem anderen etwas "besseres" ein
(sollte es das geben)
MfG EnTeQuAk
Sorry, OT, aber:
Meiner murmelnden Meinung nach?!
in my mumble opinion?!EnTeQuAk hat geschrieben:immo
Meiner murmelnden Meinung nach?!
Es gibt für alles eine rationale Erklärung.
Außerdem gibt es eine irrationale.
Wie man Fragen richtig stellt
Außerdem gibt es eine irrationale.
Wie man Fragen richtig stellt
Willst du Klassen zählen, oder Instanzen von Klassen?
Ach ja, zu immo: http://de.wikipedia.org/wiki/Immo_%28Asteroid%29
Ach ja, zu immo: http://de.wikipedia.org/wiki/Immo_%28Asteroid%29
- birkenfeld
- Python-Forum Veteran
- Beiträge: 1603
- Registriert: Montag 20. März 2006, 15:29
- Wohnort: Die aufstrebende Universitätsstadt bei München
Ja, jetzt bast du alle Klassen in Registry.registry aufgelistet. Was willst du jetzt mit denen anfangen?EnTeQuAk hat geschrieben:Oki Obiges funktioniert (vor meinem Post)
Hier das, was ich meinte:
Code: Alles auswählen
class Registry(type): registry = [] def __new__(cls, name, bases, d): new_cls = type.__new__(cls, name, bases, d) Registry.registry.append(new_cls.__bases__) return new_cls class Bold(TextToken): __metaclass__ = Registry class Italic(TextToken): __metaclass__ = Registry (...)
-
- User
- Beiträge: 773
- Registriert: Mittwoch 5. November 2003, 18:06
- Wohnort: Schweiz
- Kontaktdaten:
Hi
Listet alle Klassen auch, die von Token direkt vererbt sind.
Gruss
Code: Alles auswählen
class Counter(type):
base_tokens = set()
def __new__(cls, name, bases, d):
new_cls = type.__new__(cls, name, bases, d)
try:
if Token in bases:
Counter.base_tokens.add(new_cls)
except NameError:
pass
return new_cls
class Token(object):
__metaclass__ = Counter
class TextToken(Token):
pass
class BlockToken(Token):
pass
class SpecialToken(TextToken):
pass
print Counter.base_tokens
Gruss
Ich möchte (im Enddefekt) erst die BlockTokens verarbeiten (also alle, von BlockToken abgeleiteten Klassen)Ja, jetzt bast du alle Klassen in Registry.registry aufgelistet. Was willst du jetzt mit denen anfangen?
und dannach die TextTokens (alle davon abgeleiteten Klassen).
Mehr net...
Ansich funktioniert es ja schon so erstma --> Mir ging es erstma nur um die "Grundstruktur", wie ich die Applikation aufzubauen habe...
MfG EnTeQuAk
Die Frage ist ob man dazu unbedingt Metaklassen braucht oder ob man die nicht auch explizit in der `Registry` anmelden kann.
Insbesondere das bei Deinem Code bei jeder Token-Klasse das `__metaclass__`-Attribut gesetzt werden muss, macht es komplizierter als es sein muss. Bei rayo werden die Unterklassen automatisch registriert, da ist wenigstens ein Gewinn.
Insbesondere das bei Deinem Code bei jeder Token-Klasse das `__metaclass__`-Attribut gesetzt werden muss, macht es komplizierter als es sein muss. Bei rayo werden die Unterklassen automatisch registriert, da ist wenigstens ein Gewinn.