Python-Programmierung: Ausdrücke

Aus Wikibooks

<< Inhaltsverzeichnis

[Bearbeiten] Ausdrücke und Operatoren

Als Ausdruck bezeichnet man in der Informatik eine Berechnungsvorschrift. Das Ergebnis eines Ausdruckes kann ausgegeben oder einer Variable zugewiesen werden.

Der einfachst mögliche Ausdruck in Python besteht aus einer Konstante beliebigen Typs:

>>> 1                         
1
>>> "Hallo"
'Hallo'

Wesentlich interessanter sind natürlich zusammengesetzte Ausdrücke, wie etwa:

>>> 768 / 16
48
>>> '*' * 10
'**********'

Im Folgenden betrachten wir die in Python möglichen zusammengesetzten Ausdrücke. Sie sind nach dem Datentyp des jeweiligen Ausdruckes (genauer: seines Ergebnisses) gegliedert.

[Bearbeiten] Arithmetik

Für arithmetische Berechnungen finden die in Programmmiersprachen üblichen Operatoren Verwendung. Diese sind + für Addition, - für Subtraktion, * für Multiplikation, / für die Division und % für Modulo (Rest einer Division).

>>> 2 + 3
5
>>> 100 - 33
67
>>> 5 * 4
20
>>> 100 / 4
25
>>> 100 % 3
1

Außerdem kann das unäre Minus zur Vorzeichenänderung eines Wertes verwendet werden.

>>> - (-1)
1

Als Exponential-Operator wird in Python ** eingesetzt; also ist X ** Y der Wert X hoch Y:

>>> 2 ** 4
16
>>> 3 ** 3
27

Wie in der Mathematik gewohnt, gilt: "Punkt- vor Strichrechnung". Durch Klammerung läßt sich die Auswertungsreihenfolge beeinflussen:

>>> 2 + 3 * 4
14
>>> (2 + 3) * 4
20

[Bearbeiten] Vergleiche

Beliebige Ausdrücke können mit == und  != auf Gleichheit oder Ungleichheit getestet werden.

>>> True == None
False
>>> 1 != ""
True

Außerdem gelten die üblichen Vergleichsoperatoren < und > bzw. <= und >= zur Überprüfung der Ordnung von Ausdrücken.

>>> 5 > 4
True
>>> 1 >= 2
False

In Python ist jeder Ausdruck geordnet. Bei arithmetischen Ausdrücken gilt die für Zahlen übliche Ordnung. Listen, Tupel und Zeichenketten unterliegen der sog. lexikographischen Ordnung:

>>> "Hall" < "Hallo"
True
>>> [1, 2, 3] > [1, 2]
True

[Bearbeiten] Logik

Logische Ausdrücke werden meist eingesetzt, um den Programmablauf zu steuern, etwa in Fallunterscheidungen (if-Anweisung) oder Schleifen (while-Anweisung). Die grundlegenden Operatoren sind and für die logische Konjunktion, or für die Disjunktion, bzw. not für die Negation.

>>> True and False
False
>>> True and not False
True
>>> True or False
True

Im Gegensatz zu Programmiersprachen mit striktem Typ-System kann in Python ein logischer Ausdruck aus fast beliebigen Elementen gebildet werden, wobei leere Strings, Dictionaries, Tupel und Listen sowie die Zahl Null als False ausgewertet werden, alles andere als True:

>>> "" and 1
""
>>> True and ""
""
>>> 1 or 2
1
>>> 1 and []
[]

Wie man im vorigen Beispiel gut erkennen kann, werden logische Ausdrücke mitunter nur teilweise berechnet, sofern aufgrund des links stehenden Wertes einer and bzw. or-Verknüpfung der Wert des Gesamt-Ausdruckes bereits feststeht.

[Bearbeiten] Element-Beziehung

Mit in bzw. not in läßt sich prüfen, ob ein Wert in einer Sequenz enthalten ist oder nicht. Sequenzen, auf die sich dieser Test anwenden läßt, sind Tupel, Listen und Zeichenketten.

>>> 1 in (1, 2, 3)
True
>>> "1" in "123"
True
>>> 1 in [1, 2, 3]
True
>>> 4 not in (1, 2, 3)
True

[Bearbeiten] Bit-Arithmetik

Für logische Operationen auf Bit-Ebene gibt es & für Konjunktion bzw. bitweises AND, | für Disjunktion bzw. bitweises OR, ^ für den Sheffer-Operator bzw. bitweises XOR, sowie ~ für Negation bzw. bitweises NOT.

>>> 3 | 5
7
>>> 3 & 5
1
>>> ~5
-6
>>> 3 ^ 5
6

[Bearbeiten] Zeichenketten

Zeichenketten können mit + verknüpft und mit * wiederholt werden:

>>> "abc" + "def"
'abcdef'
>>> "abc" * 5
'abcabcabcabcabc'

[Bearbeiten] Der Formatierungs-Operator

