Veröffentlicht am

Python: Listen definieren und initialisieren

Python Listen definieren und initialisieren

Python Listen definieren und initialisieren

In Python spielen Listen eine wichtige Rolle. Und sie eignen sich hervorragend als allerersten Schritt in die Programmierung.

Dieser Blog-Post zeigt dir die wichtigsten Grundlagen dieses Sprachelements. Dazu gehört folgendes:

  • Die grundlegende Syntax in Python,
  • Das Konzept der Zuweisung in der Programmierung
  • Was sind Variablen
  • Die print-Funktion, um den Inhalt einer Liste anzuschauen.

Beispiel einer Python-Liste

korb = ['apfel', 'birne', 'banana']
print(korb)

Probiere gleich aus: Öffne den Playground und kopiere den Code in das Eingabefeld, das du dort oben links findest.

Lies hier weiter, um zu verstehen, was da passiert.

Liste in Python definieren und ausgeben

Python-Code leicht erklärt

1 Zeilennummern

Zeilennummern sind praktisch zur Orientierung. Du brauchst sie nicht selbst einzugeben – vielmehr werden sie von der Entwicklungsumgebung aufbereitet.

2 Variablen

Wir definieren eine Variable und nennen sie korb. Bezeichnungen von Variablen können wir frei wählen. Es lohnt sich, sprechende Bezeichnungen zu nehmen. Denn nur so werden wir später unser Programm noch verstehen.

Bezeichnungen von Variablen starten mit Kleinbuchstaben – das ist Programmierkonvention.

Variablen sind so etwas wie Behälter für Werte. Und mit den Werten wollen wir in unseren Programmen hantieren:

  • Rechnen
  • Hin- und Her schieben
  • Sortieren
  • Auf Festplatten speichern
  • In E-Mails versenden

korb ist also eine Variable und damit ein Behälter.

3 Zuweisung

Das = Zeichen dient in (fast) allen Programmiersprachen dazu, Werte in Variablen zu schreiben.

Und nein, das ist nicht das Gleichheitszeichen aus der Mathematik – das Zuweisungszeichen in Python und vielen anderen Programmiersprachen sieht nur gleich aus. Wir werden das mathematische Gleichheitszeichen, das die Informatiker verwenden, später noch kennenlernen.

Die Zuweisung erfolgt von rechts nach links: Der Wert rechts vom Zuweisungszeichen wird in die Variable links vom Zuweisungszeichen geschoben.

Links steht immer eine Variable.

Wir füllen also sozusagen unseren korb.

4 Listen

Rechts vom Zuweisungszeichen steht in diesem Beispiel eine Liste. Die Elemente einer Liste werden in Python mit eckigen Klammern umschlossen.

Unsere Liste enthält also die Elemente:

  • 'apfel'
  • 'birne'
  • 'banana

Sie könnte beliebig viele weitere Elemente enthalten.

Erstellen wir also eine Variable  'korb' und befüllen Sie mit der Liste 'apfel', 'birne', 'banana'.

Es ist unsere Fantasie, die uns dieses Bild vorgaukelt:

Sprechende Bezeichnungen für Variablen

5 Anführungszeichen

Liste 'apfel', 'birne', 'banana' sind keine Variablen, sondern konstante Werte – genauer Zeichenketten (englisch Strings). Zeichenketten umschließen wir mit Anführungszeichen.

Dich stört die Kleinschreibung in diesen Zeichenketten? Du darfst gerne auch etwas anderes in die Variable korb legen – wichtig sind lediglich die Anführungszeichen – innerhalb der Anführungszeichen dürfen beliebige konstante Werte stehen.

Der erste Befehl

Der erste Befehl (englisch: Statement) lautet also:

korb = ['apfel', 'birne', 'banana']

Der zweite Befehl

In Python steht jedes Statement auf einer eigenen Zeile.

Der zweite Befehl steht auf einer neuen Zeile.

print(korb)

6 Print – die einfachste Art, um den aktuellen Wert einer Variablen zu erfahren

Wollen wir jetzt sehen, welchen Wert die Variable korb gerade hat, dann hilft der Funktion print().

Der Funktion übergeben wir in runden Klammern die Variable, mit denen die Funktion arbeiten soll.

print(korb) schreibt also den Wert der Variablen korb auf die Konsole – in unserem Playground ist das der rechte Bereich.

7 Klammern

Klammern sind in jeder Programmiersprache wichtig und zwar:

  • runde Klammern
  • eckige Klammern
  • geschweifte Klammern

