Deutsche Bücher vs. englische Bücher

[cofi]

Code: Alles auswählen

class fibonacci:
   @staticmethod
   def berechne():
       pass

Und schon kannst du `fibonacci.berechne()` nutzen. Du ziehst zu viele Grenzen, dabei gibt es keine verschiedenen Objekte an sich, sondern nur Objekte die sich verschieden verhalten.

[BlackJack]

@ratna_fong: Wo nimmst Du bei `codecs.open()` einen Klassennamen!? An den Namen `codecs` ist ein Objekt gebunden. Das Objekt ist *keine* Klasse. Die *Klasse* von dem Modul heisst `module`, das habe ich hier sogar schon einmal gezeigt.

Um das nochmal etwas akribischer auseinanderzunehmen: `codecs` ist ein Objekt vom Typ `module`. Mittels Punktoperator kann man von diesem Objekt das Attribut `open` abfragen. Das Objekt was man dabei bekommt ist aufrufbar und ein Exemplar der Klasse `function`. Beides sind Objekte die nicht durch (direktes) Aufrufen von Klassenobjekten erzeugt werden. Modulobjekte werden in der Regel durch ``import``-Anweisungen ggf. erzeugt und an Namen gebunden und Funktionsobjekte werden in der Regel durch ``def``-Anweisungen erzeugt.

[ms4py]

Ich habe das Gefühl, dass du einfach zu sehr in dem OO-Paradigma von Java festhängst...

Noch nie C programmiert? Du gibt es auch einfache Funktionen, die man ohne deinen "Übergang" aufrufen kann.

Du musst dich einfach von dem "Alles ist ein Klasse"-Java-Prinzip lösen, dann ist das alles eigentlich ziemlich einleuchtend...

[ratna_fong]

hat mein Problem eigentlich mit Duck-Typing zu tun? Bin aus Verzweiflung auf den Begriff gestoßen, hab dann versucht, die Definition von Duck-Typing in den Fall "codecs" reinzuziehen.

Ich habe den Eindruck:
1. Objekt einfach mal erstmal erstellen
2. Geprüft, geguckt, ob das erstellte Objekt die erwünschte Funktion aufrufen kann, bzw. ob das Objekt bestimmte Attribute für die Funktion besitzt.
3. Wenn ja, geht durch
4. Falls nein, es kracht an der Stelle, wo eine Funktion zum beispiel aufgerufen wird, die es nicht gibt.

Nun das ganze auf "meinen" Fall, codecs, zu übertragen.

codecs ist also ein Objekt, das Objekt hat ja Attribute. Nun zu codecs.open().

open() sagt, "lieber codecs, du hast all die Attribute, die nötig sind, um mich aufzurufen. Kannst mich jetzt kurz haben."
Kurze Zeit später ruft open(): "Nächste bitte !!!"

Also, ich werde auch noch bekloppt.

Eure Ratna

[cofi]

hat mein Problem eigentlich mit Duck-Typing zu tun?

Jein, nur in soweit, wie ich das schon beschrieben hatte, es also nicht nach Typen unterschieden wird, sondern nach Verhalten.

1. Ist falsch, es wird kein Objekt bei dem Aufruf erstellt, sondern es muss existieren.
2. Auch, es wird nicht zuerst ueberprueft, sonder erstmal gemacht "Easier to Ask Forgiveness than to get Permission" (EAFP)

`codecs.open()` == `codecs.open.__call__()`
1. Es gibt einen lookup auf codecs: Gibt es das nicht, wird ein NameError geworfen.
2. Lookup auf open innerhalb von codecs: Gibt es das nicht, wird ein NameError geworfen.
3. Aufruf von __call__: NameError ... ha falsch geraten! Die Laufzeitumgebung erkennt das und gibt die hilfreichere Meldung, dass open kein `callable` ist (als TypeError).

Wenn dich die Interna wirklich interessieren, willst du vllt die Language Reference anschaun: http://docs.python.org/reference/

[ratna_fong]

codecs.open()

diese Methode funktioniert, da das Objekt codecs existiert und es wird in der Doku definiert, dass es existiert und funktioniert.
codecs war schon vorher erzeugt worden, nämlich mit der Klasse module. Nun, da codecs das Verhalten besitzt, um von open() aufgerufen werden zu können, funktioniert das alles.
Richtig?

Dann hab ich aber ne Frage, wo "steht" open()? Ist das eine Funktion, auf die jedes Objekt versuchen kann, zuzugreifen?

