Python-Einzeiler mit for und if

Einzeiler – oder One Liner – sind pure Python-Magie. Hier ein Beispiel:

[print(x * '*') for x in range(1, 5)]

Der Code produziert folgendes:

*
**
***
****

Wir könnten auch schreiben:

for x in range(1, 5):
    print(x * '*')

Allgemeine Regel für One Liner

Die allgemeine Regel lautet wie folgt:

[Ausdruck Kontext]

Der Python-Interpreter erwartet die eckigen Klammern, um den Einzeiler überhaupt zu erkennen.

Ausdruck engl. Expression

Ein Ausdruck (engl. Expression) ist in der Programmierung ein Konstrukt, das ausgewertet werden kann, um dessen Wert zu bestimmen. Es besteht aus Konstanten, Variablen, Funktionen, Operatoren.

Beispiele:

x + 3
wert == True
print(‘Hello World’)
print(3 * ‘x’)

Kontext

Der Kontext gibt die Werte an, auf die der Ausdruck angewendet werden soll. Hier können beliebig viele for und if-Statements stehen.

[print(x * '*') for x in range(1, 5) if x % 2 == 0]

Der Output sieht so aus:

**
****

Erläuterung

Zuerst wird also range(1, 5) erzeugt und auf die resultierende Folge wird noch x % 2 == 0 angewendet.

Die Langform lautet wie folgt:

for x in range(1, 5):
   if (x % 2 == 0):
       print(x * '*')

Anmerkung: Dazu wäre die if-Anweisung nicht nötig, wir könnten ja auch sagen range(2,5,2) – doch hier geht es um Einzeiler.

Verschachtelte Listen als einen Einzeiler

Das können wir noch weiter treiben:

[print(x, y) for x in range(3) for y in range(2)]

Probier aus auf dem Python Playground direkt im Browser.

Hier haben wir zwei verschachtelte Listen. Hier die aufgelöste Form:

for x in range(3):
   for y in range(2):
       print(x, y)

Einzeiler mit for und if

Der Phantasie sind keine Grenzen gesetzt:

[print(x, y) for x in range(3) if x % 2 == 0 for y in range(2)]

Hier werden die geraden x ausgewählt. Und jetzt wählen wir noch die ungeraden y und erhalten:

[print(x, y) for x in range(3) if x % 2 == 0 for y in range(2) if y % 2 == 1]

Hier die Langform: Statt einer Zeile benötigt sie ganze fünf Zeilen:

for x in range(3):
   if x % 2 == 0:
       for y in range(2):
           if y % 2 == 1:
               print(x, y)

Ergebnis eines One-Liners als Variable

Sterne ausgeben ist immer hübsch, aber in Wirklichkeit eher nutzlos. Hier eine praktische Einsatzmöglichkeit:

v = [(x,y) for x in range(3) if x % 2 == 0 for y in range(2) if y % 2 == 1]
print(v)

v ist also eine Liste von Tupeln, deren Inhalt den genannten Bedingungen genügt. Ganz schön praktisch für viele Anwendungen.

Python Datentypen

Der Einsatz von Einzeilern setzt gute Kenntnisse der eingebauten Datentypen von Python voraus.
Hol dir unser Cheat Sheet – Alle Built-In Python Datentypen auf einen Blick:

Variablen tauschen in Python und Java

Die Werte zweier Variablen sollen vertauscht werden. Eine alltägliche Anforderung die es in sich hat. Ein Rezept funktioniert in jeder Programmiersprache. Doch Python bietet eine besonders einfache Möglichkeit.

Werte von Variablen vertauschen mit Java

Dies ist ein häufig gesehener Anfängerfehler:

/* Variablen definieren und initialisieren */
int a = 47;
int b = 11;
/* Variablen tauschen */
a = b;
b = a;
/* Variablen ausgeben */
System.out.println("a="+a+" b="+b);

Das Ergebnis der Bemühung sieht so aus:

a=11 b=11

Die Erklärung ist mehrstufig:

Das Gleichheitszeichen

Das Gleichheitszeichen ist nicht die mathematsiche Gleichheit sondern der Zuweisungsoperator: Der Wert der Variablen links vom Zuweisungsoperator wird mit dem Wert der Variablen rechts vom Zuweisungsoperator überschrieben. Der alte Wert geht dabei verloren.

Also:

• Der Befehl a  = b bewirkt, dass der Wert von b, also 11 in die Variable a kopiert wird. Die Variable a hat danach den Wert 11.
• Der nachfolgende Befehl b = a bewirkt, dass der Wert von a, der jetzt ja 11 beträgt, in die Variable b kopiert wird.

So entsteht das Ergebnis.

Die Abhilfe ist einfach – eine Hilfsvariable:

