Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.

...powered by haas.homelinux.net...

Inhaltsverzeichnis
1 Einleitung
2 Überblick über Python
3 Die Arbeit mit Python
4 Der interaktive Modus
5 Grundlegendes zu Python-Programmen
6 Kontrollstrukturen
7 Das Laufzeitmodell
8 Basisdatentypen
9 Benutzerinteraktion und Dateizugriff
10 Funktionen
11 Modularisierung
12 Objektorientierung
13 Weitere Spracheigenschaften
14 Mathematik
15 Strings
16 Datum und Zeit
17 Schnittstelle zum Betriebssystem
18 Parallele Programmierung
19 Datenspeicherung
20 Netzwerkkommunikation
21 Debugging
22 Distribution von Python-Projekten
23 Optimierung
24 Grafische Benutzeroberflächen
25 Python als serverseitige Programmiersprache im WWW mit Django
26 Anbindung an andere Programmiersprachen
27 Insiderwissen
28 Zukunft von Python
A Anhang
Stichwort

Download:
- ZIP, ca. 4,8 MB
Buch bestellen
Ihre Meinung?

Spacer
 <<   zurück
Python von Peter Kaiser, Johannes Ernesti
Das umfassende Handbuch - Aktuell zu Python 2.5
Buch: Python

Python
gebunden, mit CD
819 S., 39,90 Euro
Galileo Computing
ISBN 978-3-8362-1110-9
Pfeil 8 Basisdatentypen
  Pfeil 8.1 Operatoren
  Pfeil 8.2 Das Nichts – NoneType
  Pfeil 8.3 Numerische Datentypen
    Pfeil 8.3.1 Ganze Zahlen – int, long
    Pfeil 8.3.2 Gleitkommazahlen – float
    Pfeil 8.3.3 Boolesche Werte – bool
    Pfeil 8.3.4 Komplexe Zahlen – complex
  Pfeil 8.4 Methoden und Parameter
  Pfeil 8.5 Sequenzielle Datentypen
    Pfeil 8.5.1 Listen – list
    Pfeil 8.5.2 Unveränderliche Listen – tuple
    Pfeil 8.5.3 Strings – str, unicode
  Pfeil 8.6 Mappings
    Pfeil 8.6.1 Dictionary – dict
  Pfeil 8.7 Mengen
    Pfeil 8.7.1 Mengen – set
    Pfeil 8.7.2 Unveränderliche Mengen – frozenset


Galileo Computing - Zum Seitenanfang

8.3 Numerische Datentypen  Zur nächsten ÜberschriftZur vorigen Überschrift

Die numerischen Datentypen sind eine Kategorie, zu der fünf Basisdatentypen gehören: int und long zum Speichern von ganzen Zahlen, float für Gleitkommazahlen, complex für komplexe Zahlen und bool für boolesche Werte. Alle numerischen Datentypen sind immutable, also unveränderlich. Beachten Sie, dass dies nicht bedeutet, dass es keine Operatoren gibt, um Zahlen zu verändern, sondern vielmehr, dass nach jeder Veränderung eine neue Instanz des jeweiligen Datentyps erzeugt werden muss. Aus Sicht des Programmierers besteht also zunächst kaum ein Unterschied.

Für alle numerischen Datentypen sind folgende Operatoren definiert:


Tabelle 8.1  Gemeinsame Operatoren numerischer Datentypen
Operator Ergebnis

x + y

Summe von x und y

xy

Differenz von x und y

x * y

Produkt von x und y

x / y

Quotient von x und y

x % y

Rest beim Teilen von x durch y (außer bei complex)

+x

Positives Vorzeichen, lässt x unverändert

-x

Negatives Vorzeichen – Vorzeichenwechsel bei x

x ** y

x hoch y

x // y

Abgerundeter Quotient von x und y (außer bei complex)



Hinweis
Sollten Sie bereits eine C-ähnliche Programmiersprache beherrschen, wundern Sie sich zu Recht, denn in Python existiert kein Operator für Inkrementierungen (x++) oder Dekrementierungen (x--).


Neben diesen grundlegenden Operatoren existiert in Python eine Reihe zusätzlicher Operatoren. Oftmals möchte man beispielsweise die Summe von x und y berechnen und das Ergebnis in x speichern, x also um y erhöhen. Dazu ist mit den obigen Operatoren folgende Anweisung nötig:

x = x + y

Für solche Fälle gibt es in Python sogenannte erweiterte Zuweisungen (engl. augmented assignments), die als eine Art Abkürzung für die obige Anweisung angesehen werden können.