Zur Formatierung von Zeichenketten dient der %-Operator. Er erwartet links eine Zeichenkette mit Ersetzungszeichen und rechts einen Wert oder ein Tupel von Werten.

>>> "%s mene %s" % ("ene", "mopel")
'ene mene mopel'
>>> "123 = 0x%x" % 123
'123 = 0x7b'
>>> "0x7b = %d" % 0x7b
'0x7b = 123'
>>> "Pi = %f" % 3.14159265
'Pi = 3.141593'
>>> "%f" % True
'1.000000'

[Bearbeiten] Sequenzen

Als Sequenzen werden Tupel (1, 2, 3) und Listen [1, 2, 3] bezeichnet. Im Gegensatz zu Dictionaries sind Sequenzen geordnet, d.h. jedes Element hat eine eindeutige Position, ab Position 0 (Null) für das erste Element der Liste bis -1 für das letzte Element.

# Erstes Element
>>> (3, 4, 5)[0]
3

# Letztes Element
>>> (3, 4, 5)[-1]
5

# Vorletztes Element
>>> (3, 4, 5)[-2]
4

In Python kann man aus Sequenzen eine Teilsequenz heraustrennen, indem man die Positionen [von : bis] in eckigen Klammern angibt. Wenn von oder bis fehlen, wird jeweils der Anfang der Sequenz (0) bzw. deren Ende (-1) angenommen.

# Nulltes und erstes Element extrahieren
>>> (3, 4, 5) [:2]
(3, 4)

# Alle Elemente ab dem zweiten Element
>>> (3, 4, 5) [2:]
(5,)

# Sequenz kopieren (alle Elemente)
>>> (3, 4, 5) [:]
(3, 4, 5)

[Bearbeiten] Listen-Generatoren

Das Konzept der Listen-Generatoren stammt aus dem Umfeld der funktionalen Programmiersprachen und wurde erst relativ spät in Python übernommen. Es bietet eine sehr kompakte Schreibweise für Operationen auf Listen-Elementen, wie das folgende Beispiel anhand der Berechnung von Quadraten zeigt:

# Grund-Sequenz: 0..9
>>> to_ten = range( 10)
>>> to_ten
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Bilde Quadrate per Listengenerator
>>> [ x ** 2 for x in to_ten ]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Die generelle Form eines Listengenerators ist: [ Ausdruck for Variable in Liste ] oder mit einer zusätzlichen Filter-Bedingung: [ Ausdruck for Variable in Liste if Bedingung ]. Im folgenden Beispiel werden Quadrate ungerader Zahlen per Listengenerator gebildet:

>>> [ x ** 2 for x in to_ten if x % 2 ]
[1, 9, 25, 49, 81]

[Bearbeiten] (Anonyme) Funktionen

Man kann Funktionen einer Variablen zuweisen oder sie als Argument an Funktionen oder Methoden übergeben.

# Funktions-Definition
>>> def square( x): return x ** 2

# Zuweisung einer Funktion an eine Variable
>>> quadrat = square

# Aufruf unter neuem Namen
>>> quadrat( 3)
9

# Funktion wird als Argument an eine weitere Funktion übergeben
>>> map( quadrat, range(10))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Aus den funktionalen Programmiersprachen wurde das Konzept der anonymen Funktionen entlehnt. In der Literatur wird dies auch häufig als Lambda-Kalkül bezeichnet. Es erlaubt, "mal eben" eine Funktion zu definieren. Die allgemeine Schreibweise ist: lambda Variable : Ausdruck

Im folgenden Beispiel wird die Quadratreihe des letzten Beispieles mithilfe einer anonymen Funktion realisiert:

>>> map( lambda x: x ** 2, range(10))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

[Bearbeiten] Anwendungsbeispiel

Das folgende Beispiel implementiert das Schulbuch-Verfahren des Eratosthenes zur Ermittlung von Primzahlen mithilfe anonymer Funktionen und Listengeneratoren. Das Beispiel ist absichtlich einfach gehalten und für eine bessere Lesbarkeit nicht auf Effizienz optimiert.

#!/usr/bin/python
#
# Sieb des Eratosthenes zur Bestimmung von Primzahlen
# Beispiel zum Gebrauch von Listengeneratoren und anonymen Funktionen
#
# Dies ist ein Lehrbeispiel, der Code ist absichtlich nicht optimiert.
#
# Autor: Daniel Knauth 2005/01/03
 
# Der zu durchsuchende Zahlenbereich
numbers = range( 2, 500)
 
# Sieb wird mit dem gesamten Wertebereich gefüllt...
sieve = numbers 
 
# ... aus dem dann alle Vielfachen von Primzahlen entfernt werden.
for prime in sieve:
   sieve = filter( lambda x: x not in [ prime * num for num in numbers ], sieve)
 
# Ergebnis ausgeben
print sieve

So, liebe C / C++ / Java-Programmierer: Wir Pythonesen können das in 5 Code-Zeilen netto implementieren. Könnt Ihr das auch?

<< Inhaltsverzeichnis