einem Objekt eine Id zuweisen ?

[Satzende]

Hallo,

ich würde gerne dynamische speichervewaltun Praktizieren.
Also ein Programm schreiben das während der Laufzeit neue Objekte erzeugen kann.
Habe so etwas ähnliches mal in C++, mit der Hilfe eines Buches(" C++ von A bis Z"), gemacht.
Nun gibt es in Python aber keine Zeiger (*1) und wie sich eine id einem Objekt zuweisen lässt konnte ich noch nicht in Erfahrung bringen.

Kann mir das jemand begreiflich machen ?


*1 Glaube ich


Danke für das Lesen und die (Eventuelle) Nützliche Antwort

[sma]

Jedes Objekt in Python hat bereits eine ID:

Code: Alles auswählen

print id(object())

Doch ich befürchte, du stellst die falsche Frage, denn ich wüsste nicht, wie dir dieses Wissen hilft, dynamische Speicherverwaltung zu praktizieren. Was verstehst du unter diesem Begriff? Speicher in Python kannst und willst du nicht selbst verwalten. Die Programmiersprache abstrahiert davon und gibt dir immer Objekte, deren Speicher automatisch verwaltet wird.

Stefan

[pillmuncher]

Du brauchst in Python den Speicher nicht selbst zu verwalten, denn Python hat einen Garbage Collector. Neue Objekte legt man folgendermaßen an:

Code: Alles auswählen

x = 5
y = 'hallo'
z = SomeClass()

wobei 'SomeClass' der Name eine Klasse ist. Objekte löschst du nicht selbst, sondern wartest, bis die Variablen, die auf sie verweisen out of scope gehen, oder du weist den Variablen einfach neue Werte zu:

Code: Alles auswählen

x = 7
y = None
z = SomeOtherClass()

Die zuvor an die Variablen gebundenen Objekte kann der Garbage Collector nun löschen, sprich, deren Speicherplatz freigeben und ggf. wiederverwenden. Aber nur, sofern die Objekte nicht noch an andere Variablen gebunden sind:

Code: Alles auswählen

a = SomeClass()
b = a
a = None

Nach der zweiten Zeile verweisen sowohl a als auch b auf dasselbe Objekt, denn in Python werden bei Zuweisungen Referenzen auf Objekte kopiert, nicht die von den Objekten belegten Speicherbereiche. Deswegen verweist b nach der dritten Zeile immer noch auf das in der ersten Zeile erzeugte Objekt. Python ist nicht C.

Mehr zum Thema findest du in jedem guten Python-Tutorial.

[Satzende]

Danke für eure Antworten.

Mir ist da etwas eingefallen, worauf ich hinaus wollte (will) ist eine Verkettet Liste.
In C++ wurde dazu Funktionen erzeugt die ein Glied aus der liste einfügen bzw. ausgliedern.
Während der Laufzeit konnte man nun eine dieser Funktionen aufrufen um ein neues Objekt in die Liste einzufügen, dazu wurde dann eine klasse erzeugt die einen Zeiger und einen String inne hatte.
Nun will ich so etwas in Python erschaffen.

Hoffe meine Aussagen wahren verständlich

[lunar]

@Satzende: Python ist nicht C++, und es gibt beileibe keine Zeiger in Python. Arbeite also bitte erst einmal das Tutorial aus der Python-Dokumentation durch, um zu sehen, wie Python funktioniert, und insbesondere, wie es sich von C++ unterscheidet.

[Satzende]

Hallo lunar,

Recht hast du, Python ist nicht C++. Und du hast auch recht wenn du Sagst das man lieber erst die Tutorial durcharbeiten sollte bevor man nicht weiter weiß.
Ich hatte mir eben eine schnelle Lösung gewünscht ohne mich einarbeiten zu müssen

[HerrHagen]

Code: Alles auswählen

