Ein paar Fragen über das überladen von operatoren...

[sape]

Ich hatte das so aus der Beschreibung rausgelesen (welches objekt an einen namen gebunden ist).

Das macht man aber nicht mit id sonder mit repr. Identität != Typ.

``id`` gibt mir einen kollisionsfreihen (Also wirklich einzigartige) Numerischen Wert zurück. Das ist die Identität des Objektes (BZW. Des namen der an Objekt X gebundene ist.).

Code: Alles auswählen

blex = BasisLexer("**//test**")
print id(blex) #id: 10374384

Falls zwei Objekte die gleiche id haben, muss das eine, eine Referenz auf das andere sein oder auf ein Objekt X das noch nicht untersucht wurde.

Was ist ``blex2``? Ist es das das instanziierte Objekt der Klasse ``BasisLexer`` oder ist es nur die Referenz auf ``blex``?

Code: Alles auswählen

    
    ref_blex = blex2
    print id(blex2) #id: 10374384
    print id(ref_blex) #id: 10374384
    # ref_blex == blex2

Tja, was sagte ich noch am Anfang? ``id`` gibt die Identität zurück? Das habe ich ja wohl ad absurdum geführt Eine Identität ist was einzigartiges, einmaliges. Das gilt für Objekte/Name in Python aber anscheinend nicht. Mal ernsthaft: Alles in Python ist nur eine Referenz.

Wie auch immer, es sollte nun klar sein worauf ich hinaus wollte.

...

So eine ``id`` bringt mich nicht wirklich weiter. Ich kann damit nur herausfinden das zwei Namen auf die gleiche Speicheradresse zeigen (Oder besser gesagt auf den gleichen Inhalt). -- Es ist also gerade brauchbar um zu testen ob zwei Objekte die gleiche Identität haben. Und wie oft muss man sowas testen?

Wie BlackJack schon sagt, für mich ist es relevant welche Werte ein Name hat und an welches Objekt es gebunden ist. Das alles kann ich mit ``repr`` rausfinden (Wenn ich ``__repr__`` selber Sinnvoll überladen habe):

Code: Alles auswählen

src = """** test **"""
dwlex = DauCMSWikiLexer(src)
print repr(dwlex)

Output:

Code: Alles auswählen

<dcmswlex.DauCMSWikiLexer: [[('MARKUP_BOLD', None), ('LITERAL', ' test '), ('MARKUP_BOLD', None)]]>

Und wenn du unbedingt auch zusätlich die ``id`` angezeigt habe willst, dann fügst du zusätzlich in ``__repr__`` ein ``id(self)`` hinzu, ...

Code: Alles auswählen

def __repr__(self):
        return "<%s.%s: %r @ ID: %d>" % (
            _NAME_OF_THIS_MODULE, self.__class__.__name__, self._token_stream,
            id(self)
        )

Output wäre z.B.:

Code: Alles auswählen

<dcmswlex.DauWikiLexer: [[('MARKUP_BOLD', None), ('LITERAL', ' test '), ('MARKUP_BOLD', None)]] @ ID: 10373328>

... das IMHO aber unnötig ist, da wie gesagt mehrere Namen auch die gleiche Identität (id) habe können, falls die besagten auf das instanziierte referenziert sind.

Wenn mich nur der Wert interessiert (Und ich ``__str__`` überladen habe), genügt nur ein einfaches ``print dwlex``.

Fazit für mich: Die Überladung von ``__repr__`` ist für mich genauso unersätzlich wie die Überladung von ``__str__``. ``repr()`` nutze ich ziemlich oft, wohingegen ich ``id`` so gut wie garnicht brauche.

lg

[sape]

Hier noch ein Beispiel über ``id``.

Code: Alles auswählen

x = 1
y = 1
print "%d == %d" % (id(x), id(y)) # 9722488 == 9722488

Ich referenzierte y nicht auf x, aber dennoch haben die die gleiche id. Warum? Weil in Python alle Objekte die den gleichen Wert haben, von Python auf die gleiche Adresse referenziert werden, um Redundanzen zu verhindern. [1]