Tabelle 8.2  Gemeinsame Operatoren numerischer Datentypen
Operator Entsprechung

x += y

x = x + y

x -= y

x = x – y

x *= y

x = x * y

x /= y

x = x / y

x %= y

x = x % y

x **= y

x = x ** y

x //= y

x = x // y

Wichtig ist, dass Sie hier für y einen beliebigen arithmetischen Ausdruck einsetzen können, während x ein Ausdruck sein muss, der auch als Ziel einer normalen Zuweisung eingesetzt werden könnte.

Für die Datentypen int, long, float und bool sind außerdem vergleichende Operatoren definiert. Da komplexe Zahlen prinzipiell nicht sinnvoll anzuordnen sind, lässt der Datentyp complex nur die Verwendung der ersten drei Operatoren zu:


Tabelle 8.3  Gemeinsame Operatoren numerischer Datentypen
Operator Ergebnis

==

Wahr, wenn x und y gleich sind

!=

Wahr, wenn x und y verschieden sind

<>

Analog zu !=, bitte nicht verwenden

<

Wahr, wenn x kleiner ist als y (außer bei complex)

<=

Wahr, wenn x kleiner oder gleich y ist (außer bei complex)

>

Wahr, wenn x größer ist als y (außer bei complex)

>=

Wahr, wenn x größer oder gleich y ist (außer bei complex)


Jeder dieser vergleichenden Operatoren liefert als Ergebnis einen Wahrheitswert. Ein solcher Wert wird zum Beispiel als Bedingung einer if-Anweisung erwartet. Die Operatoren könnten also folgendermaßen verwendet werden:

if x < 4: 
    print "x ist kleiner als 4"

Es können beliebig viele der vergleichenden Operatoren zu einer Reihe verkettet werden. Das obere Beispiel ist genau genommen nur ein Spezialfall dieser Regel, mit lediglich zwei Operanden. Die Bedeutung einer solchen Verkettung entspricht der mathematischen Sichtweise und soll am folgenden Beispiel zu erkennen sein:

if 2 < x < 4: 
    print "x liegt zwischen 2 und 4"

Mehr zu booleschen Werten folgt im Unterabschnitt des entsprechenden Basisdatentyps bool.

Numerische Datentypen können ineinander umgeformt werden. Dabei können je nach Umformung Informationen verloren gehen. Als Beispiel betrachten wir einige Konvertierungen im interaktiven Modus:

>>> float(33) 
33.0 
>>> int(33.5) 
33 
>>> bool(12) 
True 
>>> complex(True) 
 (1+0j)

Allgemein wird zunächst der Name des Datentyps geschrieben, in den konvertiert werden soll, gefolgt von dem zu konvertierenden Wert in Klammern. Statt eines konkreten Literals kann auch eine Referenz eingesetzt werden bzw. eine Referenz mit dem entstehenden Wert verknüpft werden:

>>> var1 = 12.5 
>>> int(var1) 
12 
>>> var2 = int(40.25) 
>>> var2 
40

So viel zur allgemeinen Einführung in die numerischen Datentypen. Die folgenden Abschnitt werden jeden dieser Datentypen im Detail behandeln.


Galileo Computing - Zum Seitenanfang

8.3.1 Ganzzahlen – int, long  Zur nächsten ÜberschriftZur vorigen Überschrift

Im Raum der ganzen Zahlen gibt es in Python zwei Datentypen: den Typ int für den begrenzten Zahlenraum von –231  bis 231  – 1 (auf 32-Bit-Systemen) und den Typ long für ganze Zahlen, deren Länge theoretisch unbegrenzt ist.

Der Datentyp int hat dabei durchaus seine Berechtigung, da er intern als ein Datenwort der zugrunde liegenden Rechnerarchitektur gespeichert wird und somit sehr schnell verarbeitet werden kann. Um mit dem Datentyp long zu arbeiten, muss intern sehr viel mehr Aufwand betrieben werden, weshalb die Verarbeitung von int im Verhältnis zu long grundsätzlich schneller ist. Falls das Ergebnis einer Operation nicht mehr durch den Datentyp int abgebildet werden kann, erzeugt Python automatisch eine Instanz vom Typ long. Vor dem Programmierer bleibt das in den meisten Fällen verborgen.

Der bevorzugte Datentyp für ganze Zahlen ist int. Möchte man eine Zahl explizit als long definieren, so kennzeichnet man dies durch ein L oder l am Ende des Literals. Auch wenn beides zulässig ist, empfehlen wir hier, stets ein großes L zu verwenden, da das kleine allzu häufig, und gerade am Ende einer Zahl, mit der 1 (Eins) verwechselt wird:

v_int = 12345 
v_long = 12348975128537394593873245L

Zahlensysteme

Ganze Zahlen, egal ob int oder long, können in Python in mehreren Zahlensystemen geschrieben werden.

  • Zahlen, die, wie im obigen Beispiel, ohne ein spezielles Präfix geschrieben sind, werden im Dezimalsystem interpretiert. Zu beachten ist, dass einer solchen Zahl keine führenden Nullen vorangestellt werden dürfen:
v_dez1 = 1337 
v_dez2 = 1337L
  • Eine führende Null kennzeichnet eine Zahl, die im Oktalsystem geschrieben wurde. Die Verwendung des Oktalsystems ist ein Relikt aus älteren Zeiten und wird heute kaum noch benötigt. Beachten Sie, dass hier nur Ziffern von 0 bis 7 erlaubt sind:
v_okt1 = 02471 
v_okt2 = 02471L
  • Die nächste und weitaus gebräuchlichere Variante ist das Hexadezimalsystem, das durch das Präfix 0x bzw. 0X gekennzeichnet wird. Die Zahl selbst darf aus den Ziffern 0 - 9 und den Buchstaben AF bzw. af gebildet werden:
v_hex1 = 0x5A3F 
v_hex2 = 0X5a3fL

Für alle diese Literale ist die Verwendung eines negativen Vorzeichens möglich:

>>> -1234 
-1234 
>>> -0777 
-511 
>>> -0xFF 
-255

Vielleicht möchten Sie sich nicht auf diese drei Zahlensysteme beschränken, die von Python explizit unterstützt werden, sondern ein exotischeres verwenden. Natürlich gibt es in Python nicht für jedes mögliche Zahlensystem ein eigenes Literal. Stattdessen können Sie sich folgender Schreibweise bedienen:

v_6 = int("54425", 6)

Es handelt sich um eine alternative Methode, eine Instanz des Datentyps int zu erzeugen und mit einem Anfangswert zu versehen. Dazu werden in den Klammern ein String, der den gewünschten Initialwert in dem gewählten Zahlensystem enthält, sowie die Basis dieses Zahlensystems als ganze Zahl geschrieben. Beide Werte müssen durch ein Komma getrennt werden. Im Beispiel wurde das Sechsersystem verwendet.

Python unterstützt Zahlensysteme mit einer Basis zwischen 2 und 36. Wenn ein Zahlensystem mehr als zehn verschiedene Ziffern zur Darstellung einer Zahl benötigt, werden zusätzlich zu den Ziffern 0 bis 9 die Buchstaben des englischen Alphabets A bis Z verwendet.

v_6 hat jetzt den Wert 7505 (im Dezimalsystem).

Beachten Sie, dass es sich bei den Zahlensystemen nur um eine alternative Schreibweise des gleichen Wertes handelt. Der Datentyp int springt beispielsweise nicht in eine Art Hexadezimalmodus, sobald er einen solchen Wert enthält. Ein Zahlensystem ist nur bei Wertzuweisungen oder -ausgaben von Bedeutung. Standardmäßig werden alle Zahlen im Dezimalsystem ausgegeben:

>>> v1 = 0xFF 
>>> v2 = 0777 
>>> v1 
255 
>>> v2 
511

Wir werden später, im Zusammenhang mit Strings, darauf zurückkommen, wie sich Zahlen in anderen Zahlensystemen ausgeben lassen.

Bit-Operationen

Neben dem Hexadezimal- und dem Oktalsystem ist in der Informatik das Dualsystem von großer Bedeutung. Das Dualsystem, oder auch Binärsystem, ist ein Zahlensystem mit der Basis 2. Eine ganze Zahl wird also als Folge von Einsen und Nullen dargestellt. In Python existiert kein Literal, mit dem Zahlen in Dualschreibweise direkt verwendet werden könnten, jedoch sind für die Datentypen int und long einige Operatoren definiert, die sich explizit auf die binäre Darstellung der Zahl beziehen:


Tabelle 8.4  Bit-Operatoren der Datentypen int und long
Operator Ergebnis

x & y

Bitweises UND von x und y (AND)

x | y

Bitweises nicht ausschließendes ODER von x und y (OR)

x ^ y

Bitweises ausschließendes ODER von x und y (XOR)

~x

Bitweises Komplement von x

x << n

Bitverschiebung um n Stellen nach links

x >> n