Am besten suchst du die Klammern gleich auf deiner Tastatur, du wirst sie noch oft benötigen.

Beachte: Jede Art Klammern hat eine andere Bedeutung.

Wir haben in Listen schon die eckigen Klammern kennengelernt und jetzt für die Parameter der Funktionen die runden Klammern.

8 Parameter

Beim Aufruf einer Funktion übergeben wir immer die Parameter, mit denen die Funktion etwas tun soll – das heißt, wir zählen die Variablen auf, mit denen die Funktion rechnen soll.

Die print()-Funktion soll den Wert der Variablen korb ausgeben und so schreiben wir in die runden Klammern die Bezeichnung korb.

9 Programm ausführen

Das erste Programm ist fertig geschrieben und wir führen es aus – dazu klicken wir auf den Play-Button, um das Programm auszuführen.

10 Das Ergebnis

Das Ergebnis wird rechts gezeigt – und zwar sehen wir das Ergebnis der Funktion print() – also den Inhalt der Variablen korb.

Hinweis zu den Anführungszeichen in Python

Wichtig ist die Wahl der Anführungszeichen. Folgende Anführungszeichen funktionieren

  • Die geraden doppelten Anführungszeichen und zwar paarweise, öffnend und schließend
  • Die schönen Anführungszeichen, die in Prosa-Texten verwendet werden, geschweift und mal oben, mal unten, werden von Python nicht akzeptiert.
  • Die geraden einfachen Anführungszeichen und zwar paarweise, öffnend und schließend

Übernimmst du als Code mit Copy-Paste und der Code funktioniert nicht, dann hat vielleicht dein Computer die Anführungszeichen durch unerwünschte Zeichen ersetzt. Beim Ausführen wird Python eine Fehlermeldung ausgeben. Ersetzt du die unerwünschten Anführungszeichen durch zulässige Anführungszeichen, dann wird das Programm funktionieren.

Python Listen – einfache Übungen

Wende die Theorie praktisch an und vertiefe dein Verständnis

Entwickle die Lösungen der Challenges im Playground und vergleiche deine Lösung mit den Beispiellösungen.

Challenge 1

Schreib das folgende Programm:

  • Eine Variable mit Datentyp Liste und mit der Bezeichnung garage enthalte drei Werte, die deine Lieblingsautomarken bezeichnen.
  • Gib den Inhalt der Variablen garage

Challenge 2

Erstelle ein neues Programm wie folgt:

Die Variable werte enthalte eine Liste mit den folgenden Werten: 47, 11, 42, 3.1415, ’Hello World’

Kontrolliere mit print() – entspricht die Ausgabe deinen Erwartungen

  • Programmieren für absolute Anfänger - Spiel mit Python 1

  • Dieser Artikel ist Teil von Spiel mit Python 1 dem Anfänger-Trainings für Programmierneulinge.

  • Mach dir ein Bild von diesem einmaligen, deutschsprachigen Online-Training für absolute Programmieranfänger und buche gleich den kostenlosen Schnupperkurs auf der online Lernplattform.

Veröffentlicht am

Verschachtelte Listen und Schleifen mit Python

Python Verschachtelte Listen

Verschachtelte Listen und Schleifen mit Python

Listen sind eindimensional. Oft benötigt man mehrdimensionale Strukturen. Verschachtelte Listen sind ein Beispiel dafür. Eine zweidimensionale Matrix oder ein Schachbrett können  als verschachtelte Liste programmiert werden. Der Blog-Post stellt zweidimensionale Listen vor.

Beispiel einer verschachtelten Liste

spielbrett = [ \
    ['a1','a2','a3'],\
    ['b1','b2','b3'],\
    ['c1','c2','c3'] \
  ]

Eine zweidimensionale Liste in Python

Beachte: Der Code wird viel übersichtlicher, wenn die langen Befehle auf mehrere Zeilen aufgeteilt werden.

spielbrett ist eine Liste von Listen. Hier bauen wir die inneren Listen so auf, dass alle Elemente vom gleichen Datentyp sind. Das braucht nicht so zu sein, passt jedoch sehr gut zu unserem Beispiel: Wir wollen ein Spielbrett darstellen.

Mit einer Schleife geben wir die einzelnen Elemente der Liste aus:

spielbrett = [ \
  ['a1', 'a2', 'a3'], \
  ['b1', 'b2', 'b3'], \
  ['c1', 'c2', 'c3']
]
for zeile in spielbrett:
  print(zeile)