Noch ein Beispiel:

Code: Alles auswählen

x = 1
y = 1
print "x: %d == y: %d" % (id(x), id(y))
x = 2
print "x: %d != y: %d" % (id(x), id(y))
y=2
print "x: %d == y: %d" % (id(x), id(y))

Code: Alles auswählen

x: 9722488 == y: 9722488
x: 9722476 != y: 9722488
x: 9722476 == y: 9722476

Es sollte nun klar sein, das ``id`` nicht besser ist als ``repr`` beim debugen.

lg

EDIT:
[1] Das gilt aber nur für imutable und nicht für mutable Objekte!!

Code: Alles auswählen

x = [1, 2, 3]
y = [1, 2, 3]
print "x: %d != y: %d" %(id(x), id(y))

Code: Alles auswählen

x: 10369464 != y: 10381392

[birkenfeld]

Ich hatte das so aus der Beschreibung rausgelesen (welches objekt an einen namen gebunden ist).

Das macht man aber nicht mit id sonder mit repr. Identität != Typ.

``id`` gibt mir einen kollisionsfreihen (Also wirklich einzigartige) Numerischen Wert zurück. Das ist die Identität des Objektes (BZW. Des namen der an Objekt X gebundene ist.).

Nein, die Identität des Objekts. Der Namen hat keine.

Falls zwei Objekte die gleiche id haben, muss das eine, eine Referenz auf das andere sein oder auf ein Objekt X das noch nicht untersucht wurde.

Kein Objekt ist eine Referenz auf ein anderes (außer es ist ein weakref-Objekt ), ein Objekt ist ein Objekt. Und was ist an einem Objekt, das noch nicht untersucht wurde, anders als an einem, das untersucht wurde? Wir sind hier nicht in der Quanteninformatik.

Tja, was sagte ich noch am Anfang? ``id`` gibt die Identität zurück? Das habe ich ja wohl ad absurdum geführt Eine Identität ist was einzigartiges, einmaliges. Das gilt für Objekte/Name in Python aber anscheinend nicht. Mal ernsthaft: Alles in Python ist nur eine Referenz.

Das ist, mit Verlaub gesagt, Schwachsinn. Du solltest mal [wiki]Objekte[/wiki] durchlesen.

[birkenfeld]

Code: Alles auswählen

x = 1
y = 1
print "%d == %d" % (id(x), id(y)) # 9722488 == 9722488

Ich referenzierte y nicht auf x, aber dennoch haben die die gleiche id. Warum? Weil in Python alle Objekte die den gleichen Wert haben, von Python auf die gleiche Adresse referenziert werden, um Redundanzen zu verhindern. [1]

Nein, es ist *das gleiche Objekt*. Deswegen hat es *die gleiche id*.

[BlackJack]

Nein, es ist *das gleiche Objekt*. Deswegen hat es *die gleiche id*.

Ich weiss, der Duden macht diese Unterscheidung nicht mehr, aber "es ist das *selbe* Objekt" ist etwas stärker und deutlicher. IMHO.

[birkenfeld]

Nein, es ist *das gleiche Objekt*. Deswegen hat es *die gleiche id*.

Ich weiss, der Duden macht diese Unterscheidung nicht mehr, aber "es ist das *selbe* Objekt" ist etwas stärker und deutlicher. IMHO.

Hast recht. Irgendwie hab ich den Unterschied zwischen den beiden nie richtig gelernt, ebenso wie bei "anscheinend" und "scheinbar"

[sape]

Falls zwei Objekte die gleiche id haben, muss das eine, eine Referenz auf das andere sein oder auf ein Objekt X das noch nicht untersucht wurde.

Kein Objekt ist eine Referenz auf ein anderes (außer es ist ein weakref-Objekt ), ein Objekt ist ein Objekt. Und was ist an einem Objekt, das noch nicht untersucht wurde, anders als an einem, das untersucht wurde? Wir sind hier nicht in der Quanteninformatik.

