Python Zusammenfassung

Mit den folgenden sechs Merkmalen kannst du jedes Programm schreiben:

In Variablen werden Werte gespeichert, die man im Laufe des Programms lesen oder verändern will. Variablen haben einen Namen und einen Wert. Den Namen der Variable darf man frei wählen. Nicht erlaubt sind allerdings die Schüsselwörter (z.B. from, repeat, …) und Namen mit Sonderzeichen.

Variablen kannst du ganz einfach deklarieren: <Name der Variablen> = <Wert der Variablen>

Variablen haben jeweils einen Typ:

• Zahlen: Mit Zahlen kann man rechnen.
• Ein Text wird in der Informatik als String bezeichnet. In Python müssen Strings immer in Anführungs- und Schlusszeichen geschrieben werden. Zahlen sind keine Strings und benötigen deshalb keine Anführungs- und Schlusszeichen. Natürlich kann man mit Strings nicht rechnen.

Beispiele:

x = 7 # Zahl
 
a = "Hallo, ich bin ein String!" # String

Betrachte als Beispiel den folgenden Code:

x = 7
 
y = x*x
 
print(y)

Im ersten Schritte legen wir eine Variable mit Namen x fest und weisen ihr den Wert 7 zu. Danach quadrieren wir die Zahl und speichern diesen Wert in einer zweiten Variable mit Namen y. Nun geben wir in der Konsole den Wert der Variable y (also 49) aus. Die Konsole (auch Terminal) ist das Fenster unterhalb des Code-Fensters. Um etwas in der Konsole auszugeben, schreiben wir dies in die print(...) Funktion.

Führe diesen Code (selber schreiben, nicht copy-paste!) nun selbst aus. Weise der Variablen x nun einen anderen Wert zu. Damit wird dann auch der Wert der Variablen y verändert und dementsprechend sieht die Ausgabe im Terminal anders aus.

Einige wichtige mathematischen Operatoren sind:

Ziel: Ein Stück Code nur ausführen, falls eine Bedingung erfüllt ist.

if <Bedingung>:
    # Codeblock der ausgeführt wird,
    # falls (if) Bedingung erfüllt (True) ist

Wollen wir zwei Fälle unterscheiden, können wir mit else arbeiten. Achtung: else hat keine Bedingung - der Block wird dann ausgeführt, wenn die if-Bedingung nicht zutrifft.

if <Bedingung>:
    # Codeblock der ausgeführt wird,
    # falls (if) Bedingung erfüllt (True) ist
else:
    # Codeblock der ausgeführt wird,
    # der ansonsten ausgeführt wird,
    # falls also Bedingung NICHT erfüllt ist (False)

Gibt es aber drei oder mehr Fälle, muss man if-else-Verzweigungen ineinander verschachteln. Dadurch wird der Code unübersichtlich und fehleranfällig. Es ist dann besser, mit elif die weiteren Fälle zu programmieren, da man mit dieser beliebig viele Fälle unterscheiden kann:

if <Bedingung1>:
    # Code, falls <Bedingung1> erfüllt ist.
elif <Bedingung2>:
    # Code, falls <Bedingung2> erfüllt ist, aber nicht <Bedingung1>.
else:
    # Code, falls keine der Bedingungen erfüllt ist.

Bemerkungen:

• Es gibt genau eine if-Anweisung!
• Man kann beliebig viele (auch null) elif-Anweisungegn hintereinander schalten.
• Es gibt keine oder eine else-Anweisung.
• Falls die Bedingung bei if oder einem elif erfüllt ist, werden alle darauffolgenden elif gar nicht mehr überprüft.

Ziel: Ein Stück Code soll wiederholt ausgeführt werden, solange eine Bedingung erfüllt (True) ist.

while <Bedingung>:
    # Dieser Codeblock wird solange ausgefuehrt,
    # wie die <Bedingung> True (also erfuellt) ist
 
# Dieser Code wird ausgeführt,
# sobald die <Bedingung> nicht mehr erfüllt ist

Sowohl in Schleifen wie auch in Verzweigungen werden Bedingungen überprüft. Bedingungen sind Code-Ausdrücke, die in einen Wahrheitswert (True - die Bedingung ist erfüllt, oder False, sie ist nicht erfüllt) umgewandelt werden können.