Danke Leutz.

Eure Ratna

[BlackJack]

@ratna_fong: Die Dokumentation definiert keine Objekte sondern beschreibt sie nur. Wenn es die Doku nicht gäbe, wäre ja trotzdem das Modul vorhanden.

Das Objekt `codecs` wird beim erstmaligen importieren aus der entsprechenden Python-Quelltext oder -Bytecodedatei erzeugt.

Nun, da codecs das Verhalten besitzt, um von open() aufgerufen werden zu können, funktioniert das alles.

Der Satz macht keinen Sinn. Das Modul wird doch nicht von `open()` aufgerufen!? `codecs` besitzt halt ein Attribut mit dem Namen `open` und das Objekt ist aufrufbar und besitzt die Semantik die in der Dokumentation beschrieben ist. Und Modul-Objekte besitzen eigentlich kein Verhalten was über Attributzugriffe mittels Punktoperator hinausgeht, also die Grundlagen für *jedes* Objekt.

Was meinst Du mit "steht"? Es wird in der Quelltextdatei vom `codecs`-Modul definiert. Und natürlich kann jedes Objekt auf die `open()`-Funktion zugreifen, wenn das Funktionsobjekt irgendwie erreichbar ist, also zum Beispiel über das `codecs`-Modulobjekt oder direkt, wenn die Funktion im lokalen Modul an einen Namen gebunden wurde.

[ratna_fong]

vielen Dank BlackJack,

das Objekt codecs wird also beim Importieren erzeugt, ersellt bzw. instantiiert. Du meintest, nämlich aus dem entsprechenden Quellcode oder Bytecode.
Ist dieser Quellcode eigentlich das Modul codecs?

In dem Modul codecs steht aber jedenfalls die Funktion/Attribut open().

Das hört sich jetzt wieder nach einer ganz "normalen" Objektorientierung wie bie Java oder C++

Ich glaube, mein Hauptproblem ist der Begriff "Modul". Das Modul heißt codecs. Was steht denn in diesem Modul, Definitionen von Klassen, Funktionen, usw.. oder?
Ich kann mich natürlich arrangieren, indem ich mir einfach vorstelle, "ein Objekt namens codecs wird instantiiert, sobald ich der Interpreter import codecs einliest. Und dieses Objekt kann auf die Funktion open() zugreifen."
Ob dies aber stimmt, das bezweifle ich.

Gruss,

Ratna

[ratna_fong]

ich frage mal ganz vorsichtig:

ist also codecs doch nicht so eine Art cout oder cin?

cout oder cin ist ja jeweils ein Objekt, das Attribute besitzt.

cout.ausgabeoperator(string)

ist das nicht so ähnlich wie:

codecs.encodes(parameter)

[BlackJack]

@ratna_fong: Du vermischt immer verschiedene Ebenen. In dem Modul-Objekt `codecs` steht nichts. Das ist ein Objekt mit Attributen. In der Quelltextdatei `codecs.py` steht Python-Quelltext, der bei der Ausführung die Attribute des `codecs`-Objektes definiert.

Das Objekt wird nicht erstellt wenn die ``import``-Anweisung eingelesen wird, sondern wenn sie ausgeführt wird. Und dann hat das Objekt ein Attribut mit dem Namen `open` das an ein Funktionsobjekt gebunden ist.

Das kannst Du doch aber auch alles selber ausprobieren! In einer Python-Shell zum Beispiel. Und das es in der Standardbibliothek eine Datei `codecs.py` gibt und was da drin steht hättest Du auch selber viel schneller herausfinden können als durch das nachfragen hier.

Und das mit dem `cin`/`cout` verstehe ich nicht. Warum fragst Du das immer wieder? Bei den Kriterien die Du da anlegst ist *alles* in Python so etwas wie `cin` oder `cout` weil eben alles was man an einen Namen binden kann ein Objekt ist.

[ratna_fong]

codecs.open("sample.txt")

heißt die Zeile hier oben:
öffne die Datei sample.txt mittels der Funktion open, DIE in dem Modul codecs definiert ist

Angenommen:

Code: Alles auswählen

import codecs
import ratna
#in der Datei ratna.py gibt es die Funktion open()

codecs.open("sample.txt")
ratna.open("sample.txt")

So gesehen, sind codecs und ratna eine Art Schnittstelle und Bezeichner für das entsprechende Modul.
So richtig?