int hilfsvariable = a;
a = b;
b = hilfsvariable;

Was passiert:

• Mit int c = a wird eine neue Variable mit der Bezeichnung c definiert und mit dem Wert der Variablen a initialisiert. hilfsvariable hat also den Wert 47;
• a = b kopiert den Wert der Variablen b in die Variable a. a hat also den Wert 11.
• b = c kopiert jetzt den Wert der Variable hilfsvariable in die Variable a und diese nimmt damit wie erwartet den Wert 47 an.

Fertig. Das Rezept funktioniet in jeder Programmiersprache – auch in Python.

Variablen tauschen in Python – einfache Variante

Python ist keine typsichere Sprache, wir brauchen also den Datentyp einer Variablen nicht zu definieren. Der Python-Interpreter findet diesen für uns heraus. Der Java Code aus unserem Beispiel sieht in Python so aus:

a = 47
b = 11
c = a
a = b
b = c
print(f'a={a} b={b}')

Probier gleich aus auf dem Python Playground.

Variablen tauschen in Python – fortgeschrittene Variante

Python bietet viel Magie – auch für das Tauschen von Variablenwerten. Statt drei Zeilen reicht eine Zeile: (b, a) = (a, b). Sehr intuitiv, nicht wahr.

a = 47
b = 11
(b, a) = (a, b)
print(f'a={a} b={b}')

Probier gleich aus auf dem Python Playground.

Doch was steckt dahinter? Viele Konzepte laufen zusammen, um diese einfach Möglichkeit anzubieten.

Pointer

Eine Variable in Python bedeutet eigentlich nur einen Verweis auf eine Stelle im Memory. Also eine Adresse. Der Python-Interpreter den Variablen während der Programmausführung die jeweiligen Adressen zu. Das ist auch in anderen Programmiersprachen so.  Der Artikel Primitive Datentypen vergleicht Java und Python im Hinblick auf die Art und Weise, wie Variablen gespeichert werden.

Der Fachbegriff für Verweis ist Pointer (oder Zeiger). Und ein Pointer ist eigentlich eine Adresse im RAM. Die Speicherstellen im RAM sind ja durchnummeriert und die Nummer dient als Adresse. Das können wir uns vorstellen, wie auf diesem Bild:

a bedeutet also eigentlich eine Adresse, also ein Zeiger ins RAM (Random Access Memory). Ohne sich darum zu kümmern, verwenden Python-Programmierer ständig Pointers.

In anderen Sprachen, beispielsweise C, sorgt man sich beim Programmieren ständig um Pointers.

Tupel

In Python ist (a, b) ein Tupel – also ein eigener Datentyp. Eigentlich müsste man sagen, ein Objekt des Typs Tupel. Doch das ist zu umständlich.

Tupel sind eingebaute Datentypen – und so können wir sie auch ohne speziellen Aufruf eines Konstruktors verwenden – also einfach (a, b) schreiben und damit ist das Tupel gebildet. Und auch ein Tupel ist als Objekt eigentlich nur ein Pointer.

Zuweisungszeichen

Das Gleichheitszeichen ist in Python – und nicht nur dort – der Zuweisungsoperator:
Der Wert des Ausdrucks rechts vom Zuweisungszeichen, wird der Variablen links vom Zusweisungszeichen zugeordnet.

Eigentlich werden nur Pointers umgehängt – Das Bild zeigt die folgenden Befehle:

a = 47
c = a

Und das auf die Spitze getrieben münde bei Python in den Code (b, a) = (a, b).

Was der Code bewirkt, sehen wir im Python Playground:

Die Werte der Variablen a und b werden also vertauscht.

So elegant geht das und so viel steckt dahinter.

Der Aufwand der Python-Magie

Eine Extra-Variable c einfügen erscheint auf den ersten Blick umständlich und Python erscheint viel sparsamer.

Doch der Schein trügt: In Python haben wir sogar zwei Extra-Objekte: nämlich das Tupel (a, b) und das Tupel (b, a).

So gesehen ist Python für die Anwender sparsam, doch die Python-Magie kostet im Hintergrund ganz schön viel Platz und auch viel Ausführungszeit.

Zeit ist Geld – das ist nichts Neues. Als Programmiererinnen und Programmierer konzentrieren wir uns gerne auf die unmittelbaren Fragestellungen und da ist Python natürlich attraktiv.

Python-Magie und Datentypen

Python ist eine enorm flexible Sprache. Tupel sind nur einer der Python Datentypen. Hol dir unser praktisches Cheat Sheet mit allen eingebauten Python Datentypen.:

Hardwarekenntnisse für Programmierer