Die einfachste Bedingung ist also gerade so ein Wahrheitswert. Eine while True-Schleife wird nie regulär beendet, wir verwenden Sie für einen Programmteil der nicht verlassen werden sollen (z.B. in der Robotik):

while True:
    if button_a.is_pressed():
        display.show(Image.SMILE)

Für komplexere Bedingungen in Verzweigungen und Schleifen benötigen wir Vergleichsoperatoren:

Python kann alle Werte irgendwie in einen Wahrheitswert umwandeln:

• False sind:
  • die Zahl 0 oder 0.0
  • der leere String "" und die leere Liste []
  • None
  • False selbst
• True ist alles andere:
  • alle anderen Zahlen ausser 0
  • alle nicht-leeren Strings und Listen
  • True selbst
  • alle anderen Objekte

Mit Logikoperatoren können mehrere Aussagen verknüpft (and, or) oder eine Aussage negiert (not) werden:

Eine Liste ist eine Sequenz von Werten, die in einer einzigen Variable gespeichert werden.

Eine Liste erstellt man wie folgt:

L = ['a', 'b', 'c', 'd']

Eine Liste besteht aus Elementen, die Position eines Elements wird Index genannt. Die Elemente einer Liste kann man über ihren Index auslesen. Das erste Element hat den Index 0, das zweite den Index 1 usw. print(L[2]) gibt also c in der Konsole aus. Ganz ähnlich kannst du auch einen Wert ändern: L[2] = 'B'.

Elemente hinten hinzufügen kann man mit append:

L = ['a', 'b', 'c', 'd']
L.append('e')

Nach dem append-Befehl sieht die Liste wie folgt aus: ['a', 'b', 'c', 'd', 'e']. Mit print(L) kannst du dich selbst davon überzeugen. Weitere wichtige Befehle sind

L.insert(2,'z') # fügt an Index-Position 2 den Wert 'z' ein
L.pop(4) # Entfernt das Element mit Index 4
len(L) # Gibt an, wieviele Elemente sich in der Liste befinden. Diesen Wert kann man z.B. printen oder in einer Variablen speichern

Iteration bedeutet, alle Elemente einer Liste durchzugehen. Mit einer while-Schleife könnte das so aussehen:

i = 0
while i < len(L):
    print(L[i])
    i = i + 1

Noch etwas eleganter geht dasselbe mit einer for-Schleife. Dabei wird die Schleifen-Variable (im Beispiel e) in jedem Durchgang der Schleife auf das nächste Element der Liste gesetzt.

for e in L:
    print(e)

Eine Funktion verpackt ein Stück Code, das wir öfter benötigen.

Die Funktion ist immer wie folgt aufgebaut:

def name_der_funktion(PARAMETER): # Parameter sind optional, die Klammern nicht.
    # CODE DER FUNKTION
    return RETURN_WERT # ist optional

Wir verwenden Funktionen schon lange, viele kennst du: print und input, random.randint, len. Zudem gibt es Funktionen, die zu einem Objekt gehören:

digits = [0, 1, 2, 3, 4, 5]
digits.append(6)  # Die Funktion append gehört zum Listen-Objekt
 
message = "Wir haben {0} Ziffern".format(7)  # Die Funktion format gehört zum String-Objekt

Gründe, um Funktionen zu benützen:

• Effizienz: Wiederholung vermeiden, mehrfach benötigten Code nur einmal schreiben.
• Klarheit: Der Name der Funktion dokumentiert, was hier passiert.
• Isolation: Eine Funktion bearbeitet nur ihre Argumente, andere Variablen sind tabu!

Vergleich den folgenden Code und entscheide, was klarer ist:

numbers = [58, 100, 2, 24, 34, 34, 41, 46, 49, 45]
 
count = 0
for n in numbers:
   if n % 5 == 0:
       if n % 3 == 0:
           count = count + 1
print(count)

def is_multiple(number, factor):
    return number % factor == 0
 
def count_multiples_of(candidates, x, y):
    count = 0
    for n in candidates:
       if is_multiple(n, x) and is_multiple(n, y):
           count = count + 1
    return count
 
numbers = [58, 100, 2, 24, 34, 34, 41, 46, 49, 45]
print(count_multiples_of(numbers, 5, 3))