>>> l=[]
>>> l.append(1)
>>> l
0: [1]
>>> l.append("ABC")
>>> l
1: [1, 'ABC']
>>> l.append([1,2,3])
>>> l
2: [1, 'ABC', [1, 2, 3]]
>>> l[0]
3: 1
>>> l[1]
4: 'ABC'

Nur zum Appetit anregen. Das Lesen eines Tutorials ist trotzdem unerlässlich. Python ist noch viel weniger C++ als du denkst.
Achtung: bei der gezeigten Liste handelt es sich intern nicht um eine verlinkte Liste.

MFG HerrHagen

[hendrikS]

Nur zum Appetit anregen.

Ich weiß nicht so recht ob Dein Bsp. tatsächlich appetitanregend ist. Ich versuche Typmischungen in Listen eher zu vermeiden. Ein Feature, auf das ich durchaus auch verzichten könnte.

[sma]

(Einfach verkettete) Listen sind ja nun einer der ältesten universellen Datentypen und natürlich auch in Python kein größeres Problem:

Code: Alles auswählen

def cons(car, cdr):
    return car, cdr

def car(cons):
    return cons[0]

def cdr(cons):
    return cons[1]

def list(*args):
    return cons(args[0], list(*args[1:])) if args else None

def length(l):
    return length(cdr(l)) + 1 if l else 0

def append(l1, l2):
    return cons(car(l1), append(cdr(l1), l2)) if l1 else l2

def reverse(l):
    return append(reverse(cdr(l)), cons(car(l), None)) if l else None

Stefan

[hendrikS]

@sma: Wo ist denn der praktische Nutzen Deines Posts? Kann den Sinn oder Unsinn nicht erkennen?

[sma]

Die Funktionen implementieren klassische verkettete Listen mittels cons-Zellen und definieren ein paar Funktionen wie "length", "append" und "reverse" - das, was man typischerweise so baut, wenn man sich mit diesem Datentyp beschäftigt.

Stefan

[hendrikS]

Hatte bis jetzt von cons Zellen noch nie was gehört. Gut, daß es wikipedia gibt. Finde es trotzdem suboptimal. Ohne Erklärung kann der Normalo damit nichts anfangen.

[Leonidas]

Das ist auch eher eine Lisp-Spielerei denn ein "ernstgemeinter" Vorschlag zur Lösung des Problems

[Darii]

Hatte bis jetzt von cons Zellen noch nie was gehört. Gut, daß es wikipedia gibt. Finde es trotzdem suboptimal. Ohne Erklärung kann der Normalo damit nichts anfangen.

Der „Normalo“ weiß auch nicht, was eine verlinkte Liste ist.

[sma]

Das ist auch eher eine Lisp-Spielerei denn ein "ernstgemeinter" Vorschlag zur Lösung des Problems

Das "Spielerei" habe ich nicht gehört. Es ging um verkettete Listen und ich habe Funktionen zur (nicht-destruktiven) Konstruktion verketteter Listen gezeigt. Bis auf die archaischen Namen cons, car und cdr sind das Grundoperationen, die für jede Sprache gelten. Das schöne eine einem rekursiven Datentyp wie einer Cons-Liste ist, dass alle Operationen darauf elegant per Rekursion definiert werden können. Hier sind noch ein paar:

Code: Alles auswählen

def nth(l, n):
    return (car(l) if n == 0 else nth(cdr(l), n - 1)) if l else None

def nthcdr(l, n):
    return (l if n == 0 else nthcdr(cdr(l), n - 1)) if l else None

def index(l, o, i=0):
    return (i if car(l) == o else index(cdr(l), o, i+1)) if l else -1

def insert(l, a, e):
    return cons(car(l), cons(e, cdr(l)) if car(l) == a else insert(cdr(l), a, e))

Stefan

[BlackJack]

@sma: Dann sag ich's mal ein wenig lauter: Spielerei. Zumindest in CPython würde ich mich damit nicht weiter aufhalten. Funktionsaufrufe sind verhältnismässig teuer, es gibt ein Rekursionslimit, und keine TCO. Damit verbieten sich IMHO solche Lösungen.