Bitverschiebung um n Stellen nach rechts


Auch hier sind erweiterte Zuweisungen mithilfe der folgenden Operatoren möglich:


Tabelle 8.5  Bit-Operatoren der Datentypen int und long
Operator Entsprechung

x &= y

x = x & y

x |= y

x = x | y

x ^= y

x = x ^ y

x <<= n

x = x << n

x >>= n

x = x >> n

Da vielleicht nicht jedem unmittelbar klar ist, was die einzelnen Operationen bewirken, möchten wir sie im Folgenden im Detail besprechen.

Das bitweise UND zweier Zahlen wird gebildet, indem beide Zahlen in ihrer Binärdarstellung Bit für Bit miteinander verknüpft werden. Die resultierende Zahl hat in ihrer Binärdarstellung genau da eine 1, wo die jeweiligen Bits der Operanden übereinstimmen, und es hat da eine 0, wo sich diese unterscheiden. Dies soll durch die folgende Grafik veranschaulicht werden:

Abbildung 8.1  Bitweises UND

Im interaktiven Modus von Python probieren wir aus, ob das bitweise UND mit den in der Grafik gewählten Operanden tatsächlich das erwartete Ergebnis zurückgibt:

>>> 106 & 12 
8

Diese Prüfung des Ergebnisses werden wir nicht für jede Operation einzeln durchführen. Um allerdings mit den bitweisen Operatoren vertrauter zu werden, lohnt es sich, hier ein wenig zu experimentieren.

Das bitweise ODER zweier Zahlen wird gebildet, indem beide Zahlen in ihrer Binärdarstellung Bit für Bit miteinander verglichen werden. Die resultierende Zahl hat in ihrer Binärdarstellung genau da eine 1, wo mindestens eines der jeweiligen Bits der Operanden 1 ist. Abbildung 8.2 veranschaulicht dies.

Abbildung 8.2  Bitweises nicht ausschließendes ODER

Das bitweise ausschließende ODER zweier Zahlen wird gebildet, indem beide Zahlen in ihrer Binärdarstellung Bit für Bit miteinander verglichen werden. Die resultierende Zahl hat in ihrer Binärdarstellung genau da eine 1, wo sich die jeweiligen Bits der Operanden voneinander unterscheiden, und da eine 0, wo sie gleich sind. Dies wird von Abbildung 8.3 veranschaulicht.

Abbildung 8.3  Bitweises exklusives ODER

Das bitweise Komplement bildet das sogenannte Einerkomplement einer Dualzahl, das der Negation aller vorkommenden Bits entspricht. In Python ist dies auf Bitebene nicht möglich, da eine ganze Zahl in ihrer Länge unbegrenzt ist und das Komplement immer in einem abgeschlossenen Zahlenraum gebildet werden muss. Deswegen wird die eigentliche Bit-Operation zur arithmetischen Operation und folgendermaßen definiert: [Das ist sinnvoll, da man zur Darstellung negativer Zahlen in abgeschlossenen Zahlenräumen das sogenannte Zweierkomplement verwendet. Dieses erhält man, indem man zum Einerkomplement 1 addiert. Also: –x = Zweierkomplement von x = ~x + 1 Daraus folgt: ~ x = –x – 1 ]

~ x = –x – 1

Bei der Bitverschiebung wird die Bitfolge in der binären Darstellung des ersten Operanden um die durch den zweiten Operanden gegebene Anzahl Stellen nach links bzw. rechts verschoben. Die entstandene Lücke wird mit Nullen gefüllt. Abbildung 8.4 und Abbildung 8.5 veranschaulichen eine Verschiebung um zwei Stellen nach links bzw. nach rechts.

Abbildung 8.4  Bitverschiebung um zwei Stellen nach links

Abbildung 8.5  Bitverschiebung um zwei Stellen nach rechts

Die in der Bitdarstellung entstehenden Lücken auf der rechten bzw. linken Seite werden mit Nullen aufgefüllt.


Galileo Computing - Zum Seitenanfang

8.3.2 Gleitkommazahlen – float  Zur nächsten ÜberschriftZur vorigen Überschrift

Zu Beginn dieses Teils des Buches sind wir bereits oberflächlich auf Gleitkommazahlen eingegangen, was wir hier ein wenig vertiefen möchten. Zum Speichern einer Gleitkommazahl mit begrenzter Genauigkeit wird der Datentyp float verwendet.

Wie bereits besprochen wurde, sieht eine Gleitkommazahl im einfachsten Fall folgendermaßen aus:

v = 3.141