Ausgabe:

['a1', 'a2', 'a3']
['b1', 'b2', 'b3']
['c1', 'c2', 'c3']

Die Elemente der Liste spielbrett sind ihrerseits wieder Listen. Mit zwei verschachtelten Schleifen, gelingt eine schönere Ausgabe:

for zeile in spielbrett:
  z = ''
    for element in zeile:
      z += element + ' '
  print(z)

 Ausgabe

a1 a2 a3
b1 b2 b3
c1 c2 c3

Die innere Schleife durchläuft die Elemente der inneren Liste, die durch die äußere Schleife gewählt wurde. Eine verschachtelte Datenstruktur benötigt also verschachtelte Schleifen.

Beachte: print() beginnt eine neue Zeile. Um das Spielbrett schön darzustellen, ist das störend. Wir helfen uns mit der Variablen z.

Diese initialisieren wir als leere Zeichenkette bevor wir die Elemente einer einzelnen Zeile durchlaufen. Und statt die Elemente der einzelnen Zeile direkt mit print() auszugeben, verketten wir sie der Reihe nach in z. Ist die innere Schleife fertig, dann geben wir z aus.

Probiere folgendes aus und ersetze z += element + ' ' durch

print(element)
z += element

Erinnere: z += element + ' ' ist die Kurzform für z = z + element + ' '

Python verschachtelte Listen – einfache Übungen

Wende die Theorie praktisch an und vertiefe dein Verständnis

Entwickle die Lösungen der Challenges im Playground und vergleiche deine Lösung mit den Beispiellösungen.

Challenge 1

Erstelle eine verschachtelte Liste brett wie folgt:

brett = [['a0', 'a1'], ['b0', 'b1']]

Schreib ein Programm, das aus der Liste brett eine neue Liste ergebnis enthält, deren Elemente die Verkettung der einzelnen Elemente der inneren Liste enthält. Gib die Variable ergebnis aus.

Für das Beispiel brett soll diese Ausgabe erzeugt werden:

['a0a1', 'b0b1']

Teste mit anderen verschachtelten Listen, die auch eine andere Anzahl innere Listen unterschiedlicher Länge enthalten.

 

Challenge  2

Nehme die folgende Liste zahlen = [[1, 2], [3, 4]] bilde eine neue Liste produkte, die die Produkte der inneren Listen von zahlen enthält. In diesem Beispiel lautet das Ergebnis [2, 12].

Teste mit anderen verschachtelten Listen, die auch eine andere Anzahl innere Listen unterschiedlicher Länge enthalten.

 

Challenge 3

Gib in einer Zählschleife die Elemente der Liste anfang aus.

 

Challenge 4

Verwende Zählschleifen, um die Liste

[['a0', 'a1'], ['b0', 'b1']]

schön formatiert auszugeben.

 

Challenge 5

Untersuche diesen Code. Was bewirkt er?

liste = ['Adam', 'Eva']
for i, el in enumerate(liste):
  print(f'{i=} {el=}')
  • Programmieren für absolute Anfänger - Spiel mit Python 1

  • Dieser Artikel ist Teil von Spiel mit Python 1 dem Anfänger-Trainings für Programmierneulinge.

  • Mach dir ein Bild von diesem einmaligen, deutschsprachigen Online-Training für absolute Programmieranfänger und buche gleich den kostenlosen Schnupperkurs auf der online Lernplattform.

Veröffentlicht am

Wahrheitstabellen

Wahrheitstabellen Boolsche Logik

Wahrheitstabellen

“Wahr oder Falsch” – diese Frage beschäftigt Programmiererinnen und Programmierer tagtäglich. Wann immer sie eine Bedingung formulieren, kommt die Bool’sche Algebra mit ihren Wahrheitstabellen zum Zuge. 

Im folgenden beleuchten wir die theoretischen Hintergründe. Und geben einfache, praktische Tipps für alle, die gerne programmieren.

Autorin: Ursula Deriu

Bool’sche Logik

George Boole (um 1860) Bild: Wikipedia

Die Bezeichnung verdanken wir dem Mathematiker George Boole.
Ob er sich im 18. Jahrhundert hätte vorstellen können, dass seine Studien solch zentralen Stellenwert für einen ganzen Berufszweig haben würden?

