Deutsche Bücher vs. englische Bücher

[ratna_fong]

okay, vielen Dank an alle für die Bemühungen.

Aber zurück zu dem Modul codecs. Das Modul codecs ist hier also tatsächlich ein Objekt.

Wo und wann wurde dieses Objekt codecs aber instantiiert, und aus welcher Klasse? Ist diese Frage überhaupt berechtigt?
Ich habe nämlich ein bisschen gegoogelt, bin dann auf die Aussage "in Python ist alles Objekte" gestoßen.

Also, momentan identifiziere ich den Begriff Objekt immer mit folgenden Eigenschaften?
1. Es MUSS eine Klasse geben, die quasi Grundgerüst dieses Objekts ist
2. Es können Variablen und Methoden dieses Objekts geben.
Also, Objekt in dem Sinne der Sprache C++ oder Java.

Vielleicht muss ich eine weitere Sichtweise haben, um es besser zu verstehen, was ein Objekt ist?

Ich bin dankbar für die Hilfe.

Grüße,


Eure Ratna

[BlackJack]

@ratna_fong: In Python hat zwar jedes Objekt auch eine Klasse, das ist aber aus objektorientierter Sicht nicht zwingend notwendig. Es heisst ja objektorientiert und nicht klassenorientiert. Es gibt auch Programmiersprachen die nur Objekte, aber keine Klassen kennen. Io oder Self wären zum Beispiel solche Sprachen.

Zurück zu Python: Module haben die Klasse `module`. Das heisst aber nicht, dass es irgendwo Python-Code geben muss, der mit ``class module:`` beginnt, denn diese grundlegende Klasse ist in C implementiert und im Interpreter integriert.

Code: Alles auswählen

In [336]: codecs.__class__
Out[336]: <type 'module'>

In [337]: codecs.__class__.__module__
Out[337]: '__builtin__'

Ausserdem ist die Klasse recht "langweilig", weil sie nichts weiter implementiert. Objekte von diesem Typ dienen ja nur als Namensraum und haben sonst keine weiteren Eigenschaften oder Aufgaben.

Ansonsten ist die einfachste, allgemeinste Beschreibung von einem Objekt wohl: ein "Ding" mit benannten Attributen. Wobei in der Regel einige Attribute Methoden sind, also an das Objekt gebundene Funktionen, die beim Aufruf automatisch das Objekt selbst als erstes Argument übergeben bekommen.

[ratna_fong]

Hallo BlackJack,

Objekte von diesem Typ dienen ja nur als Namensraum

dann heißt es ja, dass zum Beispiel codecs.open() eine Art built-in Funktion ist. Der Unterschied wäre nur dass wir das Modul codecs noch zu explizit zu importieren haben.

Ist es denn wirklich falsch, wenn ich codecs in codecs.open() mit zum Beispiel cout oder cin als gleich betrachte?

[BlackJack]

@ratna_fong: Wieso ist `codecs.open()` eine Art builtin-Funktion? Als "built-in" bezeichnet man bei Python eigentlich die Objekte, die tatsächlich in den Interpreter eingebaut sind und in der Regel über das `__builtin__`-Modul erreichbar sind. `codecs` ist ein ganz normales Modul, das als Python-Quelltext bzw. Bytecode-Datei in der Standardbibliothek vorliegt und die `codecs.open()`-Funktion ist auch in Python geschrieben.

Abgesehen von `__builtin__` ist es IMHO ein Implementierungsdetail ob ein Modul eingebaut ist, oder als eigene Datei ausserhalb der Laufzeitumgebung existiert.

Was hast Du immer mit `cin` und `cout`? In wie fern sollte eine Funktion mit diesen beiden Objekten "gleich" sein? Welche Eigenschaften sollen da verglichen werden? Es sind alles Objekte. Aber dann sind `cin` und `cout` "das gleiche" wie *alle* Objekte in Python.

[ratna_fong]

Danke für die Antwort BlackJack,

es ist mir grad klar geworden, was mich eigentlich stutzig macht:

codecs ist also ein ganz normales Modul. codecs ist also ein Modulbezeichner.

import codecs:
Es gibt also ein Modul mit dem Namen codecs.

Darauf hin meintest Du, codecs.open() ist eine Funktion in dem obengenannten Modul codecs.

Nun:
Modul heißt codecs
Funktion ist codecs.open()

Also, da fehlt was dazwischen. Ich weiss nicht wie ich das erklären soll, aber für mich fehlt da eine Art Übergang.

Normalerweise:

Modulname: fibonacci

Code: Alles auswählen

class fibonacci:
   def berechne()

#Nun zum Aufruf der Funktion, schreibt man nach der Instantiierung dann:
test.berechne()
#statt
fibonacci.berechne()

Ich weiss nicht, ich finde es sehr irritierend, wenn ich eine Methode aufrufe, indem ich den Klassennamen nehme, statt ein Objekt der Klasse.
Also, statt test.berechne() fibonacci.berechne()

Es kann sein, dass ich grad Apfel und Birne vergleiche. Aber dafür ist der eine oder andere ja da, der vielleicht mir aufklären kann.

Gruss,

Eure Ratna

[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.