Ok, ich dachte Namen werden auch als Objekt betrachtet, das es doch heißt dass alles in Python ein Objekt ist? Ist denn die Variabel x (Instanz von x= [1,2,3]) kein Objekt? Sind Namen keine Objekte?

Tja, was sagte ich noch am Anfang? ``id`` gibt die Identität zurück? Das habe ich ja wohl ad absurdum geführt Eine Identität ist was einzigartiges, einmaliges. Das gilt für Objekte/Name in Python aber anscheinend nicht. Mal ernsthaft: Alles in Python ist nur eine Referenz.

Das ist, mit Verlaub gesagt, Schwachsinn. Du solltest mal [wiki]Objekte[/wiki] durchlesen.

Ja aber wenn ich folgendes habe:

Code: Alles auswählen

x = [1,2 ,3]
y = x

Dan ist doch y eine Referenz von x? Oder nicht? Und x ist doch auch ein Objekt, es sei den Namen sind keine Objekte

EDIT2: Fehler berichtigt!

[sape]

Oder mal anders Birkenfeld.

Code: Alles auswählen

def edit(list_):
    list_.append("Keine Referenz?")

li = [1,2,3]
print li
edit(li)
print li

Code: Alles auswählen

[1, 2, 3]
[1, 2, 3, 'Keine Referenz?']

?

[sape]

http://www.ruby-lang.org/de/documentati ... om-python/

Alles ist ein Objekt, und Variablen sind Referenzen auf Objekte.

Ok, dann sind Namen (Variablen?) nur Referenzen auf Objekte (Klassen und ?) und selbst keine Objekte? 0_o Ich dachte immer das eine Instanz von einer Klasse auch ein Objekt darstellt und nicht eine Referenz auf die Klasse.

[wiki]Objekte[/wiki]

Objekte haben außerdem:

*

keine oder mehrere Methoden (vom Typobjekt bereitgestellt)
*

keinen oder mehrere Namen

Was ist den eine Funktion in Python? Auch ein Objekt des Namensraumes "Modul"? Oder sind in gruden nur Klassen (Namensräume) nur Objekte und somit auch Module? Operatoren sind in Python schonmal keine Objekte, so wie in Ruby?

Sorry aber um so mehr ich über die Definition "Objekte bei Python" nachdenke um so inkonsistenter erscheint mir das.

Ich dachte **alles** ist ein Objekt in Python.

[Leonidas]

Schau dir mal http://bj.spline.de/download/names'n'objects.pdf an. Namen sind keine Objekte, Namen kannst du dir eher als Schnüre vorstellen, die an ein Objekt drangebunden werden. Ein Objekt kann zwar mehrere Namen haben, aber ein Name kann nur ein Objekt haben. Und außerdem kann ein Name nicht auf einen Namen zeigen, sondern immer nur auf das daran gebundene Objekt.

Ganz wichtig ist die Trennlinie zwischen `Names` und `Objects`. Pfeile von Namen können nur auf die Objektseite zeigen, aber nie und nimmernicht auf einen anderen Namen!

[birkenfeld]

Falls zwei Objekte die gleiche id haben, muss das eine, eine Referenz auf das andere sein oder auf ein Objekt X das noch nicht untersucht wurde.

Kein Objekt ist eine Referenz auf ein anderes (außer es ist ein weakref-Objekt ), ein Objekt ist ein Objekt. Und was ist an einem Objekt, das noch nicht untersucht wurde, anders als an einem, das untersucht wurde? Wir sind hier nicht in der Quanteninformatik.

Ok, ich dachte Namen werden auch als Objekt betrachtet, das es doch heißt dass alles in Python ein Objekt ist? Ist denn die Variabel x (Instanz von x= [1,2,3]) kein Objekt? Sind Namen keine Objekte?