Es gelang ihm, die Aussagenlogik als Algebra aufzufassen. Um das zu verstehen, brauchen wir gar nicht so genau zu wissen, was eine “Algebra” ist. Den meisten von uns ist der Begriff bekannt, ohne dessen Definition genau zu kennen.

In der Algebra, präzise in einer Algebra, untersucht man Zahlensysteme hinsichtlich ihrer Regeln. Wir kennen das:

Die ganzen Zahlen mit den beiden Operationen Addition und Subtraktion.
Oder die reellen Zahlen mit den Operationen Addition, Subtraktion, Multiplikation und Division.

George Bool untersuchte ein anderes Zahlensystem. Es besteht aus genau zwei Werten:
True und False – also Wahr und Falsch – oder auch 1 und 0.

Und es kennt eine Reihe von Operationen: Multiplikation, Addition – als die einfachsten Beispiele.

Wie soll das gehen? Wie kann man mit Wahr und Falsch multiplizieren und addieren?

Ganz einfach: wenn wir es nicht wissen, dann können wir es definieren. George Bool hat das getan und untersucht, was dabei passiert.

Aussagenlogik

Boole ist nicht blind vorgegangen, sondern hat auf Bekanntes zurückgegriffen. Auf die Definition einer “Algebra” beispielsweise. Genauer auf die Axiome einer Algebra. Wenn er beweisen kann, dass seine Definition eines neuen Zahlensystems den bekannten und anerkannten Axiomen einer Algebra entspricht, dann hat seine “Erfindung” wirklich Hand und Fuss.

Um es vorwegzunehmen – es ist ihm gelungen.

Addition und Multiplikation hat George Bool nicht einfach so erfunden. Er orientierte sich an der Aussagenlogik, deren Wurzeln ja bis zu den alten Griechen, zu Aristoteles, reicht.

Bool’sche Operationen als Wahrheitstabellen

Und so entstanden die Wahrheitstabellen.

WahrheitstabellenAND wirkt wie die Multiplikation – ersetzte True durch 1 und False durch 0, dann kannst du in der AND-Tabelle die gewohnte Multiplikation ablesen.

Ähnlich bei OR – diese entspricht der Addition – nur dass beim Einsetzen von 0 und 1 bei TRUE or TRUE also 1 or 1 oder auch 1 + 1 nicht zwei resultiert, sondern wieder 1. Wir haben ja gar keine 2.

Und ähnlich geht es bei NOT – hier wird der Wert ‘umgedreht’ also invertiert – im Ansatz so ähnlich wie die Division.

Dieses ‘Zahlensystem’ genügt den Axiomen einer Algebra. Bool hat es bewiesen und deshalb sprechen wir von einer Bool’schen Algebra.

Und die Logik-Ausdrücke mit Wahr und Falsch mit AND, OR, NOT widerspiegeln die Bool’sche Logik.

Und es gibt die bekannten Regeln, die wir aus anderen Algebren kennen.

Sagen wir nämlich, dass AND der Multiplikation entspricht und OR der Addition, dann gilt auch hier:

Punkt vor Strich. Und damit gelten auch die gewohnten Klammerregeln.

Wahrheitstabellen in der Programmierung

Wahrheitstabellen sind aus der Programmierung nicht wegzudenken – in jeder Bedingung, die wir formulieren, beispielsweise in einer IF-Bedingung oder einer WHILE-Bedingung, kommen diese Tabellen zum Zuge:

Wenn wir formulieren:

if (wert1 < wert2):
    print(“das ist wahr”)

Dann wird der Python-Interpreter den Ausdruck wert1 < wert2 mit den aktuellen Werten der beiden Variablen auswerten und herausfinden, ob die Bedingung zutrifft oder nicht.

Trifft sie zu, dann wird der Rumpf der Bedingung ausgeführt – im Beispiel der Text “das ist wahr” ausgegeben.

Trifft die Bedingung zu, dann wird wert1 < wert2 ersetzt durch den Bool’schen Wert True.

Trifft sie nicht zu, dann wird die Bedingung ersetzt durch den Bool’schen Wert False.

Das passiert auch, wenn die Bedingung etwas komplexer ist – ein Beispiel:

if wert1 < wert2 and wert2 < wert3:
    print("das ist wahr")