weil eben alles was man an einen Namen binden kann ein Objekt ist.

Hierzu mal zur Sicherheit eine Verständnisfrage:

Code: Alles auswählen

i = 5
# 5 ist das Objekt 
# i ist der Name  
# das Objekt 5 wir an den Namen i gebunden

codecs.open("sample.txt")
Hierbei ist codecs das Objekt. Was ist hier der Name, an den das Objekt codecs gebunden wird?

[Leonidas]

Hierbei ist codecs das Objekt. Was ist hier der Name, an den das Objekt codecs gebunden wird?

codecs ist der Name an den das Modul-Objekt gebunden wird.

Code: Alles auswählen

import codecs
a = codecs
b = codecs
c = codecs

``codecs``, ``a``, ``b`` und ``c`` beziehen sich alle auf das gleiche Objekt.

[ratna_fong]

codecs.open("sample.txt")

codecs ist der Name an den das Modul-Objekt gebunden wird.

die Funktion open() ist also das Modul-Objekt, das an den Namen codecs gebunden wird?

[Rebecca]

codecs.open("sample.txt")
Hierbei ist codecs das Objekt. Was ist hier der Name, an den das Objekt codecs gebunden wird?

Der Name ist codecs, das Objekt, das an den Namen gebunden ist, ist das codecs-Modul. Das codecs-Modul muss nicht immer an den Namen codecs gebunden sein:

Code: Alles auswählen

>>> import codecs as foo
>>> foo.open
<function open at 0x7fe3fbf83a28>
>>> bar = foo
>>> bar
<module 'codecs' from '/usr/lib/python2.6/codecs.pyc'>
>>> bar.open
<function open at 0x7fe3fbf83a28>

[Rebecca]

die Funktion open() ist also das Modul-Objekt, das an den Namen codecs gebunden wird?

Nein. Das codecs-Modul ist das Modul-Objekt, das an den Namen codecs gebunden wird.

[Leonidas]

codecs ist der Name an den das Modul-Objekt gebunden wird.

die Funktion open() ist also das Modul-Objekt, das an den Namen codecs gebunden wird?

Nein, ``open`` ist ein weiteres Objekt (ein Funktionsobjekt), welches über das Modulobjekt erreichbar ist. Und ``open()`` ruft dieses Objekt auf.

[derdon]

Hierzu mal zur Sicherheit eine Verständnisfrage:

Code: Alles auswählen

i = 5
# 5 ist das Objekt 
# i ist der Name  
# das Objekt 5 wir an den Namen i gebunden

Ja, hast du so richtig verstanden.

[ratna_fong]

codecs.open("sample.txt")

codecs ist also der Name(Bezeichner), an den das FunktionsOBJEKT open() gebunden wird.

Ich hab immer gefragt, was denn codecs in codecs.open() ist.
da wurde immer gesagt, codecs sei das Objekt, finde ich irreführend. Naja, egal.

Wenn man also eine Funktion, eine Klasse, oder was auch immer (was ja alles Objekte sind) in dem Modul codecs verwenden will, muss man also immer den Bezeichner/Namen "codecs" nehmen, an den ein Objekt gebunden wird, insofern man nicht explizit folgendes definiert:

Code: Alles auswählen

import codecs as ratna

ratna.open("sample.txt")

Bitte um Korrektur falls noch Denkfehler ist. Danke..

Ratna

[ms4py]

die Funktion open() ist also das Modul-Objekt, das an den Namen codecs gebunden wird?

Nein. Das codecs-Modul ist das Modul-Objekt, das an den Namen codecs gebunden wird.

Und die Funktion `open` ist ein Attribut diese Objekts.

Edit: Du hast 2 Objekte! Das Objekt-Modul, das über den Bezeichner "codecs" aufrufbar ist, und das Funktions-Objekt, das über den Attributzugriff des Moduls erreichbar ist.

Edit2:

Code: Alles auswählen

import codecs
func = codecs.open
func("test.txt")

Damit wird z.B. das Funktions-Objekt an den Bezeichner "func" gebunden und kann über den Bezeichner auch aufgerufen werden.

[Leonidas]

codecs ist also der Name(Bezeichner), an den das FunktionsOBJEKT open() gebunden wird.

Nein, das Funktionsobjekt ist an den Namen ``open`` gebunden. An den Namen ``codecs`` ist das Modulobjekt gebunden.