Die Von-Neumann-Architektur ist ein Modell, welches das für die Programmierung notwendige Basisverständis über die Funktion eines Computers vermittelt.

Software und Hardware

Elektroingenieure befassen sich mit der Hardware von Computern, also mit den elektronischen Bauteilen und deren Funktionsweise.

Programmierer schreiben Software für Computer. Damit sind Programme gemeint, welche den Computer eine bestimmte Funktionalität ausführen lassen. Ein Programmierer braucht ein gewisses Grundverständnis für die Hardware. Dieses verschafft er sich mit einem Modell.

Modelle sind für den Programmierer Hilfsmittel, um die Hardware so zu verstehen, dass er Programme korrekt schreiben kann.

Von-Neumann-Architektur

Die Von-Neumann-Architektur ist  eines der frühesten Modelle und es ist immer gut geeignet, um als Anfänger der Programmierung den Einstieg in die Thematik zu finden. Wir betrachten die einfachste Darstellung der Von-Neumann-Architektur. Sie umfasst die folgenden Elemente:

Prozessor (CPU)

Der Prozessor (auch CPU, Central Processing Unit – Zentraleinheit) – ist die wichtigste Komponente eines Computers. Hier wird die eigentliche Rechenarbeit erledigt. Verarbeitet werden Folgen von Bits. Diese werden in Registern gehalten, das sind spezielle Bereiche, in welchen Rechenoperationen ausgeführt werden können.

Aus Sicht der Elektronik handelt es sich bei Bits um Schalterzustände. Aus Sicht der Programmierer können Bits die Werte 0 und 1 annehmen. Die CPU verarbeitet also eine Folge von 0- und 1-Werten. Dabei werden die Regeln der Bool‘schen Logik und der Arithmetik berücksichtigt.

Memory (RAM)

Das Memory (genauer RAM = Random Access Memory)– hier werden Zwischenergebnisse festgehalten, oder auch ganze Programme geladen, um sie schneller verarbeiten zu können. Wird der Rechner ausgeschaltet, dann geht der Inhalt des Memorys verloren. Erst beim Wiederhochfahren des Computers, erhält das Memory wieder Inhalte.

Input- und Output-Devices (I-O Devices)

Ein Computer ist nicht Selbstzweck sondern er verarbeitet Daten, welche er durch ein Eingabegerät erhält und gibt sie weiter an ein Ausgabegerät. Input- und Output-Geräte, also Ein- und Ausgabegeräte, sind sehr vielfältig, vom Touchscreen, über die Tastatur, eine Festplatte oder anderen Computern, ist nahezu alles denkbar.

Festplatte

Eine Festplatte, neu auch ein SSD (Solid State Drive) ist ein spezieller Datenspeicher erhält Daten dauerhaft, d.h. sie bleiben erhalten, auch wenn der Computer ausgeschaltet wird.

Bus

Ein Bus (Control-Bus, Address-Bus, Data-Bus) dient dazu, Kontroll-Information, Adressen und Daten zwischen der CPU dem Memory und den Input- und Output-Geräten zu transportieren.

Die von Neumann Architektur ist eine Referenzarchitektur. Seit ihrere Entwicklung wurde sie weiter verbessert und es kamen weitere Architekturen dazu.

Das Verständnis der von Neumann Architektur ist hilfreich, um Programmieren zu lernen.

Raspberry Pi als Beispiel einer realisierten Von-Neumann Architektur

Raspberry Pi ist der beliebte Einplatinen-Rechner – Single-Board Computer (SBC). Auch dieser implementiert im Wesentlichen die von Neumann Architektur. Wer einen SBC erwirbt, erhält diesen meist eine Platine ohne Gehäuse geliefert. Die Platine enthält die gedruckte Schaltung. CPU, RAM und I-O Devices werden auf der Platine montiert, die Busse werden als Schaltung gedruckt.

Das Raspberry Pi verfügt über mannigfaltige Input- und Output-Devices: USB, Ethernet, HDMI. Es gibt kaum eine Device, die man nicht anschließen kann – Tastatur, Maus, Monitor, Kamera und vieles mehr.

Auch die Netzwerk-Verbindungen sind möglich, via Festnetz (Ethernet) oder auch via WiFi.

Die Busse sind aufgedruckt, wer genau hinsieht, erkennt die feinen Linien auf der grünen Platine.

Aus Sicht der Programmierer ist jeder  Computer ist so aufgebaut – ob ganz klein, beispielsweise als Smart-Watch oder ganz groß, wie bei einem Server in einem Rechenzentrum. Und das schon seit den ersten Computern und daran hat sich nicht viel geändert. Elektro-Ingenieuresehen das anders: sie verbessern die einzelen Hardware-Komponenten und entwickeln neue I-O-Devices.