Der Python-Interpreter macht folgendes:

  1. Ersetzt die Variablen wert1, wert2, wert3 durch die aktuellen Werte
  2. Vergleicht, ob wert1 < wert2 – trifft das zu, wird dieser Ausdruck ersetzt durch True (sonst False)
  3. Vergleicht, ob wert2 < wert3 – trifft das zu, wird dieser Ausdruck ersetzt durch True (sonst False)
  4. Wertet das Gesamtergebnis aus, also Beispielsweise True AND False – und da kommen die Wahrheitstabellen zum Zuge – das Ergebnis wäre hier False und der Text wird nicht ausgegeben.

Wir können beliebig komplexe Bedingungen formulieren und AND – OR – NOT beliebig verwenden.

Natürlich muss die Bedingung für die Programmlogik sinnvoll sein. Und da gilt der

Tipp: Möglichst einfache und leicht verständliche Bedingungen zu formulieren.

Hier ein Beispiel:

if (not ((wert1 < wert2 and wert2 < wert3) or (wert4 > wert5 and wert2 < wert5))):
print(“das trifft zu”)

Der menschliche Leser wird die Bedingung nicht ohne weiteres nachvollziehen können.

Der Python-Interpreter ist in der Lage, diesen Ausdruck auszuwerten.

Zuerst werden basierend auf den aktuellen Werten der Variablen alle Vergleichsoperationen durchgeführt und es wird jeweils True oder False eingesetzt.

Wir können wie folgt vereinfachen:

not ((a and b) or (b and c))

Statt der Vergleiche schreiben wir eine Variable – a, b, c und d sind Bool’schen Variablen und sie nehmen jeweils True oder False an, je nachdem, welches Ergebnis der Vergleich liefert.

Das sind die boolean Variables, die in allen Programmiersprachen vorkommen. Und entsprechend sind True und False boolean values, also Bool’sche Werte.

Danach wird die Wahrheitstabelle stufenweise angewendet: zuerst werden die Klammern ersetzt:

not (d or e)

d und e sind wieder Bool’sche Wert und sie stellen das Ergebnis der Auswertung der Klammern an.

Das passiert nochmals:

not(f)

und nochmals. Und so entsteht das Endergebnis.

  • Klick aufs Bild und hol dir das kostenlose Cheat Sheet Wichtigste Python-Datentypen

Algebraisch vereinfachen

Ohne Kommentar ist die Bedingung in diesem if-Statement für die menschliche Leserschaft nicht mehr nachvollziehbar.

Die Regeln der Bool’schen Algebra helfen, solche Bedingungen umzuformen.

NOT dreht alles um: aus 0 wird 1 und aus AND wird OR. Wir lösen die Klammern auf und beginnen von innen:

Hier ein Beispiel:

not ((a and b) or (b and c)) = not(a and b) and not(b and c) = (a or b) and (b or c)

Da könnten wir jetzt die ursprünglichen Vergleiche wieder einsetzen und erhalten eine gleichwertige Bedingung.

Manchmal wird die Bedingung so besser verständlich.

Manchmal auch nicht. Dann lohnt es sich, die Bedingungen aufzuspalten und einzeln zu Formulieren:

AND Bedingung vereinfachen:

Oft wird eine AND-Bedingung so besser nachvollziehbar:

if (wert1 < wert2 and wert2 < wert3):
    print(“das trifft zu”

Können wir formulieren als:

if wert1 < wert2:
    if wert2 < wert3):
        print(“das trifft zu”

AND können wir auflösen, indem wir zwei IF-Statements verschachteln.

OR Bedingung vereinfachen:

Den Trick gibt es auch für OR:

if (wert1 < wert2 or wert2 < wert3):
    print(“das trifft zu”

Können wir formulieren als

if (wert1 < wert2: 
    print(“das trifft zu”
if wert2 < wert3):
    print(“das trifft zu”

Statt OR, können wir zwei IF hintereinanderschalten.

Fazit:

Bool’sche Logik resp. Bool’sche Algebra haben einen großen Einfluss auf die Programmierung.

True entspricht ‘wahr’ oder auch 1.
False entspricht ‘false’ oder auch 0.

AND entspricht der Multiplikation OR entspricht der Addition, NOT dreht die Werte um, ist also eine Invertierung.

Punkt kommt vor Strich – die Klammerregeln gelten.

Logische Ausdrücke sollten vorsichtig formuliert werden.

Und die praktischen Tipps:

AND kann aufgelöst werden durch verschachtelte IF-Statements
OR kann aufgelöst werden durch hintereinandergeschaltete IF-Statements

Veröffentlicht am

Primitive Datentypen

Primitive Datentypen

Primitive Datentypen – Python und Java im Vergleich

Wenn es primitive Datentypen gibt, welche sind dann die “nicht primitiven” Datentypen?

Antwort: “primitve” Datentypen sind “unboxed” Typen “nicht primitiven” Datentypen sind “gepackte” also “boxed” Typen.  Nicht wirklich hilfreich, nicht wahr?   Holen wir aus:

Autorin: Ursula Deriu

Objektorientierte Sprachen

Die Unterscheidung in die zwei Arten Datentypen ist in objektorientierten Sprachen sinnvoll.

Nehmen wir Java als Beispiel einer objektorientierten Sprache. Auch Python gehört zu dieser Sprachfamilie.

Der Unterschied zwischen diesen zwei Sprachen hinsichtlich Datentypen: Java ist typsicher – Python ist es nicht.

Wie äußert sich das?

Typsicher oder nicht typsicher?

In Java sagen wir

int javaZahl = 1;

Und in Python sagen wir:

python_zahl = 1

Der Python-Interpreter analysiert den Kontext, stellt fest, dass rechts vom Zuweisungszeichen eine konstante ganze Zahl steht und leitet daraus ab, dass python_zahl auch eine ganze Zahl sein muss, also ein int.

In Java, als typsichere Sprache, geben wir bei der Definition der Variablen bekannt, welchen Datentyp wir wünschen.

Und da bemerken wir in Java den Unterschied zwischen primitiven Datentypen und unboxed Datentypen.

In Java sagen wir beispielsweise:

ArrayList javaListe = new ArrayList();

Der Unterschied zur Definition einer Variablen mit primitivem Datentyp sticht ins Auge.

In Python sagen wir:

python_liste = []

Und damit definieren wir eine leere Liste.

In Python sind alle Datentypen “boxed” – Python kennt also gar keine primitiven Datentypen.

Java macht die Unterscheidung.

Konzentrieren wir uns also auf Java.

Wollen wir eine ganzzahlige Variable definieren, dann haben wir auch in Java zwei Möglichkeiten:

int primitiverInt = 1;

oder

Integer classInt = 1;

Im zweiten Fall könnten wir auch schreiben:

Integer classInt = new Integer(1);

Hier sieht man schön, wie der primitive Typ, dargestellt durch die 1, eingepackt wird – also in eine Box verpackt. Der primitve Typ, steht allein, ohne diese Box und ist “unboxed”.

Diese zweite Definitionsweise war in früheren Java-Versionen für Wrapper-Klassen obligatorisch und wurde inzwischen vereinfacht.

Und welches ist jetzt der Unterschied zwischen den beiden Arten ganzer Zahlen?

Dazu müssen wir verstehen, wie die Daten im Memory dargestellt werden.

Hier eine vereinfachte Darstellung:

Datentypen im Memory

Daten belegen Zellen im Memory. Wir schreiben “Zellen” um jetzt nicht noch zu erläutern, was Bytes genau sind. Die Zellen sind adressiert, also durchnummeriert.

Primitive Datentypen im RAMFür int wissen wir, dass Java 32 Bit Platz benötigt. Also 32 mal den Platz für eine 0 oder 1. Auch hier kürzen wir ab und erklären nicht, wie das genau geht.

Diese 32 Bit haben eine Adresse. Diese wird zur Laufzeit des Programms zugewiesen und zwar zum Zeitpunkt der Definition der jeweiligen Variablen, also beispielsweise primitiverInt.

Zur Laufzeit des Programms wird dann jedes Mal, wenn mit primitiverInt gerechnet wird, diese Adresse verwendet, um den aktuellen Wert der Variablen zu finden.

Statt “Adresse” sagt man auch “Zeiger”, englisch: “Pointer”. Weil die Adresse ja auf eine Stelle im Memory “zeigt”.

Und so spricht man auch von Random Access Memory, RAM. Die Adressen können aus dem Programm heraus auf beliebige Stellen im Memory zeigen. Welche es sind, bestimmt das Programm zur Laufzeit.

Das siehst du im Bild: Hier wurde zur Laufzeit die Adresse 1001 ermittelt und dort wird der Wert von primitiverInt gespeichert. Bei der nächsten Ausführung des Programms wird es eine andere Adresse sein.

Anders bei classInt

Da wird zur Laufzeit des Programms zum Zeitpunkt der Definition der Variablen classInt ein zweistufiger Prozess durchlaufen. Dieser ist im Bild illustriert:

Zuerst wird eine Adresse im Memory ermittelt – so wie auch bei primitiverInt. Im Bild ist das 1004. Doch an dieser Adresse steht nicht direkt der Wert der Variablen, sondern eine weitere Adresse. Im Bild ist das 1006. Und diese Adresse verweist auf eine weitere Stelle im Memory, auf der der eigentliche Wert der Variablen classInt steht.

Du findest, das sei unnötig kompliziert?

Da hast du möglicherweise recht. Doch die Vorteile sind enorm:

Vorteile primitiver Datentypen

Illustrieren wir das anhand des Unterschieds zwischen ganzen Zahlen in Python und Java

int in Java belegt 32 Bit. Reichen diese 32 Bit nicht aus, um den Wert der Zahl darzustellen, dann wirft Java eine Fehlermeldung.

Nicht so Python. Dort wird int als eine objektorientierte Klasse implementiert. Auch hier wird Python-Interpreter zur Laufzeit für die Variable eine Speicheradresse festlegen. Im Bild könnte das beispielsweise 1004 sein.

Und an der Stelle dieser Adresse steht eine weitere Adresse zu dem Bereich im Memory, der den Wert der Variablen darstellt. Im Bild ist das 1006.

Dort ist auch Platz für den Wert der Zahl reserviert.

Doch anders als in Java, brauchen wir uns in Python nicht um diesen Platz zu kümmern. Python sorgt dafür, dass der Platz automatisch erweitert wird, wenn die Zahl zu groß wird:

In dem Fall reserviert Python an anderer Stelle noch mehr Platz, im Bild könnte das an Adresse 1002 sein und dort wird gleich auch 1003 mit reserviert.

Python ändert die Adresse an Stelle 1004 ab – neu wird sie 1002. Python merkt sich auch, dass zwei Zellen reserviert sind, also 1002 und 1003.

Die Adresse, die das Programm benötigt, um die Variable darzustellen, bleibt bestehen – also 1004.

  • Klick aufs Bild und hol dir das kostenlose Cheat Sheet Wichtigste Python-Datentypen

Platz im Memory dynamisch verwalten

Ein cleverer Trick, den sich die Leute haben einfallen lassen, die Objektorientierung erfunden haben. So können Klassen geschrieben werden, mit denen dynamisch viel Platz im Memory verwendet wird.

Java kann das auch, beispielsweise mit ArrayList. Gleich wie in Python kann auch in Java die Anzahl der Listenelemente dynamisch, also während der Laufzeit des Programms, geändert werden.

Der Java-Datentyp Integer ist leider nicht so schlau, wie sein Pendant in Python.

In Java können wir verschiedene ganze Zahlen haben: byte, short, int long – das sind alles primitive Datentypen für ganze Zahlen. Wir müssen uns darum kümmern, dass die Anzahl Bits, die sie repräsentieren, für unsere Werte ausreichen. Auch die entsprechenden Wrapper-Klassen (so heißen sie) Byte, Short, Integer, Long, sind nur Attrappen – im Herzen haben sie den jeweiligen primitiven Datentyp und bieten nicht die Flexibilität von Python.

Die Java-Spracharchitekten könnten sich entscheiden, das zu ändern – haben es aber nicht vor.

Und ja – es gibt noch mehr primitive Datentypen in Java:

float und double für Zahlen mit Nachkommastellen

boolean für true-false Variable

char für einzelne Buchstaben.

Fazit

Primitive Datentypen gibt es nicht in allen Programmiersprachen. Objektorientierte Programmiersprachen können primitive Datentypen anbieten – müssen aber nicht.

Python ist enorm flexibel bei der Handhabung von Zahlen. Darum ist die Sprache für Datenanalysen auch so beliebt.

Veröffentlicht am

Listen in Python und Java

Sprachvergleich Python Java mit Listen

Listen in Python und Java

Wir sind umgeben von Daten – Wir arbeiten täglich mit Daten – Über uns existieren Daten und diese sollten wir möglichst nicht hergeben.

All diese Daten sind in elektronischer Form.

Und sie werden erzeugt, verarbeitet, gespeichert und übertragen.

Dazu werden die Daten in Strukturen gegossen und mit Werkzeugen bearbeitet.

Python als Programmiersprache ist wie ein Werkzeug, um Daten zu bearbeiten. Daten in beliebigsten Strukturen.

Eine der einfachsten Datenstrukturen ist die Liste.

Listen gibt es in vielen Programmiersprachen. Und all diese Sprachen verstehen unter einer Liste dasselbe Konzept.

Die Programmiersprachen verwenden unterschiedliche Syntaxelemente und unterschiedliche Schlüsselwörter, um die Befehle darzustellen.

Autorin: Ursula Deriu

Listen in Python und Java definieren

Listen sind in beiden Programmiersprachen als Klassen realisiert. Um mit einer Liste zu arbeiten, müssen wir ein Objekt der Klasse instanzieren.

Das ist in Python besonders einfach, gerade auch, weil Listen eingebaute Datentypen sind. Hier ein Beispiel:

pythonListe = [1, 2, 3]

Mehr dazu findest du im Blog Post: Python Listen definieren und initialisieren.

Zum Vergleich in Java:

ArrayList javaListe = new ArrayList();

Dazu müssen wir noch das Package java.util.ArrayList importieren. In Python ist das nicht nötig, weil die Listen in Python zu den eingebauten (built-in) Datentypen gehören.

Zudem ist die Java-Liste noch leer. Es gibt keine Möglichkeit, sie mit einem Initialwert zu versehen, so wie in Python.

In allen Programmiersprachen können Listen variabel viele Elemente haben. Wir müssen also nicht schon zum Zeitpunkt der Programmierung festlegen, wie viele Elemente wir benötigen. Das ist sehr praktisch. Und in Java geht man davon aus, dass man sowieso immer mit einer leeren Liste startet.

Elemente in Listen einfügen

In allen Programmiersprachen können wir neue Elemente hinten an der Liste anhängen.

In Python sieht das so aus:

pythonListe.append(4)

Und in Java sagen wir

ArrayList javaListe = new ArrayList();

Das ist fast wie Französisch und Italienisch – oder wie Deutsch und Holländisch: sehr ähnlich, aber doch nicht gleich.

Reihenfolge der Elemente in Listen

Und in allen Programmiersprachen ist die Reihenfolge der Listenelemente immer dieselbe. Das macht sich bemerkbar, wenn wir die Listenelemente bearbeiten.

Beispielsweise der Reihe nach ausgeben. Wir erhalten immer dieselbe Reihenfolge. Nicht jede Datenstruktur garantiert das.

Wollen wir in Python die Elemente einer Liste der Reihe nach ausgeben, dann sieht das beispielsweise so aus:

for element in meineListe:
    print(element);

Und in Java sagen wir

for (int element : meineListe) {
    System.out.println(element);
}

Das sieht wiederum ähnlich aus.

Anforderungen an Elemente in Listen

Java gilt als typsichere Sprache. Das bedeutet in unseren Code-Beispielen, dass wir für die Listenelemente einen Datentyp angeben müssen. Hier haben wir gesagt, dass wir mit ganzen Zahlen arbeiten wollen, also mit Integer.

In Java können wir in einer Liste nur Elemente desselben Datentyps unterbringen.

Python ist da flexibler. Weil Python nicht typsicher ist.

In Python können wir sagen

pythonListe = [1, 2, 'Hallo']

Mit Python können wir also ganze Zahlen und Zeichenketten in der Liste unterbringen.

Etwas Ähnliches können wir in Java nicht machen – (na ja, wenn’s sein muss, dann kann man den Effekt auch erzielen, doch dann wäre es gescheiter, für dieses Programm nicht Java zu verwenden).

Elemente aus Listen löschen

Wir können in allen Programmiersprachen auch Elemente aus Listen löschen:

In Python:

pythonListe.remove('Hallo')

Das erste Element ‘Hallo’ wird entfernt. Vielleicht gibt es mehr als ein solches Element in der Liste.

In Java löschen wir so:

javaListe.remove(2);

Das Element an der zweiten Stelle wird entfernt.

Wiederum ähnlich, aber nicht gleich. Etwa so wie Deutsch und Englisch. Man muss beide Sprachen lernen, kennt man die eine, dann fällt die andere viel leichter.

Fazit

Listen als abstraktes Konzept sind allen Informatikern bekannt. Sie verhalten sich in allen Programmiersprachen ähnlich.

Als Anfängerin oder Anfänger konzentrierst du dich am besten darauf, Listen in einer Programmiersprache kennen zu lernen.

Später wirst du allgemein gültige Konzepte lernen und der Wechsel zu einer anderen Programmiersprache wird dir leicht fallen.

 

  • Klick aufs Bild und hol dir das kostenlose Cheat Sheet Wichtigste Python-Datentypen