Python unterstützt außerdem eine Notation, die es ermöglicht, die Exponentialschreibweise zu verwenden:

v = 3.141e-12

Durch ein kleines oder großes e wird die Mantisse (3.141) vom Exponenten (-12) getrennt. Übertragen in die mathematische Schreibweise, entspricht 3.141e-12 3,141 · 10–  12  . Beachten Sie, dass sowohl die Mantisse als auch der Exponent im Dezimalsystem anzugeben sind. Andere Zahlensysteme sind nicht vorgesehen, was die gefahrlose Verwendung von führenden Nullen ermöglicht:

v = 03.141e-0012

Es gibt noch weitere Varianten, eine gültige Gleitkommazahl zu definieren. Es handelt sich dabei um Spezialfälle der obigen Notation, weswegen sie etwas exotisch wirken. Sie sollten der Vollständigkeit halber trotzdem erwähnt werden. Pythons interaktiver Modus gibt nach jeder Eingabe ihren Wert aus. Das machen wir uns zunutze und lassen zu jedem Spezialfall den normal formatierten Wert automatisch ausgeben:

>>> -3. 
-3.0 
>>> .001 
0.001 
>>> 3e2 
300.0

Eventuell haben Sie gerade schon etwas mit den Gleitkommazahlen experimentiert und sind dabei auf einen vermeintlichen Fehler des Interpreters gestoßen:

>>> 0.9 
0.90000000000000002

Aufgrund der Begrenztheit von float können rationale Zahlen nicht unendlich präzise gespeichert werden. Stattdessen werden sie mit einer bestimmten Genauigkeit angenähert. In diesem Fall konnte keine präzisere Annäherung an die 0.9 gefunden werden. Es ist unter Verwendung der Basisdatentypen nicht möglich mit beliebig genauen Dezimalzahlen zu rechnen. Dazu muss die Standardbibliothek bemüht werden, was wir zu gegebener Zeit behandeln werden.

Gleitkommazahlen können nicht beliebig genau gespeichert werden. Das impliziert auch, dass es sowohl eine Ober- als auch eine Untergrenze für diesen Datentyp geben muss. Und tatsächlich können Gleitkommazahlen, die in ihrer Größe ein bestimmtes Limit überschreiten, in Python nicht mehr dargestellt werden. Wenn das Limit überschritten wird, wird die Zahl als inf gespeichert, bzw. als -inf, wenn das untere Limit unterschritten wurde. Es kommt also zu keinem Fehler, und es ist immer noch möglich, eine übergroße Zahl mit anderen zu vergleichen:

>>> 3.0e999 
inf 
>>> -3.0e999 
-inf 
>>> 3.0e999 < 12.0 
False 
>>> 3.0e999 > 12.0 
True 
>>> 3.0e999 == 3.0e999999999999 
True

Es ist zwar möglich, zwei unendlich große Gleitkommazahlen miteinander zu vergleichen, jedoch lässt sich nur bedingt mit ihnen rechnen. Dazu folgendes Beispiel:

>>> 3.0e999 + 1.5e999999 
inf 
>>> 3.0e999 - 1.5e999999 
nan 
>>> 3.0e999 * 1.5e999999 
inf 
>>> 3.0e999 / 1.5e999999 
nan

Zwei unendlich große Gleitkommazahlen lassen sich problemlos addieren oder multiplizieren. Das Ergebnis ist in beiden Fällen wieder inf. Ein Problem gibt es aber, wenn versucht wird, zwei solche Zahlen zu subtrahieren bzw. zu dividieren. Da diese Rechenoperationen nicht sinnvoll sind, ergeben sie nan. Der Status nan ist vom Typ her ähnlich wie inf, bedeutet jedoch »not a number«, also so viel wie »nicht berechenbar«.

Beachten Sie, dass weder inf noch nan eine Konstante ist, die Sie selbst in einem Python-Programm verwenden könnten.


Galileo Computing - Zum Seitenanfang

8.3.3 Boolesche Werte – bool  Zur nächsten ÜberschriftZur vorigen Überschrift

Eine Instanz des Datentyps bool kann nur zwei verschiedene Werte annehmen: »Wahr« oder »Falsch« oder, um innerhalb der Python-Syntax zu bleiben, True bzw. False. Deshalb ist es auf den ersten Blick absurd, bool den numerischen Datentypen unterzuordnen. Python sieht hier jedoch True analog zur 1 und False analog zur 0, sodass sich mit booleschen Werten genauso rechnen lässt wie beispielsweise schon mit den ganzen Zahlen. Bei den Namen True und False handelt es sich um Konstanten, die im Quelltext verwendet werden können. Zu beachten ist besonders, dass die Konstanten mit einem Großbuchstaben beginnen:

v1 = True 
v2 = False

Logische Operatoren

Ein oder mehrere boolesche Werte lassen sich mithilfe von bestimmten Operatoren zu einem booleschen Ausdruck kombinieren. Ein solcher Ausdruck resultiert, wenn er ausgewertet wurde, wieder in einem booleschen Wert, also in True oder False. Bevor es zu theoretisch wird, folgt hier zunächst die Tabelle der sogenannten logischen Operatoren, und darunter sehen Sie weitere Erklärungen mit konkreten Beispielen.


Tabelle 8.6  Logische Operatoren des Datentyps bool
Operator Ergebnis

not x

Logische Negierung von x

x and y

Logisches UND zwischen x und y

x or y

Logisches (nicht ausschließendes) ODER zwischen x und y


Die logische Negierung eines booleschen Wertes ist schnell erklärt: Der entsprechende Operator not macht True zu False und False zu True. In einem konkreten Beispiel würde das folgendermaßen aussehen:

if not x: 
    print "x ist False" 
else: 
    print "x ist True"

Das logische UND zwischen zwei Wahrheitswerten ergibt nur dann True, wenn beide Operanden bereits True sind. In folgender Tabelle sind alle möglichen Fälle aufgelistet:


Tabelle 8.7  Mögliche Fälle des logischen UNDs
x y Ausdruck: a and b

True

True

True

False

True

False

True

False

False

False

False

False


In einem konkreten Beispiel würde die Anwendung des logischen UNDs so aussehen:

if x and y: 
    print "x und y sind True"

Das logische ODER zwischen zwei Wahrheitswerten ergibt genau dann eine wahre Aussage, wenn mindestens einer der beiden Operanden wahr ist. Es handelt sich demnach um ein nicht ausschließendes ODER. Ein Operator für ein logisches ausschließendes (exklusives) ODER existiert in Python nicht. Folgende Tabelle listet alle möglichen Fälle auf:


Tabelle 8.8  Mögliche Fälle des logischen ODERs
x y Ausdruck: a or b

True

True

True

False

True

True

True

False

True

False

False

False


Ein logisches ODER könnte folgendermaßen implementiert werden:

if x or y: 
    print "x oder y ist True"

Selbstverständlich können all diese Operatoren miteinander kombiniert und in einem komplexen Ausdruck verwendet werden. Das könnte etwa folgendermaßen aussehen:

if x and y or y and z and not x: 
    print "Holla die Waldfee"

Wir möchten diesen Ausdruck hier nicht im Einzelnen besprechen. Es sei nur gesagt, dass der Einsatz von Klammern den erwarteten Effekt hat, nämlich dass umklammerte Ausdrücke zuerst ausgewertet werden. Die folgende Tabelle zeigt den Wahrheitswert des Ausdruckes auf, und zwar in Abhängigkeit von den drei Parametern x, y und z:


Tabelle 8.9  Mögliche Ergebnisse des Ausdrucks
x y z Ausdruck: x and y or y and z and not x
True True True True
False True True True
True False True False
True True False True
False False True False
False True False False
True False False False
False False False False

Zu Beginn des Abschnitts über numerische Datentypen haben wir einige vergleichende Operatoren eingeführt, die eine Wahrheitsaussage in Form eines booleschen Wertes ergeben. Das folgende Beispiel zeigt, dass diese ganz selbstverständlich zusammen mit den logischen Operatoren verwendet werden können:

if x > y or (y > z and x != 0): 
    print "Mein lieber Schwan"

In diesem Fall muss es sich bei x, y und z um Variablen der Typen int, float oder auch bool handeln.

Wahrheitswerte anderer Datentypen

In Python lassen sich Instanzen eines jeden Basisdatentyps in einen booleschen Wert überführen. Dies ist eine sinnvolle Eigenschaft, da sich eine Instanz der Basisdatentypen häufig in zwei Stadien befinden kann: »leer« und »nicht leer«. Oftmals möchte man beispielsweise testen, ob ein String Buchstaben enthält oder nicht. Dadurch, dass ein String in einen booleschen Wert konvertiert werden kann, wird ein solcher Test sehr einfach durch logische Operatoren möglich:

>>> not "" 
True 
>>> not "abc" 
False

Durch Verwendung eines logischen Operators wird der Operand automatisch als Wahrheitswert interpretiert.

