Der erste Schritt auf Python zu Wir reden von einer interpretierten, interaktiven und Objekt-orientierten Programmiersprache.
Es enthält Module, exceptions, dynamic typing, highlevel dynamic data types und Klassen.
Python kombiniert bemerkenswerte POWER mit einer einfachen Syntax. Es hat außerdem viele interfaces zu system calls und libraries, aber auch zu grafischen Systemen. Es ist erweiterbar mit C oder mit C++.
Sie koennen Python als eine Erweiterungssprache sehen, die über ein (um-)programmierbares interface verfügt.
Python ist 'portable' (portierbar). Es läuft auf vielen Unix-Varianten, auf dem Mac und auch auf PC's, die DOS, Windows-2000 und/oder Windows-XP mit sich herumschleppen. Eine Skriptsprache ist Python, also eine sogenannte "interpretierte Sprache", was bedeutet, dass wir den von uns geschriebenen Programmcode nicht selber in "Maschinensprache" (Binärcode) mithilfe eines Compilers übersetzen müssen, wie es z.B. bei der Programmiersprache C oder Fortran der Fall ist.
Ein (auch von uns (!) geschriebenes) Pythonprogramm nennt man "python-script" und für die einfachere Wiedererkennung hängen wir dem Namen des Skripts die Endung .py an.
z.B.
erstes.py
Python muss am Rechner installiert sein, wenn man Pythonskripte ausführen möchte!
Es gibt bereits die Version 2.5.X - um aber auf der sicheren Seite zu sein, verwenden wir 2.4.X - auf Unterschiede zu 2.5 und zu 2.3 werde ich versuchen, wenn angebracht, extra einzugehen.
Es werden alle Programme in Pythonskripte aufgeschrieben. Zum Trainieren werden wir aber vorerst viel am Python-Interpreter arbeiten.
um den Python-Interpreter aufzurufen, tippen Sie einfach auf der Kommandozeile "python" ein und sofern der PATH(Pfad) stimmt, wird dieser nach Drücken der RETURN-Taste auch aufgerufen!
host@computer:~$ python
Python 2.4.4 (#2, Apr 5 2007, 20:11:18)
[GCC 4.1.2 20061115 (prerelease) (Debian 4.1.1-21)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
Die drei Größerzeichen markieren den Eingabeprompt für den Python-Interpreter, da kann der user nun Kommandos eintippen, wie auf einer Shell nach dem Eingabeprompt! Verlassen wird der Python-Interpreter mit der Tastenkombination
CTRL-D
Was zum Eingabeprompt der Shell zurückführt.
Eine zweite Möglichkeit, den Python-Interpreter aufzurufen ist folgende Eingabe auf der command-line
host@computer:~$ /usr/bin/env python
Python 2.4.4 (#2, Apr 5 2007, 20:11:18)
[GCC 4.1.2 20061115 (prerelease) (Debian 4.1.1-21)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> credits
Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
for supporting Python development. See www.python.org for more information.
>>>
und wenn Sie fertig sind, erneut mit CTRL-D verlassen und, siehe da, haben Sie auch schon ein erstes Kommando eingetippt und seine Wirkung gesehen...
Alle Kommandos, die hier im aufgerufenen Python-Interpreter funktionieren, klappen auch im Python-Skript! Achtung - stimmt nicht ganz! Im Python-Interpreter brauchen Sie den print-Befehl nicht extra anzuführen, im python-script dafür schon! Deshalb möchte ich mich bei der Nase nehmen, auch am Python-Interpreter immer brav print hinzuschreiben, auch wenn es gar nicht notwendig wäre ... damit sind wir als "Neulinge" in jedem Fall auf der sicheren Seite.
>>> print credits
Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
for supporting Python development. See www.python.org for more information.
>>>
Wollten wir dieses Kommando in ein python-script schreiben, waere die Vorgehensweise folgende:
Wählen Sie Ihren Lieblingseditor aus - ich verwende cat zur besseren Ansicht
host@computer:~> cat > pybsp1.py <<"EOF"
> #! /usr/bin/env python
> # Beispiel1
>
> print credits
>
> # Ende von Beispiel1
> EOF
host@computer:~$ chmod +x pybsp1.py
host@computer:~$ ./pybsp1.py
Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
for supporting Python development. See www.python.org for more information.
host@computer:~$
"#!" ist die sogenannte "sha bang", der dann den Pfad hin zum Interpreter folgen soll, für den die Programmzeilen gedacht sind. In der Unix-Welt wird das Rufzeichen gerne als "bang" bezeichnet!
Wir haben gesehen, dass wir in einem python-script den Interpreter mit der Zeile
#! /usr/bin/env python
aufrufen.
Warum nicht mit
#! /usr/bin/python
??
Nun - /usr/bin/env bedeutet, dass wir das "python-binary" in Ihrem $PATH festgelegten Pfaden suchen - könnte ja sein, dass Sie eine neuere Fassung installiert haben, die unter /usr/local/bin (wird per default noch vor /usr/bin gechecked) liegt!
/usr/bin/python bedeutet, dass nur dieses genommen wird, deshalb ist
/usr/bin/env python
flexibler!
----------------------
so - und weiter geht's im Text
host@computer:~$ python
Python 2.4.4 ( 2, Apr 5 2007, 20:11:18)
[GCC 4.1.2 20061115 (prerelease) (Debian 4.1.1-21)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 2+3+4
9
>>> print 2+3+4
9
>>> print 2+3*4
14
>>> print (2+3)*4
20
>>> print 2**4 # 2 hoch 4
16
>>> print 7/3
2
>>> print 7.0/3
2.33333333333
>>>
Besonders interessant ist hier der Einsatz von runden Klammern - Sie erinnern sich jetzt wohl an Ihre Schulzeit? Wie im Beispiel gezeigt, können Sie dem Interpreter 'sagen', dass er zuerst 2 und 3 addieren soll bevor sie mit 4 multipliziert werden soll.
Auch wesentlich ist die Unterscheidung zwischen "ganzen Zahlen" und den Gleitpunktzahlen - 7/3 alleine ergibt eine ganze Zahl, weil beide Zahlen integer-Zahlen sind. Wird einer dieser Zahlen ein komma-null angehängt, dann wird die Division auch korrekt ablaufen, und diesmal ist das Ergebnis ein richtiges.
>>> a = 3
>>> print a
3
>>>
"a=3" bedeutet, dass wir der Variablen "a" den Wert "3" zuweisen.
Man nennt die Variable auch gerne "identifier", und in Python wird der zugehörige Wert "Objekt" (object) genannt.
So, etwas passiert im Arbeitsspeicher, wenn wir
a = 3
eingeben. (Alles spielt sich im Arbeitsspeicher ab!)
In zwei voneinander getrennten Bereichen des Arbeitsspeichers wird die Variable "a" angelegt, und im anderen das Objekt "3".
Die Variable "a" wird nur dann angelegt, wenn das Objekt 3 existiert, das bedeutet, dass Python zuerst das Objekt im Arbeitsspeicher anlegt, und dann die Variable, die darauf zeigt. Die Variable ist also in Python auch gleichzeitig ein "Zeiger". Eine Variable "zeigt" immer auf ein Objekt!! Sie zeigt NIEMALS auf eine andere Variable!!
Die Verbindung einer Variablen zu einem Objekt nennt man auch "Referenz".
>>> b = 3
>>> print b
3
>>>
Wir haben eine neue Variable angelegt, die auf das gleiche Objekt zeigt, wie "a" , nämlich auf das Objekt "3". Viele Variablen können auf ein und dasselbe Objekt zielen - das Objekt muss nicht jedes Mal neu angelegt werden - es müssen nicht zwei Objekte "3" im Arbeitsspeicher sein ==> das hilft Platz sparen! - zwei Variablen namens "a" und "b" zeigen auf das gleiche Objekt. Wenn ich frage, auf was für ein Objekt die Variable "a" zeigt, dann prüft das System (bildlich gesprochen), wo der Pfeil im Objektbereich des Arbeitsspeichers endet, der von der befragten Variable im "Variablenbereich des Arbeitsspeichers" weggeht. Und nicht vergessen - eine Variable wird nur dann im Arbeitsspeicher angelegt, wenn sie auf ein Objekt zeigt!
Also, wann wird eine Variable angelegt??
>>> c =
File "<stdin>", line 1
c =
^
SyntaxError: invalid syntax
>>> print c
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'c' is not defined
>>>
Der Variablen c wurde kein Objekt zugewiesen ==> Fehlermeldung. Da die Variable "c" nicht angelegt werden konnte, ging auch nicht der print-Befehl, weil es eben keine Variable "c" gibt!
>>> a = 5
>>> print a
5
>>>
Es wurde ein Objekt "5" im Arbeitsspeicher erzeugt, der Pfeil von "a" auf "3" wurde nun auf das Objekt "5" (um)gelenkt - "a" zeigt nun auf "5", und nicht mehr auf "3"! Nur "b" zeigt noch auf das Objekt "3".
>>> b = 4
>>> print b
4
>>>
Das gleiche noch einmal - die Variable "b" zeigt nun auf das neu erstellte Objekt "4" . Was passiert nun mit dem Objekt "3"?? Wenn keine Variable mehr da ist, die auf das Objekt "3" zeigt, wird der Speicherplatz, in dem das Objekt "3" liegt, zum Überschreiben freigegeben - kurz, der Speicherplatz wird freigegeben und bei Bedarf wird er durch ein anderes Objekt belegt.
So - jetzt liegen in einem die Variablennamen, und im anderen Bereich die Objekte.
Sie können alle Buchstaben verwenden, von a-z und von A-Z. Es wird zwischen Groß- und Kleinschreibung unterschieden (das nennt man "case sensitive").
Variablennamen dürfen nicht mit einer Zahl beginnen:
>>> 1ab = 46
File "<stdin>", line 1
1ab = 46
^
SyntaxError: invalid syntax
>>>
Es dürfen aber Zahlen im Variablennamen vorkommen bzw. darf der Variblenname mit einer Zahl enden
>>> a2 = 3
>>> a2b = 3
>>> print a2
3
>>> print a2b
3
>>>
Variablennamen könnten auch mit einem Unterstrich (underscore) beginnen, oder enden, oder beginnen und enden, oder mit zwei underscores beginnen und enden und underscores beinhalten
>>> _a2b = 3
>>> print _a2b
3
>>> a2b_ = 3
>>> print a2b_
3
>>> _a2b_ = 3
>>> print _a2b_
3
>>> _a_2_b_ = 3
>>> print _a_2_b_
3
>>>
Jetzt haben wir gehört; oder besser gesagt gelesen, dass diese Variablen in einem eigenen Bereich des Arbeitsspeichers abgelegt werden. Diesen Bereich nennt man "Namensbereich" (namespace). In einem Namensbereich kommt eine Variable nur einmal vor - es kann aber mehrere Namensbereiche geben, wie wir noch später sehen werden, und in jedem dieser Namensbereiche kann eine Variable namens "a" vorkommen und jeweils auf ein anderes Objekt zeigen. Wollten wir die vergebenen Variablennamen in diesem (aktuellen) Namensbereich uns anzeigen lassen, ist folgendermaßen vorzugehen
>>> dir()
['__builtins__', '__doc__', '__name__', '_a2b', '_a2b_', '_a_2_b_', '
a', 'a2', 'a2b', 'a2b_', 'b']
>>>
Ueber '__builtins__', '__doc__' und '__name__' werden wir uns noch gesondert unterhalten muessen.
>>> a&*b = 3
File "<stdin>", line 1
a&*b = 3
^
SyntaxError: invalid syntax
>>>
Das passiert, wenn Sie versuchen, Sonderzeichen in Variablennamen einzubauen. Es ist meiner Meinung nach auch gar nicht notwendig, denn die Auswahl an möglichen Variablennamen ist ohnehin groß genug.
Es gibt sogenannte "Schlüsselwörter", die in Python eine besondere Bedeutung haben. Was ist damit gemeint?
Sie sehen schon, dass wir mit dem Kommando "print" uns das Objekt ausgeben lassen, auf das eine Variable im Arbeitsspeicher zeigt. Es ist dem System absolut unmöglich zu unterscheiden, wenn Sie "print" als Variablennamen einsetzen wollten, ob Sie bei der Eingabe von "print" die Variable oder das Kommando meinen
>>> print = 3
File "<stdin>", line 1
print = 3
^
SyntaxError: invalid syntax
>>>
Deshalb geht das System immer davon aus, dass bei Eingabe von "print" das Kommando gemeint ist. "print" ist also eines jener Schlüsselwörter (oder geschützten Wörter), die nicht als Variablennamen genommen werden können. Derer gibt es noch (müssen Sie sich nicht gleich merken - bekommen ohnehin eine Fehlermeldung, wollten Sie so einen Namen für eine Variable verwenden)
and del for is raise
assert elif from lambda return
break else global not try
class except if or while
continue exec import pass
def finally in print
Das war es fürs Erste über Variablennamen.
interessant ist auch, dass es Ausdrücke bzw. Zuweisungen geben kann, die folgendermaßen aussehen
>>> a=3
>>> b=4
>>> a,b=b,a
>>> print a,b
4 3
>>>
Beim 'Austausch' der jeweiligen Objekte zwischen den Objekten"a" und "b" hat man sich so eine zusätzliche Programmzeile erspart!
|