Nein, Namen sind keine Objekte, sondern Einträge in Namensräumen, die auf Objekte verweisen. (Der Namensraum ist natürlich ein Objekt (normalerweise ein Dictionary), und der String, der den Key im Namensraum bildet, auch.

Tja, was sagte ich noch am Anfang? ``id`` gibt die Identität zurück? Das habe ich ja wohl ad absurdum geführt Eine Identität ist was einzigartiges, einmaliges. Das gilt für Objekte/Name in Python aber anscheinend nicht. Mal ernsthaft: Alles in Python ist nur eine Referenz.

Das ist, mit Verlaub gesagt, Schwachsinn. Du solltest mal [wiki]Objekte[/wiki] durchlesen.

Ja aber wenn ich folgendes habe:

Code: Alles auswählen

x = [1,2 ,3]
y = x

Dan ist doch y eine Referenz von x? Oder nicht? Und x ist doch auch ein Objekt, es sei den Namen sind keine Objekte

x und y sind Namen und zeigen beide auf das Listenobjekt. y zeigt nicht auf den Namen x.

[birkenfeld]

Alles ist ein Objekt, und Variablen sind Referenzen auf Objekte.

Ok, dann sind Namen (Variablen?) nur Referenzen auf Objekte (Klassen und ?) und selbst keine Objekte? 0_o Ich dachte immer das eine Instanz von einer Klasse auch ein Objekt darstellt und nicht eine Referenz auf die Klasse.

Eine Instanz ist ein Objekt. Der Name nicht. Deswegen gibt es ja z.b. id().

[wiki]Objekte[/wiki]

Objekte haben außerdem:

* keine oder mehrere Methoden (vom Typobjekt bereitgestellt)
* keinen oder mehrere Namen

Was ist den eine Funktion in Python? Auch ein Objekt des Namensraumes "Modul"? Oder sind in gruden nur Klassen (Namensräume) nur Objekte und somit auch Module? Operatoren sind in Python schonmal keine Objekte, so wie in Ruby?

Funktionen sind Objekte. Funktionen in Modulen haben (zumindest) einen Namen, der im Namensraum des Moduls eingetragen ist, Methoden im Namensraum der Klasse.

Wo und wie sind in Ruby Operatoren Objekte?

Sorry aber um so mehr ich über die Definition "Objekte bei Python" nachdenke um so inkonsistenter erscheint mir das.

Ich dachte **alles** ist ein Objekt in Python.

Ja, ist es auch. Du hast es nur nicht verstanden.

Oder meinst du, auch "if" und "import" sollen Objekte sein?

[Leonidas]

Code: Alles auswählen

def edit(list_):
    list_.append("Keine Referenz?")

li = [1,2,3]
print li
edit(li)
print li

Code: Alles auswählen

[1, 2, 3]
[1, 2, 3, 'Keine Referenz?']

Das wundert dich jetzt nicht, oder?
Du hast eine Funktion edit(), die einen Namen nimmt, das daran gebundene Objekt an list_ bindet und dort dessen Funktion append() aufruft.
Gehen wir es mal durch: Du erstellst eine Liste, fein. Dann zeigst du die Liste an, danach wird das an li gebundene Objekt geändert (wobei es zwischenzeitlich einen zweiten Namen, list_, bekommt, der aber beim Beenden der Funktion zerstört wird). Dann Zeigst du das an, und siehst, dass das Objekt sich verändert hat. Wo ist da der Wiederspruch?

[sape]

Ok, danke euch beiden. Das hilft mir dann schon mal weiter zum Verständnis.

Eine Frage ist aber noch offen:

Vorweg:
In C: ``int i = 0``
In C wäre i eine Variable vom Datentype int.

In C++ sind Instanzen von Klassen auch Variablen, werden aber halt Instanzen genant.

Daher die Frage: Sind den Namen in Python Variablen und instanzen?
Wiel für mich ist i in folgenden Code eine Instanz/Variabel (Wie auch immer. immer diese Unterscheidung zwischen Variabel und instanz) von Foo:

Code: Alles auswählen

class Foo(): pass
i = Foo()

[sape]

Eine Instanz ist ein Objekt. Der Name nicht. Deswegen gibt es ja z.b. id().

Puh, nun wird es ansträngend:

Code: Alles auswählen

class Foo: pass
x = Foo()

Was ist x? Ist x die Instanz von Foo? Wenn ja dann ist x ein Objekt! x ist aber auch der Name der Instanz von Foo == x ist die Instanz von Foo.

Funktionen sind Objekte. Funktionen in Modulen haben (zumindest) einen Namen, der im Namensraum des Moduls eingetragen ist, Methoden im Namensraum der Klasse.

Funktionen sind also Objekte? Eine Funktion hat doch aber ein Namen. Eine Klasse hat auch ein Namen. Bei einer Klasse wird aber gesagt sie ist ein Objekt. Ok. Bei einer Funktion wird dann auch gesagt sie ist ein Objekt. Aber ein Instanz ist kein Objekt? Ne Moment, Du sagtest ja das Instanzen auch Objekte sind. Dan ist der Name x auch ein Objekt das an das Objekt Foo gebunden ist, weil x die Instanz von Foo ist?

Merkt keiner den Widerspruch, bzw. wie kleinkariert das eigentlich ist?
Ich möchte auch erklären warumd as kleinkariert ist.
Du sagst das Instanzen Objekte sind. Du sagt aber das Namen kein Objekte sind. Man kann aber nur über einen Namen eine Instanz erzeugen. So abld ich ``x = Foo()`` schreibe ist x eine Instanz und somit ein Objekt. Aber sobald ich sage das x der Name ist der an Foo gebunden ist, ist es kein Objekt mehr sondern nur ein Namen?

Wo und wie sind in Ruby Operatoren Objekte?

Per Definition ist alles in Ruby ein Objekt. Man kann wirklcih alles überladen.

[sape]

Das wundert dich jetzt nicht, oder?

Nein. Bitte den Kontext beachten.

[Leonidas]

In denem Code ist ``i`` ein Name, der auf eine Instanz von ``Foo`` zeigt.

Ist ja auch logisch, nimm mal den Code:

Code: Alles auswählen

i = Foo()
noch_ein_i = i

Dann ist ``noch_ein_i`` natürlich keine weitere Instanz, sondern zeigt auf die gleiche Instanz wie ``i`` (kannst ja mal mit id() nachschauen).

Irgendwie ist der Name Variable in Python eigentlich nicht zutreffend, da er zu ungenau ist, bezeichnet nun die Variable ``i`` den Namen ``i`` oder das an ``i`` gebundene Objekt? Aber in der Regel ist diese Ungenauigkeit kein sonderliches Problem.

Die Unterscheidung ist also nicht zwischen Instanz und Variabel, sondern zwischen Objekt und Name.

[sape]

In denem Code ist ``i`` ein Name, der auf eine Instanz von ``Foo`` zeigt.
[...]

Ah nun habe ichs. Der Name zeigt auf die Instanz vom Objekt (Der Klasse) ``Foo``.

Irgendwie ist der Name Variable in Python eigentlich nicht zutreffend, da er zu ungenau ist, bezeichnet nun die Variable ``i`` den Namen ``i`` oder das an ``i`` gebundene Objekt? Aber in der Regel ist diese Ungenauigkeit kein sonderliches Problem.

Genau, daran hat es auch gelegen. Aber schön das du verstanden hast worauf ich hinaus wollte und warum ich das nicht verstanden hatte

EDIT: Hinzugefügt.

[Leonidas]

Code: Alles auswählen

class Foo: pass
x = Foo()

Was ist x? Ist x die Instanz von Foo? Wenn ja dann ist x ein Objekt! x ist aber auch der Name der Instanz von Foo == x ist die Instanz von Foo.

Nein, das an den Namen ``x`` gebundene Objekt ist eine Instanz von Foo. Der Name ``x`` ist kein Objekt, es gibt ebensowenig auch ungebundene Namen. Aber ungebundene Objekte (die dann vom GC entsorgt werden).

Funktionen sind also Objekte? Eine Funktion hat doch aber ein Namen.

Nein, die Funktion hat keinen Namen. Sie ist nur an einen Namen gebunden.

Code: Alles auswählen

In [13]: tex, mex, klex = hex, hex, hex

Und nun ist das Funktionobject welches an den Namen ``hex`` gebunden ist, auch an andere Namen gebunden. Mit lambda kannst du auch anonyme Funktionen bilden, die zwar ein Objekt sind, aber an keinen Namen gebunden sind.

Eine Klasse hat auch ein Namen.

Hat keinen Namen, sondern ist an einen Namen gebunden.

Bei einer Klasse wird aber gesagt sie ist ein Objekt. Ok. Bei einer Funktion wird dann auch gesagt sie ist ein Objekt. Aber ein Instanz ist kein Objekt?

Doch, sicher.

Code: Alles auswählen

class Foo(object): pass
Foo()
# so, jetzt hatten wir eine Instanz (ein Objekt), die aber keinen Namen hatte
# ist daher nicht greifbar und an dieser stelle möglicherweise 
# schon vom GC abgeräumt

Ne Moment, Du sagtest ja das Instanzen auch Objekte sind. Dan ist der Name x auch ein Objekt das an das Objekt Foo gebunden ist, weil x die Instanz von Foo ist?

Andersrum, das Objekt ist an den Namen gebunden.

Merkt keiner den Widerspruch, bzw. wie kleinkariert das eigentlich ist?

Es gibt keinen Widerspruch. Du mischt aber den Namen mit dem Wert, daher ergibt sich ein Widerspruch.

Du sagst das Instanzen Objekte sind. Du sagt aber das Namen kein Objekte sind. Man kann aber nur über einen Namen eine Instanz erzeugen. So abld ich ``x = Foo()`` schreibe ist x eine Instanz und somit ein Objekt. Aber sobald ich sage das x der Name ist der an Foo gebunden ist, ist es kein Objekt mehr sondern nur ein Namen?

Die ersten zwei Sätze stimmen ja. Aber ``x`` ist keine Instanz, sindern nur eine Art Zeiger auf das wirkliche Objekt, welches eine Instanz der Klasse ``Foo`` ist.

Wo und wie sind in Ruby Operatoren Objekte?

Per Definition ist alles in Ruby ein Objekt. Man kann wirklcih alles überladen.

Nein. Keywords wie if, class, end sind keine Objekte und können nicht überladen werden. Daher bitte ich dich, jede weitere Behauptung über das in Ruby mögliche Überladen von allem erstmal mit Code zu belegen. Die Leute aus #ruby-de wären auch daran interessiert, haben so etwas auch noch nie gesehen und fänden so etwas sicher lehrreich.

[sape]

Schau dir mal http://bj.spline.de/download/names'n'objects.pdf an.

Thx! Nun habe ich es endgültig verstanden. (BTW: Scheiß C++. Dort gibt es keine solche Unterscheidung und ist in meinen alten Buch auch nicht so aufgeführt!).

Aber noch eine Frage (Die letzte).

Sehe ich das richtig das diese Einführung mit der unterscheidung von *Name und Objekt* bei Python nur deswegen da ist, weil wir es in Python hauptsächlich mit Referenzen zu tun haben (Mehrere Namen können auf die gleiche Instanz zeigen)?

In C gibt es das ja so nicht. In C ist der Name X nicht nur ein Name sondern auch die Variable (Oder Instanz in C++).

Sorry, falls ihr denkt ich will euch ärgern. Das ist nicht meine Absicht. Wenn ich was wissen will, dann richtig. Deshalb die Fragen.

BTW: Falls gleich kommt: "I C/C++ gibt es auch Referenzen". Ja, weiß ich. Die werden dort mit pointern (*, **) gemacht, mit denen man auf Verschiedene Variablen Zeigen kann oder auch Dynamisch Speicher allokieren kann! Aber wenn ich folgendes habe:
int x = 1
int y = 2

und dan x = y schreibe, Zeigt x nicht auf y so wie bei Python Um das zu erreichen muss x ein pointer sein.
int y = 1
int *x = y.

Daher auch die frage oben weshalb es in Python dazu kam wie es ist.