Für jeden Basisdatentyp wurde ein bestimmter Wert als False definiert. Alle davon abweichenden Werte sind True. Die folgende Tabelle listet für jeden Datentyp den entsprechenden False-Wert auf. Einige der Datentypen wurden noch nicht eingeführt, woran Sie sich an dieser Stelle jedoch nicht weiter stören sollten.


Tabelle 8.10  Wahrheitswerte anderer Datentypen
Basisdatentyp False-Wert Beschreibung

NoneType

None

Der Wert None

Numerische Datentypen

int, long

0

Der Wert Null

float

0.0

Der Wert Null

complex

0 + 0j

Der Wert Null

Sequenzielle Datentypen

str

""

Eine leerer String

list

[]

Eine leere Liste

tuple

()

Ein leeres Tupel

Assoziative Datentypen

dict

{}

Ein leeres Dictionary

Mengen

set, frozenset

set(), frozenset()

Eine leere Menge


Alle anderen Werte ergeben True.

Betrachten wir die Konvertierung eines Wertes in einen Wahrheitswert anhand einer Gleitkommazahl:

>>> bool(0.0) 
False 
>>> bool(0.0e12) 
False 
>>> bool(1.0) 
True 
>>> bool(123.456) 
True

Auswertung logischer Operatoren

Python wertet logische Ausdrücke grundsätzlich von links nach rechts, also Im folgenden Beispiel zuerst a und dann b, aus:

if a or b: 
    print "a oder b sind True"

Es wird aber nicht garantiert, dass jeder Teil des Ausdruckes tatsächlich ausgewertet wird. Aus Optimierungsgründen bricht Python die Auswertung des Ausdruckes sofort ab, wenn das Ergebnis feststeht. Wenn im obigen Beispiel also a bereits den Wert True hat, ist der Wert von b nicht weiter von Belang. b würde dann nicht mehr ausgewertet werden. Dieses Detail scheint unwichtig, kann aber zu schwer auffindbaren Fehlern führen.

Zu Beginn dieses Kapitels wurde gesagt, dass ein boolescher Ausdruck stets einen booleschen Wert ergibt, wenn er ausgewertet wurde. Das ist nicht ganz korrekt, denn auch hier wurde die Arbeitsweise des Interpreters in einer Weise optimiert, über die man Bescheid wissen sollte. Deutlich wird dies an folgendem Beispiel aus dem interaktiven Modus:

>>> 0 or 1 
1

Nach dem, was wir bisher besprochen haben, sollte das Ergebnis des Ausdrucks True sein, was mitnichten der Fall ist. Stattdessen gibt Python hier den ersten Operanden mit dem Wahrheitswert True zurück. Das ist um einiges effizienter, da keine neue Instanz erzeugt werden muss, und hat in vielen Fällen trotzdem den erwünschten Effekt, denn der zurückgegebene Wert wird problemlos automatisch in den Wahrheitswert True überführt. Die Auswertung der beiden Operatoren or und and läuft dabei folgendermaßen ab:

  • Das logische ODER (or) nimmt den Wert des ersten Operanden an, der den Wahrheitswert True besitzt, oder – wenn es einen solchen nicht gibt – den Wert des letzten Operanden.
  • Das logische UND (and) nimmt den Wert des ersten Operanden an, der den Wahrheitswert False besitzt, oder – wenn es einen solchen nicht gibt – den Wert des letzten Operanden.

Diese Details haben dabei auch durchaus ihren unterhaltsamen Wert:

>>> "Python" or "Java" 
'Python'

Galileo Computing - Zum Seitenanfang

8.3.4 Komplexe Zahlen – complex  topZur vorigen Überschrift

Überraschenderweise findet sich ein Datentyp zur Speicherung komplexer Zahlen unter Pythons Basisdatentypen. In vielen Programmiersprachen würden komplexe Zahlen eher eine Randnotiz in der Standardbibliothek darstellen oder ganz außen vor bleiben. Sollten Sie nicht mit komplexen Zahlen vertraut sein, können Sie dieses Kapitel gefahrlos überspringen. Es wird nichts behandelt, was für das weitere Erlernen von Python vorausgesetzt würde.

Komplexe Zahlen bestehen aus einem reellen Realteil und einem Imaginärteil, der aus einer reellen Zahl besteht, die mit der imaginären Einheit j multipliziert wird. Das in der Mathematik eigentlich übliche Symbol der imaginären Einheit ist i. Python hält sich hier an die Notationen der Elektrotechnik. Die imaginäre Einheit j kann als Lösung der Gleichung

j = –1

