Programmierung I Basics (in Python)

Intro
Skript-Sprache
Programmierung I
Basics (in Python)
Erfinder: Guido von Rossum
Entstehung: 1987
Web-Seite: www.python.org
Newsgroup: comp.lang.python
Noch relativ aktiv weiterentwickelt (PEPs):
Wintersemester 2004/2005
University Bonn
Dr. Gabriel Zachmann
Programming Languages History
„Python Enhancement Proposal“
http://www.python.org/peps/
Wohldefinierte Prozedur unter Einbeziehung der
Community
Woraus besteht ein Programm?
Abstrakt: Zeichenfolge entsprechend einer formalen
Grammatik
Formale Grammatik besteht aus Regeln folgender Art:
statement-list :
;
[leeres Statement]
statement ; statement-list
Terminale sind Zeichen eines Alphabets
Spätere Vorlesung zu formalen Sprachen
Konkret:
Wörter (Identifier) und Zahlen (Literals)
Operatoren (+, %, &, … )
Sonstige Sonderzeichen (fast jedes hat eine eigene Bedeutung)
Kommentare
Werden ignoriert
Startet mit #, bis zum Ende der Zeile
x = 10; # Bedeutung der Variable
# Kommentarzeile
Identifier
Anderes Wort für Name (Variablename, Funktionsname,
Keywordname)
Zeichenkette
Zugelassen: alphanumerische Zeichen und Underscore (_)
Erstes Zeichen darf nicht Ziffer sein
blub und _bla sind ok
2pi nicht ok
Kein Limit auf Länge
Case-sensitiv
1
Keywords
Eingebaute (built-in) Wertarten (Typen)
Wörter mit spezieller Bedeutung
int : Integers (ganze Zahlen)
Sind reserviert, kann man nicht als Namen verwenden
bool : Wahrheitswerte
float : Floating-Point-Zahlen (floats) ("reelle Zahlen")
and
assert
break
class
continue
def
Keywords in Python
del
for
elif
from
else
global
except
if
exec
import
finally
in
is
lambda
not
or
pass
print
raise
return
try
while
yield
str : Strings (Zeichenketten)
Höhere Datenstrukturen
List : später
Komplexe zahlen, Dictionary, Map, Sequence, Set, Module, File, …
Variablen
Literale
Zahlen
int's, decimal, octal, hex
long integer
floats
scientific notation
123 O123 0x123
123l
3.14f 3.14
3e-2 0.03 0.3e-1
Strings
""
"name"
"a \"string\""
"a string "
"spanning two lines"
null string (‘\0’)
‘n’ ‘a’ ‘m’ ‘e’ ‘\0’
prints: a "string"
string concatenation for
better readability
Spezielle Zeichen
in Strings
(escape sequence)
\n
\r
\t
\b
\”
\f
\\
\0
\’
\x041
Bool (Wahrheitswerte)
False, 0, None, ""
Alles andere, z.B.:
True, 1, "0", 0.1, …
falsch
wahr
Wertebereiche
Jeder Typ hat bestimmten Wertebereich
Plattform-abhängig!
Symbolische Konstanten:
import sys
print sys.maxint
import kinds
print kinds.default_float_kind.MIN
newline
carriage return
tab
backspace
double quote
form feed
backslash
null character
single quote
hex, ‘A’
Ähnliche Funktion wie in Mathematik, speichert Wert
Variable = Name und Wert
In Python:
Variablen haben keinen Typ
Ist nur “Zeiger” auf Wert im Speicher, kann beliebig oft geändert
werden
Braucht nicht deklariert werden
Erzeugung / Initialisierung:
pi = 3.1415926
# erzeugt Variable
seconds_per_day = 60*60*24 # dito
seconds_per_day = 86400
# ändert Wert
Style Guidelines für Variablen
Style Guidelines sind sehr wichtig:
Lesbarkeit
Wartbarkeit des Programms
"Kleine" Variablen:
Laufvariablen, Variablen mit sehr kurzer Lebensdauer
1-3 Buchstaben
i,j,k,… für int's
a,b,c,x,y,z … für float's
"Große" Variablen:
Längere Lebensdauer, größere Bedeutung
Labeling names! ("Sprechende Namen")
mein_alter, meinAlter, determinante, …
2
Operatoren und Ausdrücke
Ausdruck ("expression") = mathematischer Term
Beispiel: sin(x)*sin(2*x)
FORTRAN (Formula Translator) war Ende der 50er Jahre
die erste Programmiersprache mit dieser Fähigkeit
Ausdruck setzt sich zusammen aus:
Literalen (Konstanten), Variablen, Funktionen
Operatoren
Klammern
Übliche Regeln
Ganzzahlarithmetik
Wertebereich
Typischerweise -231 ... 231-1 (32-bit int's)
Overflow:
Kein Überlauf in Python!
Integers können beliebig lang werden
Division:
Operanden bestimmen, ob Integer- oder Float-Division!
Bsp.: 3/2 Æ 1, 3.0/2 Æ 1.5
Rundet nach unten (oder zur 0)!
Beispiel: 3/2 == 1, und -3/2 == -2
Division und Modulo: (x/y)*y + x%y == x
Vergleichsoperatoren
Operanden sollten gleichen Typ haben
Resultat: Wahrheitswert (in Python: 0 oder 1)
Achtung: verwechsle nicht = und == !
Arithm. Operator
-i
+w
a*b
a/b
i%2
a+b
a-b
i=3
a=3.0
Bit-wise
~ i
i & j
i | j
i ^ j
i << n
i >> n
Operators
bitwise Complement
bitwise AND
bitwise OR
bitwise XOR
left shift (n positions)
right shift (n positions)
Assignment op.
x □= y
Bsp.:
x -= y
x /= y
x &= y
Relational Operators
Meaning
unary + and mult., div., modulo
binary + and int/float assignment
<
>
<=
>=
==
!=
less than
greater than
less or equal
greater or equal
equals
not equal
Boolean Operators
not
and
or
unary not
logical and
logical or
equivalent
x = x □ (y)
x = x - y
x = x / y
x = x & y
Float-Arithmetik
Implementiert IEEE 754-1985 Standard
Überlauf ("overflow"):
Zahl wird zu groß / zu klein
Beispiel: max.float * 2
Resultat = +∞ bzw. -∞
Underflow:
Zahlen liegen zu dicht an der 0
Resultat = +0.0 bzw. -0.0
NaN (Not a Number) (in C++):
Rechnungen, wo kein sinnvoller Wert rauskommt
Bsp.: 1/0 , ∞*0 , sqrt(-1.0)
In Python: Fehlermeldung
Richtiger Vergleich von Floating-Point-Werten
Verwendung von == ist fast immer ein Bug!
Bsp.: in Qt 3.1 findet man (qwmatrix.h)
bool isInvertible() {
return (m11*m22 - m12*m21) != 0;
}
Meistens wollen wir "Gleichheit bis auf Rundungsfehler"
Bessere Technik: "epsilon guard"
if fabsf(f1 – f2) < 1E-5 :
# Gleichheit
Noch besser:
if abs(f1 – f2) < 1E-5*f1 :
3
Bit-Operatoren
Präzedenz und Assoziativität
Für integrale Typen definiert (int, ...)
Englisch: "precedence" & "associativity" ("grouping")
Wert wird als Bitmuster betrachtet
Ohne diese ist ein Ausdruck der Art
a+b*c
nicht eindeutig
Beispiele:
x
y
1010
1100
x & y
x | y
x ^ y
1000
1110
0110
~x
0101
~y
0011
Beispiele:
x = x >> 2;
x &= 0x11;
x = x << 3;
if x & 1 :
# x is odd
else:
# x is even
# = x / 4
# = x % 4
# = x * 8
Präzedenz: Reihenfolge der Auswertung der Operatoren
Assoziativität: Reihenfolge bei Operatoren gleicher
Präzedenz
Achtung: Reihenfolge der Auswertung der Operanden
normalerweise nicht festgelegt!
Bsp.: x = f(y) + f(z) – wird zuerst f(y) oder f(z) ausgewertet?
Macht Unterschied, falls f() Nebeneffekte hat
Fazit: Nebeneffekte sind schlechter Stil!
Präzedenz-Tabelle
Präzedenz
Short circuit logic bei Boole'schen Ausdrücken
Operator
[] ()
~ + * / %
+ << >>
< … >=
== !=
&
^
not
and
or
= += … |=
Grouping
L-R
R-L
L-R
L-R
L-R
L-R
L-R
L-R
L-R
L-R
L-R
L-R
R-L
and und or werden von links nach rechts ausgewertet
Falls Wahrheitswert feststeht, keine weitere Auswertung!
true or x → true
false and x → false
Im Standard festgelegt
Kann sehr praktisch sein, kann Performance steigern
Nicht einsetzen in komplexen Ausdrücken
Dokumentieren!
Beispiel:
Nicht ganz vollständig
if foo(x) and foo(y) :
Einrahmen und über den Monitor hängen!
Listen
Statements (Anweisungen)
Folge beliebiger Werte
Beispiele von Listen-Literalen:
l = [ 1, 2, 3 ]
l = [ "null", "acht", 15 ]
Erzeugen einer Liste von Zahlen mit range :
Syntax: range(start[,stop[,step]])
Beispiel:
x = range(0,100)
x = range(10)
# 0, ..., 99
# 0, ..., 9
Die Bausteine eines Programms mit Effekt
(normalerweise)
Programm ist lange Liste von Anweisungen
Stil: eine Anweisung pro Zeile (kein Semikolon nötig)
Anweisung =
Leere Anweisung ( pass )
Ausdruck (nicht alle haben einen Effekt)
Deklarationen (Funktionen, Klassen, …; später)
Kontrollfluß-Statement (demnächst)
Zugriff auf einzelnes Element:
print x[1]
4
Beispiele:
i = j
i += 1
x + y
z = x + y
print z*y
5