verstanden werden. Im folgenden Beispiel weisen wir einer komplexen Zahl den Namen v zu:

v = 4j

Wenn man, wie im Beispiel, nur einen Imaginärteil angibt, wird der Realteil automatisch als 0 angenommen. Um den Realteil festzulegen, wird dieser auf den Imaginärteil addiert. Die beiden folgenden Schreibweisen sind äquivalent:

v1 = 3 + 4j 
v2 = 4j + 3

Statt des kleinen j ist auch ein großes J als Literal für den Imaginärteil einer komplexen Zahl zulässig. Entscheiden Sie hier ganz nach Ihren Vorlieben, welche der beiden Möglichkeiten Sie verwenden möchten.

Sowohl der Real- als auch der Imaginärteil kann eine beliebige reelle Zahl sein, also Instanzen der Typen int oder float. Folgende Schreibweise ist demnach auch korrekt:

v3 = 3.4 + 4e2j

Zu Beginn des Abschnitts über numerische Datentypen wurde bereits angedeutet, dass sich komplexe Zahlen von den anderen numerischen Datentypen unterscheiden. Da für komplexe Zahlen keine mathematische Reihenfolge definiert ist, können Instanzen des Datentyps complex nur auf Gleichheit oder Ungleichheit verglichen werden. Die Menge der vergleichenden Operatoren ist also auf ==, != und <> beschränkt.

Des Weiteren sind sowohl der Modulo-Operator % als auch der Operator // für eine ganzzahlige Division im Komplexen zwar formal möglich, haben jedoch keinen mathematischen Sinn. Deswegen sind sie in Python inzwischen als deprecated (dt. abgelehnt), also als nicht mehr zu verwenden, eingestuft. Sollten Sie die Operatoren dennoch verwenden, wird eine entsprechende Warnung ausgegeben:

>>> 4j % 2+3j 
sys:1: DeprecationWarning: complex divmod(), // and % are deprecated 
7j

Der Datentyp complex besitzt zwei sogenannte Attribute, die das Arbeiten mit ihm erheblich erleichtern. Es kommt zum Beispiel vor, dass man Berechnungen nur mit dem Realteil oder nur mit dem Imaginärteil der gespeicherten Zahl anstellen möchte. Um einen der beiden Teile zu isolieren, erlaubt Python folgende Notationen, die hier exemplarisch an einer Referenz auf eine komplexe Zahl namens x gezeigt werden:


Tabelle 8.11  Attribute des Datentyps complex
Attribut Beschreibung

x.real

Realteil von x als reelle Zahl (float)

x.imag

Imaginärteil von x als reelle Zahl (float)


Diese können im Code ganz selbstverständlich verwendet werden:

>>> c = 23 + 4j 
>>> c.real 
23.0 
>>> c.imag 
4.0

Wir werden im Zusammenhang mit objektorientierter Programmierung darauf zurückkommen und näher darauf eingehen, was ein Attribut genau ist.

Außer über seine zwei Attribute verfügt der Datentyp complex über eine sogenannte Methode, die in der Tabelle exemplarisch für eine Referenz auf eine komplexe Zahl namens x erklärt wird.


Tabelle 8.12  Methoden des Datentyps complex
Methode Beschreibung

x.conjugate()

Liefert die zu x konjugiert komplexe Zahl


Im Quelltext kann eine Methode ähnlich einfach verwendet werden wie ein Attribut:

>>> c = 23 + 4j 
>>> c.conjugate() 
(23-4j)

Das Ergebnis von conjugate ist wieder eine komplexe Zahl, der selbstverständlich ein Name zugewiesen werden kann. Außerdem verfügt natürlich auch das Ergebnis über eine Methode conjugate:

 >>> c = 23 + 4j 
>>> c2 = c.conjugate() 
>>> c2 
(23-4j)
>>> c3 = c2.conjugate() >>> c3 (23+4j)

Näheres zur Verwendung von Methoden erfahren Sie im nächsten Abschnitt.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.






 <<   zurück
  
  Zum Katalog
Zum Katalog: Python






Python
bestellen
 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: Linux






 Linux


Zum Katalog: Ubuntu GNU/Linux






 Ubuntu GNU/Linux


Zum Katalog: Praxisbuch Web 2.0






 Praxisbuch Web 2.0


Zum Katalog: UML 2.0






 UML 2.0


Zum Katalog: Praxisbuch Objektorientierung






 Praxisbuch Objektorientierung


Zum Katalog: Einstieg in SQL






 Einstieg in SQL


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für Fachinformatiker


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo