Bioinformatik Wiki - User contributions [en]

Main Page

2023-06-23T09:52:59Z

Ani: Nicht vorhandenen Link entfernt

6.Normalisierungen

2023-06-14T14:18:37Z

Ani: /* c. Normalisierung mit TMM */

==Aufgabe 1: Grundlagen==
===a: Warum ist es notwendig RNASeq Daten zu normalisieren?===
*Eliminieren von statischen Abweichungen, die durch z.B. verschiedene Durchführungsrunden, unterschiedliche Bedingungen, Laborausstattung, Experimentatoren, … entstehen
* Heterologe Geneigenschaften können zu unterschiedlichen Ergebnissen bei eigentlich gleicher Genexpression führen
* Vergleichbarkeit von Proben ermöglichen

===b: Rolle der Sequenziertiefe und Genlänge===
Die Sequenziertiefen und Genlängen müssen normalisiert werden, um die erhaltenen RNASeq Daten miteinander vergleichen zu können, da diese oft sehr unterschiedlich sind und das die Auswertung beeinflussen kann. So erhält man für längere Gene möglicherweise mehr reads, als für kürzere Gene, obwohl die Genexpression gleich ist. Der Fehlschluss liegt nah, dass das längere Gen stärker exprimiert wird. Bei einer hohen Sequenziertiefe erhält man mehr reads, als bei einer niedrigen Sequenziertiefe. Dabei muss das Verhältnis der erhaltenen reads für ein Gen, zu der Gesamtzahl an reads einer Sequenzierung betrachtet werden. Dies ist durch Normalisierungen möglich.

==Aufgabe 2: RPKM und TPM==
{| class="wikitable center"
|-
! Gen & Genlänge (L) !! Counts (c) Replikat 1 !! Counts (c) Replikat 2
|-
| A (7 kb) || 5 || 16
|-
| B (12 kb) || 10 || 36
|-
| C (0,5 kb) || 2 || 8
|-
| D (25 kb) || 1 || 0
|}
===a: Normalisierung mit RPKM===
* RPKM steht für 'Reads per kilobase of transcript per Million mapped reads'
* Für die Normalisierung wird die Formel <math> RPKM = \frac{ c_\text{i}}{L_\text{i} \cdot N} * 10^6 </math> verwendet.
<math> \frac{ c_\text{i}}{L_\text{i}} </math> → Normalisierung der Genlänge 
<math> L_\text{i} \cdot N </math> → Normalisierung der Sequenziertiefe
'''Beispiel Gen A, Replikat 1:''' 
<math> RPKM (A1) = \frac{ 5}{7 kb \cdot 18} * 10^6 = 3,97 * 10^4</math>
{| class="wikitable center"
|-
! Gen !! RPKM Replikat 1 !! RPKM Replikat 2
|-
| A || 3,97 * 10^4 || 3,81 * 10^4
|-
| B || 4,63 * 10^4 || 5 * 10^4
|-
| C || 2,222 * 10^5 || 2,667 * 10^5
|-
| D || 2,2 * 10^3 || 0
|}
* Ein hoher RPKM Wert, sagt aus, dass die Genexpression stärker ist, als bei einem niedrigeren RPKM Wert, indem die Größe des Gens berücksichtigt wird.
* Zum Vergleich der Genexpression innerhalb einer Probe, können die RPKM Werte genutzt werden, sie sind jedoch nicht dafür geeignet Genexpressionen von Genen verschiedener Proben miteinander zu vergleichen, da die Bedingungen meist sehr unterschiedlich sind und falsche Aussagen über die Genexpressionen gemacht werden können. Die Summe aller RPKMs ergibt nicht 100 % und kann somit keine Anteile am Ganzen widerspiegeln.

===b: Normalisierung mit TPM===
* TPM steht für 'Transcripts per Million.
* Wenn 1 Millionen Transkripte sequenziert werden würden, wäre TPMi die Anzahl an Transkripten des Typs 'i'.
* Bei TPM wird außerdem die totale Anzahl an reads nicht berücksichtigt. 
* Anders, als bei der Normalisierung mit RPKM wird erst die Genlänge und dann die Sequenziertiefe normalisiert.
* TPM berechnet das Verhältnis zwischen den Ergebnissen und die Werte in jeder Spalte ergeben 1 Million.
* Für die Normalisierung wird die Formel <math> TPM = \frac{ c_\text{i}}{L_\text{i}} \cdot \dfrac {1}{\sum_\text{n} \dfrac {c_\text{n}}{L_\text{n}}} \cdot 10^6 </math> verwendet.
'''Parameter:''' 
ci = Anzahl an ausrichtbaren reads für ein Transkript 'i' 
Li = Länge des Transkripts/Gens 'i' in bp 
N = Gesamtanzahl an ausrichtbaren reads in Millionen 
'''Beispiel Gen A, Replikat 1:''' 
<math> TPM (A1) = \frac{ 5}{7000} \cdot \dfrac {1}{ \dfrac {5}{7000} + \dfrac {10}{12000} + \dfrac {2}{500} + \dfrac {1}{25000}} \cdot 10^6 = 127834 </math> 
{| class="wikitable center"
|-
! Gen !! TPM Replikat 1 !! TPM Replikat 2
|-
| A || 127834 || 107383
|-
| B || 149139 || 140940
|-
| C || 715868 || 751678
|-
| D || 7159 || 0
|}

===c: Anwendungsbereich===
RPKM und TPM werden genutzt um die Expression verschiedener Gene, aus der gleichen Probe, einer RNA Sequenzierung miteinander zu vergleichen. Sie sind also Normalisierungsverfahren innerhalb einer Probe.

==Aufgabe 3: Normalisierung zwischen Proben==
==a: Normalisierungsmethode==
Für die Normalisierung zwischen Proben wird TMM eingesetzt. TMM steht für 'Trimmed mean of M – Values normalization method'.
==b: Wieso wird die Normalisierung bei RNASeq-Proben angewendet?==
* Um das relative RNA-Produktionsniveau aus RNASeq-Daten abzuschätzen
* Es können heterologe Geneigenschaften zwischen 2 Proben auftauchen und eine identische Genexpression, fälschlicherweise, als unterschiedlich erkannt werden
* Beispiel: Expression zwischen gesunden und kranken Patienten soll auf bestimmte Marker untersucht werden

==c. Normalisierung mit TMM==
'''1.''' Der Gewichtungsfaktor für das Expressionsverhältnis für Gen 'g' zwischen Probe 'k' ' und 'k' wird bestimmt. Dabei werden kleinere Werte verstärkt und große abgeschwächt. 
{| class="wikitable"
|-
! Formel !! Parameter
|-
| <math> W_\text{gk}^\text{k`} = \frac{ N_\text{k} - Y_\text{gk}}{N_\text{k} \cdot Y_\text{gk}} + \frac{ N_\text{k`} - Y_\text{gk`}}{N_\text{k`} \cdot Y_\text{gk`}} </math> || Ygk = Beobachtete Anzahl an reads für Gen 'g' und Probe 'k' 
Nk = Gesamtanzahl an reads für Probe 'k' 
k' = 2. Probe (Referenz-Bedingung)
|}
'''2.''' Der Mittelwert aller Expressionsverhältnisse wird berechnet. 
{| class="wikitable"
|-
! Formel !! Parameter
|-
| <math> M_\text{gk}^\text{k`} = log_2 \dfrac { \dfrac {Y_\text{gk}}{N_\text{k}}}{ \dfrac {Y_\text{gk`}}{N_\text{k`}}} </math> || Ygk = Beobachtete Anzahl an reads für Gen 'g' und Probe 'k' 
Nk = Gesamtanzahl an reads für Probe 'k' 
k' = 2. Probe (Referenz-Bedingung)
|}
'''3.''' Die gewichteten Mittelwerte aller Expressionsverhältnisse werden berechnet. Einsetzen der in 1. und 2. ermittelten Werte. 
<div align="center"> <math> TMM = 2^{log_2 (TMM_\text{k}^\text{k`})} </math></div> 

{| class="wikitable"
|-
! Formel !! Parameter
|-
| <math> log_2 (TMM_\text{k}^\text{k`}) = \frac{ \underset {g \in G}{\sum} W_\text{gk}^\text{k´} \cdot M_\text{gk}^\text{k´}} { \sum_{g \in G} W_\text{gk}^\text{k´}} </math> || <math> M_\text{gk}^\text{k`} = </math> Mittelwerte aller Expressionsverhältnisse 
<math> W_\text{gk}^\text{k`} = </math> Gewichtungsfaktor der Expressionsverhältnisse 
G = Menge aller Gene
|}

'''Bedingungen für dieses Verfahren:''' 
* Ygk , Ygk' > 0
* Die oberen und unteren 30 % der <math> M_\text{gk}^\text{k`} </math> Werte werden nicht berücksichtigt
* Die 5 % am höchsten und niedrigsten exprimierten Gene werden nicht berücksichtigt

3.Befehle

2023-06-02T09:48:42Z

Ani: /* len-Befehl */

== ''print''-Befehl ==
‎<syntaxhighlight lang="python">
# Befehl:
print()

# Beispiel:
print("hello")

name = "Max"
print(f"Hallo, {name}!")

# Output:
# hello
# Hallo, Max!
‎</syntaxhighlight>
=== Funktion ===
* der entsprechende Inhalt des ''print''-Befehls wird in der Konsole ausgegeben

=== Syntax ===
* die runden Klammern umschließen das Argument, das ausgegeben wird
* Wörter, bei denen es sich nicht um einen Variablennamen handelt, müssen in Anführungszeichen gesetzt werden
* geschieht das nicht, wird ein Syntaxfehler angezeigt (s. Beispiel_2)
* int und floats werden ohne Anführungszeichen eingegeben
* soll eine Variable innerhalb eines Strings eingefügt werden, kann ein sogenannter f-String genutzt werden. Dazu wird vor die Anführungszeichen ein f geschrieben, innerhalb des Strings werden die geschweiften Klammern dann durch den darin enthaltenen Ausdruck ersetzt (s. Beispiel_1)
‎<syntaxhighlight lang="python">
# Beispiel_2:
print(falsch)

# Output:
# NameError: name 'falsch' is not defined
‎</syntaxhighlight>
* Python geht davon aus, dass es sich bei „falsch“ um eine Variable handelt und möchte den Wert dieser Variablen ausgeben. Es wurde aber keine Variable mit den Namen „falsch“ definiert. Der Fehler kann durch das Hinzufügen von Anführungszeichen behoben werden:

‎<syntaxhighlight lang="python">
print("falsch")

# Output:
# falsch
‎</syntaxhighlight>

== ''type''-Befehl ==
<syntaxhighlight lang="python">
# Befehl
type()

# Beispiel_1:
a = "abc"
d = True
print(type(a))
print(type(1))
print(type(1.0)
print(type(d))

buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
print(type(buch_1))

# Output:
# <class 'str'>
# <class 'int'>
# <class 'float'>
# <class 'bool'>
# <class 'dict'>
‎</syntaxhighlight>
===Funktion===
* mit dem ''type''-Befehl lässt sich der Datentyp bestimmen

=== Syntax ===
* um den Datentyp zu bestimmen wird dieser in die Klammern des ''type''-Befehls geschrieben
* dabei kann es sich direkt um den Datentyp handeln oder einen Variablennamen
* auch hier ist der print Befehl wieder notwendig, um das Ergebnis ausgeben zu lassen
* ohne den print -Befehl wird der type -Befehl zwar ausgeführt, aber nicht in der Konsole ausgegeben

== ''input'' -Befehl ==
<syntaxhighlight lang="python">
# Befehl:
eingabe = input()

# Beispiel:
zahl = input()
print(zahl)

# output
3 # eingegebene Zahl des Nutzers im Eingabefeld
3 # durch print-Befehl ausgegebene Zahl
‎</syntaxhighlight>
=== Funktionen ===
* ermöglicht dem Nutzer die Interaktion mit dem Programm
* so kann z.B. ein Rechenprogramm mit jeder beliebigen vom Nutzer eingegebenen Zahl rechnen und nicht nur mit vorab programmierten Zahlen

=== Syntax ===
* nach den Ausdruck "input" folgt eine Klammer, die bei Ausführung des Programms ein Eingabefeld in der Konsole erzeugt
* gleichzeitig handelt es sich beim ''input''-Befehl auch um ein ''print''-Befehl, dazu muss der entsprechende Text einfach in die Klammer eingegeben werden (s. Beispiel_2)
<syntaxhighlight lang="python">
# Beispiel_2:
zahl = input("Gib hier deine Zahl ein: ")

print(zahl)

# Output:
# Gib hier deine Zahl ein: 3
# 3
‎</syntaxhighlight>
* die Eingabe des Nutzers wird meist durch eine Variable definiert, d.h.:
eingabe = input()
* da der einzutragende Wert bei der Programmierung nicht bekannt ist, kann so „stellvertretend“ mit der Variablen programmiert werden
* s. Beispiel_3, bei der die Rechenoperation „* 2“ mit der Variablen „zahl“ programmiert wird, welche später durch die Eingabe des Nutzers einen Zahlenwert erhält
* der Wert der Variable wird also erst festgelegt, während das Programm läuft
* in der Konsole entsteht durch den ''input-Befehl'' ein „Eingabefeld“ (nicht direkt sichtbar) in das der Nutzer einen Wert (in Beispiel_1 eine Zahl) eintragen kann
* ACHTUNG!: jede Eingabe wird durch den input-Befehl automatisch als string gespeichert
* in Beispiel_3 wird die 3 in string-Form abgespeichert
* die Rechenoperation wird nicht als Multiplikation mit 2 verstanden sondern als Wiederholung des strings
<syntaxhighlight lang="python">
# Beispiel_3:
zahl = input("Gib hier deine Zahl ein: ")
ergebnis = zahl * 2
print(ergebnis)

# output
# Gib hier deine Zahl ein: 3
# 33
‎</syntaxhighlight>
* der string 3 wird wiederholt und es kommt 33 statt 6 heraus
* Lösung: man kann den Datentyp des "inputs" vorab umwandeln:
int(input()) , float(input())
* weiß man vorab nicht, um welchen Datentypen es sich handelt, ist der eval()-Befehl zu empfehlen (s. Beispiel 4) , dieser speichert die Eingabe automatisch unter dem passenden Datentypen ab (string, integer, float)
* hier ist allerdings zu beachten, das in der Konsole ein string wieder in Anführungszeichen gesetzt werden muss
der eval()-Befehl sollte auf keinen Fall benutzt werden, wenn das Programm mit der Außenwelt (z. B. dem Internet oder anderen Dateien) interagiert, da dadurch beliebiger Code ausgeführt werden kann! Am besten vermeidet man den Befehl daher. 
<syntaxhighlight lang="python">
# Beispiel_4 (Möglichst vermeiden):
zahl = eval(input("Gib hier deine Zahl ein: "))
ergebnis = zahl * 2
print(ergebnis)

# output
# Gib hier deine Zahl ein: 3
# 6

# oder

# Gib hier deine Zahl ein: 2.4
# 4.8

# oder

# Gib hier deine Zahl ein: "a"
# aa
</syntaxhighlight>

== ''while''-Schleife ==
<syntaxhighlight lang="python">
# Befehl
while Bedingung:
Operation()

# Beispiel:
n = 1

while n < 10:
print(n)
n = n + 1
</syntaxhighlight>
output
1
2
3
4
5
6
7
8
9

=== Funktion ===
* bestimmte Operationen werden automatisch wiederholt
* erspart viel Programmierarbeit, da nicht alle Operationen einzeln programmiert werden müssen

=== Syntax ===
* die Schleife wird mit dem Ausdruck "while" begonnen
* darauf folgt eine Bedingung, die überprüft wird (z.B. n < 10) gefolgt von einem Doppelpunkt
* in den nächsten Zeilen folgen die Operationen, die innerhalb der Schleife durchgeführt werden sollen
* die zur Schleife gehörenden Operationen sind dadurch gekennzeichnet, dass der Code eingerückt ist. Dazu sollte man die Tab-Taste benutzen (nicht die Leertaste)
* die ''while''-Schleife sollte so programmiert sein, dass sie irgendwann zu einem Ende kommt und nicht endlos weiterläuft, d.h. die zu überprüfende Bedingung sollte irgendwann nicht mehr zutreffen
* --> ansonsten kommt es zu einer endlosen Schleife

==== Ablauf der Schleife ====
* am besten wird die Funktion und die Syntax einer Schleife klar, wenn man sie Schritt für Schritt durchgeht, hier am Beispiel_1:
* '''erste Zeile: der Variablen n wird der Wert 1 zugeordnet'''
* '''zweite Zeile: so lange n kleiner als 10 ist, werden folgende Operationen durchgeführt'''
*(hier wird die Bedingung überprüft, trifft sie zu werden die Operationen der Schleife durchgeführt)
* '''dritte Zeile: gebe den Wert von n aus'''
* (im ersten Durchlauf beträgt der Wert, wie in der ersten Zeile definiert, den Wert 1)
* '''vierte Zeile: definiere die Variable n neu, indem du den Wert von n nimmst und 1 addierst'''
* (n wird neu definiert als der alte Wert von n plus eins, also 1+1, damit ist n jetzt 2)
* sobald die Operationen der Schleife durchgeführt sind, beginnt sie wieder von Neuem, also mit der Überprüfung der Bedingung
* so wird der Wert n immer größer
* erst wenn n = 10 trifft die Bedingung nicht zu, die Operationen der Schleife werden nicht durchgeführt
* finden sich weiter Programmzeilen unterhalb der Schleife, die nicht Teil der Schleife sind, werden diese Programmzeilen erst nach Beendigung der Schleife ausgeführt
[[File:Flow diagram while_schleife.png|200px|thumb|center|flowchart ''while''-Schleife]]

== ''len''-Befehl ==
<syntaxhighlight lang="python">
# Befehl
len(liste)

# Beipiel_1:
tier_1 = ["Hund" ,100 ,399 ,99 ,True]
print(len(tier_1))
</syntaxhighlight>
output
5

=== Funktion ===
* gibt die Anzahl an Elementen in einer Liste, Dictionary, Tupel etc. an

=== Syntax ===
* hinter dem Ausdruck "len" wird der Name der Datenstruktur in Klammern geschrieben

=== Anwendungsmöglichkeiten ===

==== ''len''-Befehl und ''while''-Schleife ====
* wenn mit der ''while''-Schleife eine Liste ausgeben werden soll, muss die Schleife so programmiert werden, dass die Variable die für die Indexzahl steht maximal so groß wird, wie die Anzahl an Elementen in der Liste (s.Beispiel_2)
<syntaxhighlight lang="python">
# Beispiel_2
i = 0
tier_1 = ["Hund", 100, 399, 99, True]
while i < 5:
print(tier_1[i])
i = i + 1

# wird die Variable "i" größer als die Länge der Liste

i = 0
tier_1 = ["Hund", 100, 399, 99, True]
while i < 6:
print(tier_1[i])
i = i + 1
</syntaxhighlight>
output
Hund
100
399
99
True

IndexError: list index out of range

* ist die Länge einer Liste unbekannt oder zu umständlich diese zu ermitteln, hilft der ''len''-Befehl
* statt einer Zahl steht dann "len(name_der_liste)" in der Schleife, dadurch wird die Länge der Liste automatisch ermittelt (s. Beispiel_3)
<syntaxhighlight lang="python">
# Beipiel_3
i = 0
tier_1 = ["Hund", 100, 399, 99, True]
while i < len(tier_1):
print(tier_1[i])
i = i + 1
</syntaxhighlight>
output
Hund
100
399
99
True

== ''for''- Schleife ==

#Befehl:
for element in sammlung:
befehl()

#Beispiel_1:
liste=[“Python”, 1, 4.5, True]

for element in liste:
print(element)

output
Python
1
4.5
True

=== Funktion ===
* erlaubt, wie die ‘‘while‘‘- Schleife, die automatische Wiederholung von Befehlen
* bietet im Gegensatz zur ‘‘while‘‘-Schleife einige Vorteile (viele Funktionen der ''for''-Schleife wären zwar auch mit einer ''while''-Schleifen lösbar, die ''for''-Schleifen macht die Programmierung jedoch deutlich einfacher)
* die ''for''- Schleife eignet sich besonders gut für die einzelne Ausgabe der Elemente von Dictionaries
* sowie die Durchführung von Befehlen, die für jedes Element einer Sequenz (z.B. str) oder Sammlung (z.B. Liste) einmal durchgeführt werden soll

=== Syntax ===
* nach den Ausdruck "for" kommt der Name der Variablen, dieser steht stellvertretend für jedes Element einer Sammlung oder Sequenz
* beim ''input''-Befehl war es vorteilhaft die beim Programmieren noch nicht bekannte (weil erst später durch den Nutzer erfolgende) Eingabe bereits im Programmcode stellvertretende durch eine Variable zu definieren
* so konnte z.B. eine Rechnungen mit einer nicht bekannten Zahl programmiert werden
* das gleiche Prinzip gilt auch für die Variable der "for"-Schleife (diese kann natürlich jeden beliebigen Namen annehmen)
* im Beispiel_1 steht die Variable "element" für die Elemente der Liste namens "liste"
* die Variable "element" steht zwar für alle Elemente der Liste, also “Python”, 1, 4.5 und True, aber nicht gleichzeitig
* im ersten Durchlauf der Schleife steht sie für das erste Element der Liste ("Python"), nun werden die Befehle der Schleife ausgeführt:
* print(element) wird im ersten Durchlauf also zu print("Python")
* im zweiten Durchlauf steht die Variable für das zweite Element (1), print(element) wird im zweiten Durchlauf also zu print(1) usw.
* der darauf folgende Ausdruck "in" dient dazu die Liste, das Dictionary, den String etc. anzugeben, mit dessen Elemente die Schleife durchgeführt werden soll
* dementsprechend folgt darauf der Namen einer Liste, eines Dictionaries oder eines Strings (ein String kann durch eine Variable gespeichert sein oder direkt angegeben werden), daraufhin folgt ein Doppelpunkt
* die zur Schleife gehörenden Operationen sind dadurch gekennzeichnet, dass der Code eingerückt ist

==== Ablauf der Schleife ====
* es wird überprüft ob es ein Element gibt, wessen Wert die Variabel annehmen kann
* trifft das zu laufen die Befehl der Schleife ab, wobei die Variable immer für den entsprechenden Wert des Elements steht
* gibt es keine Elemente mehr, dessen Wert noch nicht angenommen wurde, bricht die Schleife ab
* somit läuft eine for-Schleife immer für jedes Element einmal ab und läuft so häufig ab wie es Elemente gibt (ohne Modifikationen s. unten)

[[File:flowchart ''for''-Schleife.png|200px|thumb|center|flowchart ''for''-Schleife]]

=== Anwendungsmöglichkeiten ===

==== Ausgabe von Dictionaries ====
* einen großen Vorteil bringt die ''for''-Schleife bei der Ausgabe von Dictionaries
* da der Zugriff auf die Elemente in einem Dictionary über keys und nicht Indexzahlen erfolgt, ist die Ausgabe von Dictionaries über eine while Schleife sehr kompliziert und kann nicht in der Form s. Ausgabe von Listen mit ''while''-Schleife erfolgen
* die Ausgabe über die ''for''-Schleife ist sehr einfach und erfolgt wie bei der Ausgabe der Liste
* zu beachten ist, dass hier die Variable nicht den Wert der Elemente, sondern der keys aufnimmt
* schreibt man slo wie in Beispiel_2 die Variable in den ''print''-Befehl der Schleife, werden nur die keys des Dictionaries ausgegeben

#Beispiel_2:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

for element in buch_1:
print(element)

output
Buch
Autor
Preis

* um den Wert des entsprechenden keys ausgeben zu lassen, ist es notwendig die Variable als Index der Liste anzugeben (s. Beispiel_3)
#Beispiel_3:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

for element in buch_1:
print(buch_1[element])

output
Der Herr der Ringe
Tolkien
45

* das klingt erstmal kompliziert, ergibt aber Sinn
* die Ausgabe von Dictionaries erfolgt über die Angabe des keys in eckigen Klammern hinter dem Namen des Dictionaries, dabei steht der key stellvertretend für das jeweilige Element der Liste
* da die Variable der ''for''-Schleife den Wert der keys aufnimmt, wird folglich die Variable in die eckigen Klammern hinter dem Namen des Dictionaries geschrieben

== ''range''-Befehl ==
#Befehl
for element in range(Anzahl):
befehl()

#Beipiel_1:
for element in range(10):
print(element)

output:
0
1
2
3
4
5
6
7
8
9

=== Funktion ===
* für die Wiederholung eines Vorgangs mit einer festen Anzahl an Wiederholungen
* ist auch mit ''while''-Schleife lösbar, wird durch ''range''-Befehl deutlich einfacher

=== Syntax ===
* hinter dem Ausdruck "range" kommt eine Klammer mit der einer Zahl

==== range(stop) ====
* schreibt man in den ''range''-Befehl nur eine Zahl, wird diese als Stoppwert genommen; automatisch ist 0 der Startwert als 1 die Schrittgröße (step)

==== range(start, stop) ====
* schreibt man in den range Befehl zwei Zahlen durch ein Komma getrennt, wird die erste Zahl als Startwert und die zweite als Stoppwert definiert(Stoppwert wird nicht ausgegeben); nimmt 1 als step an

==== range(start, stop, step) ====
* schreibt man in den ''Range''-Befehl drei Zahlen, die jeweils mit einem Komma getrennt sind, wird die dritte Zahl als step definiert

== ''append''-Befehl ==

#Befehl
liste=[element_1,element_2]
liste.append(element_3)

#Beispiel_1:
liste=[1,2,"Apfel"]
liste.append("Baum")

print(liste)

output
[1, 2, 'Apfel', 'Baum']

=== Funktion ===
* fügt einer Liste ein Element hinzu
* wie in Beispiel_1 gezeigt, wird der Liste das Levent "Baum" hinzugefügt

=== Syntax ===
* hinter dem Namen der Liste folgt ein Punkt und der Ausdruck "append", dahinter folg in Klammern das Element, welches der Liste hinzugefügt werden soll
* es ist auch möglich einer Liste mehrere Elemente hinzuzufügen, der Name der hinzuzufügenden Liste wird in den ''append''-Befehl geschrieben
* die Elemente müssen allerdings auch als Liste strukturiert sein (s.Beispiel_2)

#Beispiel_2:
liste_1=[1,2,3,"Baum"]
liste_2=[4,5,6,"Strauch"]
liste_1.append(liste_2)

print(liste_1)

output
[1, 2, 3, 'Baum', [4, 5, 6, 'Strauch']]

* nun wurden zwar die Elemente der liste_2 der liste_1 hinzugefügt, allerdings als Liste in der Liste
* der Grund dafür ist, das der ''append''-Befehl einer Liste immer nur ein Element hinzufügt
* so wird eine Liste, die hinzugefügt werden soll, erst als ein einzelnes Element abgespeichert und dann hinzugefügt
* das Problem lässt sich einfach lösen, indem die Elemente der liste_2 einzeln und nacheinander der liste_1 hinzufügt werden, dafür eignet sich besonders gut eine ''for''-Schleife (s.Beispiel_3)

#Beispeil_3:
liste_1=[1,2,3,"Baum"]
liste_2=[4,5,6,"Strauch"]
for element in liste_2:
liste_1.append(element)

print(liste_1)

output
[1, 2, 3, 'Baum', 4, 5, 6, 'Strauch']

== ''if''-Befehl ==

#Befehl
if Bedingung:
Befehl

#Beispiel:
if 4 < 10:
print("4 ist kleiner als 10")

output
4 ist kleiner als 10

=== Funktion ===
* der ''if''-Befehl macht es einem Computerprorgamm möglich auf verschiedene Ereignisse unterschiedlich zu reagieren
* diese Funktion hebt ein Programm von einer einfachen Rechenanleitung ab

=== Syntax ===
* nach dem Ausdruck "if" folgt die Bedingung die überprüft werden soll, daraufhin ein Doppelpunkt
* die folgenden Kommandozeilen, die zum ''if''-Befehl gehören sind dadurch gekennzeichnet, dass sie versetzt sind

=== Ablauf der Schleife ===
* nach dem Ausdruck "if" wird überprüft ob die darauf folgende Bedingung zutrifft
* trifft die Bedingung zu, werden die Befehle ausgeführt
* trifft die Bedingung nicht zu, werden die Befehle übersprungen
* so ist der Ablauf abhängig von bestimmten Bedingungen und ändert sich je nachdem welche Bedingungen erfüllt bzw. nicht erfüllt werden

=== Bedingungen stellen ===
* die Gleichheit von zwei Werten lässt sich mit "==" überprüfen
* damit kann die Gleichheit von int, str, float und bool überprüft werden (s.Beipsiel_2)

#Befehl
if Bedingung_1 == Bedingung_2:
Befehl

#Beispiel_2:
a=1
b="hallo"
c=True

if a==1:
print(a)
if b=="hallo":
print(b)
if c==True:
print(c)

output
1
hallo
True

* um zu überprüfen ob ein Wert größer oder kleiner als ein anderer ist, werden folgende Symbole verwendet:
<, <= kleiner, kleiner gleich

>, >= größer, größer gleich
* die Ungleichheit lässt sich mit "!=" überprüfen
* mit diesen einfachen Bedingungen und dem ''if''-Befehl lässt sich ganz einfach ein kleines Ratespiel programmieren, welches abhängig von der Eingabe des Nutzers reagieren kann

#Beipiel_3:
eingabe=eval(input("Errate die richtige Zahl zwischen 1 und 10: "))
zahl=8
if eingabe==zahl:
print("du hast de richtige Zahl erraten")
if eingabe!=zahl:
print ("leider falsch, versuche es nochmal")
if eingabe>zahl:
print("versuche eine kleinere Zahl")
if eingabe<zahl:
print("versuche eine größere Zahl")

==== Zusammengesetzte Bedingungen ====
* wenn mehrere Bedingungen gleichzeitig überprüft werden sollen, können diese durch drei Operatoren miteinander verknüpft werden
* das macht einen Code kürzer und übersichtlicher, weil nicht mehrer ''if''-Befehle ineinander geschrieben werden müssen
# "and" wird benutzt wenn zwei oder mehrere Bedingungen gleichzeitig zutreffen müssen
# "or" wird benutzt wenn eine von mehreren möglichen Bedingungen zutreffen muss
# "not" wird zur Verneinung genutzt (hier ist zu beachten, dass alles worauf sich das "not" beziehen soll in klammern gesetzt werden muss, sonst bezieht sich der Ausdruck nur auf das erste Element)

#Beispiel_4:
zahl=6
if zahl <10 and zahl >5:
print("richtig")

#anstatt
if zahl <10:
if zahl>5:
print("richtig")

=== ''else''-Befehl ===

#Befehl
if Bedingung:
Befehl_1
else:
Befehl_2

#Beispiel_1:
eingabe=eval(input("Errate die richtige Zahl zwischen 1 und 10: "))
zahl=8

if eingabe==zahl:
print("du hast de richtige Zahl erraten")
else:
print("das ist nicht die gesuchte Zahl")

==== Funktion ====
* erfüllt die Funktion von ''if not''
* erspart dabei Arbeit, weil im Gegensatz zu 'if not' Operator, die Bedingungen, nicht extra im Befehl formuliert werden müssen
* der 'else'-Befehl schließt automatisch alle Bedingungen ein, die nicht vom ''if''-Befehl abgedeckt werden

==== Syntax ====
* nach dem Ausdruck "else" folgt ein Doppelpunkt und der Befehl
* wenn die Bedingung des ''if''-Befehls nicht zutreffen, wird automatisch der ''else''-Befehl ausgeführt

=== ''elif''-Befehl ===

#Befehl
if Bedingung_1:
Befehl_1
elif Bedingung_2:
Befehl_2
elif Bedingung_3:
Befehl_3

==== Funktion ====
* steht für "else if"
* ersetzt die Ineinanderschachtelungen von mehreren ''if''-Befehlen
* ein ''elif''-Befehl wird nur durchgeführt, wenn die vorangegangene ''if''-Bedingung nicht erfüllt wird

==== Syntax ====
* nach dem Ausdruck "elif" folgt die Bedingung, ein Doppelpunkt und der Befehl

== Funktionen ==

#Befehl:
def funktionsname (evtl. Übergabewerte):
Befehl

#Besipiel_1:
def begrüßung():
print("hallo")
begrüßung()

output
hallo

=== Funktion ===
* ein Befehl kann als Funktion abgespeichert werden
* wird der Befehl in einem Programm häufiger verwendet, muss dieser nicht immer wieder erneut geschrieben werden, stattdessen muss nur die Funktion abgerufen werden
* erspart Zeit und sorgt für Übersichtlichkeit des Programms
* noch übersichtlicher wird ein Code, wenn man die Funktionen nicht im Hauptprogramm sondern anderen Daten abspeichern

=== Syntax ===
* nach dem Begriff "def" folg der Name der Funktion (sinnvoll sind Namen, die die Aufgabe der Funktion beschreiben)
* danach folgt eine runde Klammer, in die Klammer können Werte aus dem Hauptprogramm übernommen werden, z.B. wenn die Funktion eine Rechnung darstellt und im Laufe des Programms mit verschiedenen Werten diese Rechnung durchgeführt werden soll (s. Funktionen mit Argumenten)
* werden keine Werte übernommen, bleibt die Klammer leer

=== Funktionen mit Argumenten ===
* wird benutzt, wenn ein bestimmter Wert aus dem Hauptprogramm übernommen werden soll und es sich nicht immer um den gleichen Wert handelt
* die im Beispiel_1 leer geblieben Klammern, haben die Aufgabe einen Wert aus dem Hauptprogramm an die Funktion zu überreichen
* dabei schreibt man den Wert, der überreicht werden soll in die Klammer hinter den Funktionsnamen im Hauptprogramm --> der Wert wird als Argument bezeichnet
* in die Klammer hinter dem Funktionsnamen in der Funktion, schreibt man einen Variablennamen, der automatisch für den Wert aus dem Hauptprogramm steht
* stellvertretend für die Werte aus dem Hauptprogramm, kann mit dem Variablennamen ein Befehl geschrieben werden (s.Beispiel_2)

#Beispiel_2:
def begrüßung(name):
print(name, "sagt hallo")
begrüßung("jack")

output
jack sagt hallo

* die Funktion hallo ist abhängig vom Argument name. Dieses Argument muss der Funktion beim Aufrufen gegeben werden, sonst funktioniert sie nicht
* der Funktion wird „Jack“ als Argument für Name übergeben
* es können nicht nur str, sondern auch int, float und alle weiteren Datentypen und Strukturen, einer Funktion übergeben werden
* es ist auch möglich Funktionen mit mehreren Argumenten zu benutzen, dafür werden die Argumente mit einem Komma voneinander getrennt (s.Beipiel_3)

#Beispeil_3:
def begrüßung(name, zahl):
print("Hallo ich heiße", name)
print("und bin", zahl, "Jahre alt")

eingabe_1=input("Gib hier dienen Namen ein: ")
eingabe_2=eval(input("Gib hier dein Alter ein: "))
begrüßung(eingabe_1, eingabe_2)

output
Hallo ich heiße Jack
und bin 20 Jahre alt

=== Funktionen mit Rückgabewerten: der ''return-Befehl ===

#Befehl
def funktionsname (evtl. Übergabewerte):
Ergebnis=Befehl
return(Ergebnis)

#Beispiel_2:
def Rechnung(zahl):
value=3*zahl**2
return(value)
Ergebnis=Rechnung(4)
print(Ergebnis)

output
48

==== Funktion ====
* die Ergebnisse aus den Funktionen können dem Hauptprogramm übergeben werden um damit weiter arbeiten zu können

==== Syntax ====
* nach dem Schlüsselbegriff "return" folgt eine runde Klammer mit dem Wert der zurückgegeben werden soll
* dieser Wert selbst kann als Variable abgespeichert werden

== Literatur ==
Michael Bonacina: Python 3 Programmieren für Einsteiger. 2. Auflage. BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2

3.Befehle

2023-06-02T09:44:06Z

Ani: /* Syntax */

== ''print''-Befehl ==
‎<syntaxhighlight lang="python">
# Befehl:
print()

# Beispiel:
print("hello")

name = "Max"
print(f"Hallo, {name}!")

# Output:
# hello
# Hallo, Max!
‎</syntaxhighlight>
=== Funktion ===
* der entsprechende Inhalt des ''print''-Befehls wird in der Konsole ausgegeben

=== Syntax ===
* die runden Klammern umschließen das Argument, das ausgegeben wird
* Wörter, bei denen es sich nicht um einen Variablennamen handelt, müssen in Anführungszeichen gesetzt werden
* geschieht das nicht, wird ein Syntaxfehler angezeigt (s. Beispiel_2)
* int und floats werden ohne Anführungszeichen eingegeben
* soll eine Variable innerhalb eines Strings eingefügt werden, kann ein sogenannter f-String genutzt werden. Dazu wird vor die Anführungszeichen ein f geschrieben, innerhalb des Strings werden die geschweiften Klammern dann durch den darin enthaltenen Ausdruck ersetzt (s. Beispiel_1)
‎<syntaxhighlight lang="python">
# Beispiel_2:
print(falsch)

# Output:
# NameError: name 'falsch' is not defined
‎</syntaxhighlight>
* Python geht davon aus, dass es sich bei „falsch“ um eine Variable handelt und möchte den Wert dieser Variablen ausgeben. Es wurde aber keine Variable mit den Namen „falsch“ definiert. Der Fehler kann durch das Hinzufügen von Anführungszeichen behoben werden:

‎<syntaxhighlight lang="python">
print("falsch")

# Output:
# falsch
‎</syntaxhighlight>

== ''type''-Befehl ==
<syntaxhighlight lang="python">
# Befehl
type()

# Beispiel_1:
a = "abc"
d = True
print(type(a))
print(type(1))
print(type(1.0)
print(type(d))

buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
print(type(buch_1))

# Output:
# <class 'str'>
# <class 'int'>
# <class 'float'>
# <class 'bool'>
# <class 'dict'>
‎</syntaxhighlight>
===Funktion===
* mit dem ''type''-Befehl lässt sich der Datentyp bestimmen

=== Syntax ===
* um den Datentyp zu bestimmen wird dieser in die Klammern des ''type''-Befehls geschrieben
* dabei kann es sich direkt um den Datentyp handeln oder einen Variablennamen
* auch hier ist der print Befehl wieder notwendig, um das Ergebnis ausgeben zu lassen
* ohne den print -Befehl wird der type -Befehl zwar ausgeführt, aber nicht in der Konsole ausgegeben

== ''input'' -Befehl ==
<syntaxhighlight lang="python">
# Befehl:
eingabe = input()

# Beispiel:
zahl = input()
print(zahl)

# output
3 # eingegebene Zahl des Nutzers im Eingabefeld
3 # durch print-Befehl ausgegebene Zahl
‎</syntaxhighlight>
=== Funktionen ===
* ermöglicht dem Nutzer die Interaktion mit dem Programm
* so kann z.B. ein Rechenprogramm mit jeder beliebigen vom Nutzer eingegebenen Zahl rechnen und nicht nur mit vorab programmierten Zahlen

=== Syntax ===
* nach den Ausdruck "input" folgt eine Klammer, die bei Ausführung des Programms ein Eingabefeld in der Konsole erzeugt
* gleichzeitig handelt es sich beim ''input''-Befehl auch um ein ''print''-Befehl, dazu muss der entsprechende Text einfach in die Klammer eingegeben werden (s. Beispiel_2)
<syntaxhighlight lang="python">
# Beispiel_2:
zahl = input("Gib hier deine Zahl ein: ")

print(zahl)

# Output:
# Gib hier deine Zahl ein: 3
# 3
‎</syntaxhighlight>
* die Eingabe des Nutzers wird meist durch eine Variable definiert, d.h.:
eingabe = input()
* da der einzutragende Wert bei der Programmierung nicht bekannt ist, kann so „stellvertretend“ mit der Variablen programmiert werden
* s. Beispiel_3, bei der die Rechenoperation „* 2“ mit der Variablen „zahl“ programmiert wird, welche später durch die Eingabe des Nutzers einen Zahlenwert erhält
* der Wert der Variable wird also erst festgelegt, während das Programm läuft
* in der Konsole entsteht durch den ''input-Befehl'' ein „Eingabefeld“ (nicht direkt sichtbar) in das der Nutzer einen Wert (in Beispiel_1 eine Zahl) eintragen kann
* ACHTUNG!: jede Eingabe wird durch den input-Befehl automatisch als string gespeichert
* in Beispiel_3 wird die 3 in string-Form abgespeichert
* die Rechenoperation wird nicht als Multiplikation mit 2 verstanden sondern als Wiederholung des strings
<syntaxhighlight lang="python">
# Beispiel_3:
zahl = input("Gib hier deine Zahl ein: ")
ergebnis = zahl * 2
print(ergebnis)

# output
# Gib hier deine Zahl ein: 3
# 33
‎</syntaxhighlight>
* der string 3 wird wiederholt und es kommt 33 statt 6 heraus
* Lösung: man kann den Datentyp des "inputs" vorab umwandeln:
int(input()) , float(input())
* weiß man vorab nicht, um welchen Datentypen es sich handelt, ist der eval()-Befehl zu empfehlen (s. Beispiel 4) , dieser speichert die Eingabe automatisch unter dem passenden Datentypen ab (string, integer, float)
* hier ist allerdings zu beachten, das in der Konsole ein string wieder in Anführungszeichen gesetzt werden muss
der eval()-Befehl sollte auf keinen Fall benutzt werden, wenn das Programm mit der Außenwelt (z. B. dem Internet oder anderen Dateien) interagiert, da dadurch beliebiger Code ausgeführt werden kann! Am besten vermeidet man den Befehl daher. 
<syntaxhighlight lang="python">
# Beispiel_4 (Möglichst vermeiden):
zahl = eval(input("Gib hier deine Zahl ein: "))
ergebnis = zahl * 2
print(ergebnis)

# output
# Gib hier deine Zahl ein: 3
# 6

# oder

# Gib hier deine Zahl ein: 2.4
# 4.8

# oder

# Gib hier deine Zahl ein: "a"
# aa
</syntaxhighlight>

== ''while''-Schleife ==
<syntaxhighlight lang="python">
# Befehl
while Bedingung:
Operation()

# Beispiel:
n = 1

while n < 10:
print(n)
n = n + 1
</syntaxhighlight>
output
1
2
3
4
5
6
7
8
9

=== Funktion ===
* bestimmte Operationen werden automatisch wiederholt
* erspart viel Programmierarbeit, da nicht alle Operationen einzeln programmiert werden müssen

=== Syntax ===
* die Schleife wird mit dem Ausdruck "while" begonnen
* darauf folgt eine Bedingung, die überprüft wird (z.B. n < 10) gefolgt von einem Doppelpunkt
* in den nächsten Zeilen folgen die Operationen, die innerhalb der Schleife durchgeführt werden sollen
* die zur Schleife gehörenden Operationen sind dadurch gekennzeichnet, dass der Code eingerückt ist. Dazu sollte man die Tab-Taste benutzen (nicht die Leertaste)
* die ''while''-Schleife sollte so programmiert sein, dass sie irgendwann zu einem Ende kommt und nicht endlos weiterläuft, d.h. die zu überprüfende Bedingung sollte irgendwann nicht mehr zutreffen
* --> ansonsten kommt es zu einer endlosen Schleife

==== Ablauf der Schleife ====
* am besten wird die Funktion und die Syntax einer Schleife klar, wenn man sie Schritt für Schritt durchgeht, hier am Beispiel_1:
* '''erste Zeile: der Variablen n wird der Wert 1 zugeordnet'''
* '''zweite Zeile: so lange n kleiner als 10 ist, werden folgende Operationen durchgeführt'''
*(hier wird die Bedingung überprüft, trifft sie zu werden die Operationen der Schleife durchgeführt)
* '''dritte Zeile: gebe den Wert von n aus'''
* (im ersten Durchlauf beträgt der Wert, wie in der ersten Zeile definiert, den Wert 1)
* '''vierte Zeile: definiere die Variable n neu, indem du den Wert von n nimmst und 1 addierst'''
* (n wird neu definiert als der alte Wert von n plus eins, also 1+1, damit ist n jetzt 2)
* sobald die Operationen der Schleife durchgeführt sind, beginnt sie wieder von Neuem, also mit der Überprüfung der Bedingung
* so wird der Wert n immer größer
* erst wenn n = 10 trifft die Bedingung nicht zu, die Operationen der Schleife werden nicht durchgeführt
* finden sich weiter Programmzeilen unterhalb der Schleife, die nicht Teil der Schleife sind, werden diese Programmzeilen erst nach Beendigung der Schleife ausgeführt
[[File:Flow diagram while_schleife.png|200px|thumb|center|flowchart ''while''-Schleife]]

== ''len''-Befehl ==

#Befehl
len(liste)

#Beipiel_1:
tier_1=["Hund",100,399,99,True]
print(len(tier_1))

output
5

=== Funktion ===
* gibt die Anzahl an Elementen in einer Liste, Dictionary, Tupel etc. an

=== Syntax ===
* hinter dem Ausdruck "len" wird der Name der Liste in Klammern geschrieben

=== Anwendungsmöglichkeiten ===

==== ''len''-Befehl und ''while''-Schleife ====
* wenn mit der ''while''-Schleife eine Liste ausgeben werden soll, muss die Schleife so programmiert werden, dass die Variable die für die Indexzahl steht maximal so groß wird, wie die Anzahl an Elementen in der Liste (s.Beispiel_2)

#Beispiel_2
i=0
tier_1=["Hund",100,399,99,True]
while i < 5:
print(tier_1[i])
i=i+1

# wird die Variabel "i" größer als die Länge der Liste

i=0
tier_1=["Hund",100,399,99,True]
while i < 6:
print(tier_1[i])
i=i+1

output
Hund
100
399
99
True

# wird die Variabel "i" größer als die Länge der Liste

IndexError: list index out of range

* ist die Länge einer Liste unbekannt oder zu umständlich diese zu ermitteln, hilft der ''len''-Befehl
* statt einer Zahl steht dann "len(name_der_liste)" in der Schleife, dadurch wird die Länge der Liste automatisch ermittelt (s.Beispiel_3)

#Beipiel_3
i=0
tier_1=["Hund",100,399,99,True]
while i < len(tier_1):
print(tier_1[i])
i=i+1

output
Hund
100
399
99
True

== ''for''- Schleife ==

#Befehl:
for element in sammlung:
befehl()

#Beispiel_1:
liste=[“Python”, 1, 4.5, True]

for element in liste:
print(element)

output
Python
1
4.5
True

=== Funktion ===
* erlaubt, wie die ‘‘while‘‘- Schleife, die automatische Wiederholung von Befehlen
* bietet im Gegensatz zur ‘‘while‘‘-Schleife einige Vorteile (viele Funktionen der ''for''-Schleife wären zwar auch mit einer ''while''-Schleifen lösbar, die ''for''-Schleifen macht die Programmierung jedoch deutlich einfacher)
* die ''for''- Schleife eignet sich besonders gut für die einzelne Ausgabe der Elemente von Dictionaries
* sowie die Durchführung von Befehlen, die für jedes Element einer Sequenz (z.B. str) oder Sammlung (z.B. Liste) einmal durchgeführt werden soll

=== Syntax ===
* nach den Ausdruck "for" kommt der Name der Variablen, dieser steht stellvertretend für jedes Element einer Sammlung oder Sequenz
* beim ''input''-Befehl war es vorteilhaft die beim Programmieren noch nicht bekannte (weil erst später durch den Nutzer erfolgende) Eingabe bereits im Programmcode stellvertretende durch eine Variable zu definieren
* so konnte z.B. eine Rechnungen mit einer nicht bekannten Zahl programmiert werden
* das gleiche Prinzip gilt auch für die Variable der "for"-Schleife (diese kann natürlich jeden beliebigen Namen annehmen)
* im Beispiel_1 steht die Variable "element" für die Elemente der Liste namens "liste"
* die Variable "element" steht zwar für alle Elemente der Liste, also “Python”, 1, 4.5 und True, aber nicht gleichzeitig
* im ersten Durchlauf der Schleife steht sie für das erste Element der Liste ("Python"), nun werden die Befehle der Schleife ausgeführt:
* print(element) wird im ersten Durchlauf also zu print("Python")
* im zweiten Durchlauf steht die Variable für das zweite Element (1), print(element) wird im zweiten Durchlauf also zu print(1) usw.
* der darauf folgende Ausdruck "in" dient dazu die Liste, das Dictionary, den String etc. anzugeben, mit dessen Elemente die Schleife durchgeführt werden soll
* dementsprechend folgt darauf der Namen einer Liste, eines Dictionaries oder eines Strings (ein String kann durch eine Variable gespeichert sein oder direkt angegeben werden), daraufhin folgt ein Doppelpunkt
* die zur Schleife gehörenden Operationen sind dadurch gekennzeichnet, dass der Code eingerückt ist

==== Ablauf der Schleife ====
* es wird überprüft ob es ein Element gibt, wessen Wert die Variabel annehmen kann
* trifft das zu laufen die Befehl der Schleife ab, wobei die Variable immer für den entsprechenden Wert des Elements steht
* gibt es keine Elemente mehr, dessen Wert noch nicht angenommen wurde, bricht die Schleife ab
* somit läuft eine for-Schleife immer für jedes Element einmal ab und läuft so häufig ab wie es Elemente gibt (ohne Modifikationen s. unten)

[[File:flowchart ''for''-Schleife.png|200px|thumb|center|flowchart ''for''-Schleife]]

=== Anwendungsmöglichkeiten ===

==== Ausgabe von Dictionaries ====
* einen großen Vorteil bringt die ''for''-Schleife bei der Ausgabe von Dictionaries
* da der Zugriff auf die Elemente in einem Dictionary über keys und nicht Indexzahlen erfolgt, ist die Ausgabe von Dictionaries über eine while Schleife sehr kompliziert und kann nicht in der Form s. Ausgabe von Listen mit ''while''-Schleife erfolgen
* die Ausgabe über die ''for''-Schleife ist sehr einfach und erfolgt wie bei der Ausgabe der Liste
* zu beachten ist, dass hier die Variable nicht den Wert der Elemente, sondern der keys aufnimmt
* schreibt man slo wie in Beispiel_2 die Variable in den ''print''-Befehl der Schleife, werden nur die keys des Dictionaries ausgegeben

#Beispiel_2:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

for element in buch_1:
print(element)

output
Buch
Autor
Preis

* um den Wert des entsprechenden keys ausgeben zu lassen, ist es notwendig die Variable als Index der Liste anzugeben (s. Beispiel_3)
#Beispiel_3:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

for element in buch_1:
print(buch_1[element])

output
Der Herr der Ringe
Tolkien
45

* das klingt erstmal kompliziert, ergibt aber Sinn
* die Ausgabe von Dictionaries erfolgt über die Angabe des keys in eckigen Klammern hinter dem Namen des Dictionaries, dabei steht der key stellvertretend für das jeweilige Element der Liste
* da die Variable der ''for''-Schleife den Wert der keys aufnimmt, wird folglich die Variable in die eckigen Klammern hinter dem Namen des Dictionaries geschrieben

== ''range''-Befehl ==
#Befehl
for element in range(Anzahl):
befehl()

#Beipiel_1:
for element in range(10):
print(element)

output:
0
1
2
3
4
5
6
7
8
9

=== Funktion ===
* für die Wiederholung eines Vorgangs mit einer festen Anzahl an Wiederholungen
* ist auch mit ''while''-Schleife lösbar, wird durch ''range''-Befehl deutlich einfacher

=== Syntax ===
* hinter dem Ausdruck "range" kommt eine Klammer mit der einer Zahl

==== range(stop) ====
* schreibt man in den ''range''-Befehl nur eine Zahl, wird diese als Stoppwert genommen; automatisch ist 0 der Startwert als 1 die Schrittgröße (step)

==== range(start, stop) ====
* schreibt man in den range Befehl zwei Zahlen durch ein Komma getrennt, wird die erste Zahl als Startwert und die zweite als Stoppwert definiert(Stoppwert wird nicht ausgegeben); nimmt 1 als step an

==== range(start, stop, step) ====
* schreibt man in den ''Range''-Befehl drei Zahlen, die jeweils mit einem Komma getrennt sind, wird die dritte Zahl als step definiert

== ''append''-Befehl ==

#Befehl
liste=[element_1,element_2]
liste.append(element_3)

#Beispiel_1:
liste=[1,2,"Apfel"]
liste.append("Baum")

print(liste)

output
[1, 2, 'Apfel', 'Baum']

=== Funktion ===
* fügt einer Liste ein Element hinzu
* wie in Beispiel_1 gezeigt, wird der Liste das Levent "Baum" hinzugefügt

=== Syntax ===
* hinter dem Namen der Liste folgt ein Punkt und der Ausdruck "append", dahinter folg in Klammern das Element, welches der Liste hinzugefügt werden soll
* es ist auch möglich einer Liste mehrere Elemente hinzuzufügen, der Name der hinzuzufügenden Liste wird in den ''append''-Befehl geschrieben
* die Elemente müssen allerdings auch als Liste strukturiert sein (s.Beispiel_2)

#Beispiel_2:
liste_1=[1,2,3,"Baum"]
liste_2=[4,5,6,"Strauch"]
liste_1.append(liste_2)

print(liste_1)

output
[1, 2, 3, 'Baum', [4, 5, 6, 'Strauch']]

* nun wurden zwar die Elemente der liste_2 der liste_1 hinzugefügt, allerdings als Liste in der Liste
* der Grund dafür ist, das der ''append''-Befehl einer Liste immer nur ein Element hinzufügt
* so wird eine Liste, die hinzugefügt werden soll, erst als ein einzelnes Element abgespeichert und dann hinzugefügt
* das Problem lässt sich einfach lösen, indem die Elemente der liste_2 einzeln und nacheinander der liste_1 hinzufügt werden, dafür eignet sich besonders gut eine ''for''-Schleife (s.Beispiel_3)

#Beispeil_3:
liste_1=[1,2,3,"Baum"]
liste_2=[4,5,6,"Strauch"]
for element in liste_2:
liste_1.append(element)

print(liste_1)

output
[1, 2, 3, 'Baum', 4, 5, 6, 'Strauch']

== ''if''-Befehl ==

#Befehl
if Bedingung:
Befehl

#Beispiel:
if 4 < 10:
print("4 ist kleiner als 10")

output
4 ist kleiner als 10

=== Funktion ===
* der ''if''-Befehl macht es einem Computerprorgamm möglich auf verschiedene Ereignisse unterschiedlich zu reagieren
* diese Funktion hebt ein Programm von einer einfachen Rechenanleitung ab

=== Syntax ===
* nach dem Ausdruck "if" folgt die Bedingung die überprüft werden soll, daraufhin ein Doppelpunkt
* die folgenden Kommandozeilen, die zum ''if''-Befehl gehören sind dadurch gekennzeichnet, dass sie versetzt sind

=== Ablauf der Schleife ===
* nach dem Ausdruck "if" wird überprüft ob die darauf folgende Bedingung zutrifft
* trifft die Bedingung zu, werden die Befehle ausgeführt
* trifft die Bedingung nicht zu, werden die Befehle übersprungen
* so ist der Ablauf abhängig von bestimmten Bedingungen und ändert sich je nachdem welche Bedingungen erfüllt bzw. nicht erfüllt werden

=== Bedingungen stellen ===
* die Gleichheit von zwei Werten lässt sich mit "==" überprüfen
* damit kann die Gleichheit von int, str, float und bool überprüft werden (s.Beipsiel_2)

#Befehl
if Bedingung_1 == Bedingung_2:
Befehl

#Beispiel_2:
a=1
b="hallo"
c=True

if a==1:
print(a)
if b=="hallo":
print(b)
if c==True:
print(c)

output
1
hallo
True

* um zu überprüfen ob ein Wert größer oder kleiner als ein anderer ist, werden folgende Symbole verwendet:
<, <= kleiner, kleiner gleich

>, >= größer, größer gleich
* die Ungleichheit lässt sich mit "!=" überprüfen
* mit diesen einfachen Bedingungen und dem ''if''-Befehl lässt sich ganz einfach ein kleines Ratespiel programmieren, welches abhängig von der Eingabe des Nutzers reagieren kann

#Beipiel_3:
eingabe=eval(input("Errate die richtige Zahl zwischen 1 und 10: "))
zahl=8
if eingabe==zahl:
print("du hast de richtige Zahl erraten")
if eingabe!=zahl:
print ("leider falsch, versuche es nochmal")
if eingabe>zahl:
print("versuche eine kleinere Zahl")
if eingabe<zahl:
print("versuche eine größere Zahl")

==== Zusammengesetzte Bedingungen ====
* wenn mehrere Bedingungen gleichzeitig überprüft werden sollen, können diese durch drei Operatoren miteinander verknüpft werden
* das macht einen Code kürzer und übersichtlicher, weil nicht mehrer ''if''-Befehle ineinander geschrieben werden müssen
# "and" wird benutzt wenn zwei oder mehrere Bedingungen gleichzeitig zutreffen müssen
# "or" wird benutzt wenn eine von mehreren möglichen Bedingungen zutreffen muss
# "not" wird zur Verneinung genutzt (hier ist zu beachten, dass alles worauf sich das "not" beziehen soll in klammern gesetzt werden muss, sonst bezieht sich der Ausdruck nur auf das erste Element)

#Beispiel_4:
zahl=6
if zahl <10 and zahl >5:
print("richtig")

#anstatt
if zahl <10:
if zahl>5:
print("richtig")

=== ''else''-Befehl ===

#Befehl
if Bedingung:
Befehl_1
else:
Befehl_2

#Beispiel_1:
eingabe=eval(input("Errate die richtige Zahl zwischen 1 und 10: "))
zahl=8

if eingabe==zahl:
print("du hast de richtige Zahl erraten")
else:
print("das ist nicht die gesuchte Zahl")

==== Funktion ====
* erfüllt die Funktion von ''if not''
* erspart dabei Arbeit, weil im Gegensatz zu 'if not' Operator, die Bedingungen, nicht extra im Befehl formuliert werden müssen
* der 'else'-Befehl schließt automatisch alle Bedingungen ein, die nicht vom ''if''-Befehl abgedeckt werden

==== Syntax ====
* nach dem Ausdruck "else" folgt ein Doppelpunkt und der Befehl
* wenn die Bedingung des ''if''-Befehls nicht zutreffen, wird automatisch der ''else''-Befehl ausgeführt

=== ''elif''-Befehl ===

#Befehl
if Bedingung_1:
Befehl_1
elif Bedingung_2:
Befehl_2
elif Bedingung_3:
Befehl_3

==== Funktion ====
* steht für "else if"
* ersetzt die Ineinanderschachtelungen von mehreren ''if''-Befehlen
* ein ''elif''-Befehl wird nur durchgeführt, wenn die vorangegangene ''if''-Bedingung nicht erfüllt wird

==== Syntax ====
* nach dem Ausdruck "elif" folgt die Bedingung, ein Doppelpunkt und der Befehl

== Funktionen ==

#Befehl:
def funktionsname (evtl. Übergabewerte):
Befehl

#Besipiel_1:
def begrüßung():
print("hallo")
begrüßung()

output
hallo

=== Funktion ===
* ein Befehl kann als Funktion abgespeichert werden
* wird der Befehl in einem Programm häufiger verwendet, muss dieser nicht immer wieder erneut geschrieben werden, stattdessen muss nur die Funktion abgerufen werden
* erspart Zeit und sorgt für Übersichtlichkeit des Programms
* noch übersichtlicher wird ein Code, wenn man die Funktionen nicht im Hauptprogramm sondern anderen Daten abspeichern

=== Syntax ===
* nach dem Begriff "def" folg der Name der Funktion (sinnvoll sind Namen, die die Aufgabe der Funktion beschreiben)
* danach folgt eine runde Klammer, in die Klammer können Werte aus dem Hauptprogramm übernommen werden, z.B. wenn die Funktion eine Rechnung darstellt und im Laufe des Programms mit verschiedenen Werten diese Rechnung durchgeführt werden soll (s. Funktionen mit Argumenten)
* werden keine Werte übernommen, bleibt die Klammer leer

=== Funktionen mit Argumenten ===
* wird benutzt, wenn ein bestimmter Wert aus dem Hauptprogramm übernommen werden soll und es sich nicht immer um den gleichen Wert handelt
* die im Beispiel_1 leer geblieben Klammern, haben die Aufgabe einen Wert aus dem Hauptprogramm an die Funktion zu überreichen
* dabei schreibt man den Wert, der überreicht werden soll in die Klammer hinter den Funktionsnamen im Hauptprogramm --> der Wert wird als Argument bezeichnet
* in die Klammer hinter dem Funktionsnamen in der Funktion, schreibt man einen Variablennamen, der automatisch für den Wert aus dem Hauptprogramm steht
* stellvertretend für die Werte aus dem Hauptprogramm, kann mit dem Variablennamen ein Befehl geschrieben werden (s.Beispiel_2)

#Beispiel_2:
def begrüßung(name):
print(name, "sagt hallo")
begrüßung("jack")

output
jack sagt hallo

* die Funktion hallo ist abhängig vom Argument name. Dieses Argument muss der Funktion beim Aufrufen gegeben werden, sonst funktioniert sie nicht
* der Funktion wird „Jack“ als Argument für Name übergeben
* es können nicht nur str, sondern auch int, float und alle weiteren Datentypen und Strukturen, einer Funktion übergeben werden
* es ist auch möglich Funktionen mit mehreren Argumenten zu benutzen, dafür werden die Argumente mit einem Komma voneinander getrennt (s.Beipiel_3)

#Beispeil_3:
def begrüßung(name, zahl):
print("Hallo ich heiße", name)
print("und bin", zahl, "Jahre alt")

eingabe_1=input("Gib hier dienen Namen ein: ")
eingabe_2=eval(input("Gib hier dein Alter ein: "))
begrüßung(eingabe_1, eingabe_2)

output
Hallo ich heiße Jack
und bin 20 Jahre alt

=== Funktionen mit Rückgabewerten: der ''return-Befehl ===

#Befehl
def funktionsname (evtl. Übergabewerte):
Ergebnis=Befehl
return(Ergebnis)

#Beispiel_2:
def Rechnung(zahl):
value=3*zahl**2
return(value)
Ergebnis=Rechnung(4)
print(Ergebnis)

output
48

==== Funktion ====
* die Ergebnisse aus den Funktionen können dem Hauptprogramm übergeben werden um damit weiter arbeiten zu können

==== Syntax ====
* nach dem Schlüsselbegriff "return" folgt eine runde Klammer mit dem Wert der zurückgegeben werden soll
* dieser Wert selbst kann als Variable abgespeichert werden

== Literatur ==
Michael Bonacina: Python 3 Programmieren für Einsteiger. 2. Auflage. BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2

3.Befehle

2023-06-02T09:43:16Z

Ani: /* while-Schleife */

== ''print''-Befehl ==
‎<syntaxhighlight lang="python">
# Befehl:
print()

# Beispiel:
print("hello")

name = "Max"
print(f"Hallo, {name}!")

# Output:
# hello
# Hallo, Max!
‎</syntaxhighlight>
=== Funktion ===
* der entsprechende Inhalt des ''print''-Befehls wird in der Konsole ausgegeben

=== Syntax ===
* die runden Klammern umschließen das Argument, das ausgegeben wird
* Wörter, bei denen es sich nicht um einen Variablennamen handelt, müssen in Anführungszeichen gesetzt werden
* geschieht das nicht, wird ein Syntaxfehler angezeigt (s. Beispiel_2)
* int und floats werden ohne Anführungszeichen eingegeben
* soll eine Variable innerhalb eines Strings eingefügt werden, kann ein sogenannter f-String genutzt werden. Dazu wird vor die Anführungszeichen ein f geschrieben, innerhalb des Strings werden die geschweiften Klammern dann durch den darin enthaltenen Ausdruck ersetzt (s. Beispiel_1)
‎<syntaxhighlight lang="python">
# Beispiel_2:
print(falsch)

# Output:
# NameError: name 'falsch' is not defined
‎</syntaxhighlight>
* Python geht davon aus, dass es sich bei „falsch“ um eine Variable handelt und möchte den Wert dieser Variablen ausgeben. Es wurde aber keine Variable mit den Namen „falsch“ definiert. Der Fehler kann durch das Hinzufügen von Anführungszeichen behoben werden:

‎<syntaxhighlight lang="python">
print("falsch")

# Output:
# falsch
‎</syntaxhighlight>

== ''type''-Befehl ==
<syntaxhighlight lang="python">
# Befehl
type()

# Beispiel_1:
a = "abc"
d = True
print(type(a))
print(type(1))
print(type(1.0)
print(type(d))

buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
print(type(buch_1))

# Output:
# <class 'str'>
# <class 'int'>
# <class 'float'>
# <class 'bool'>
# <class 'dict'>
‎</syntaxhighlight>
===Funktion===
* mit dem ''type''-Befehl lässt sich der Datentyp bestimmen

=== Syntax ===
* um den Datentyp zu bestimmen wird dieser in die Klammern des ''type''-Befehls geschrieben
* dabei kann es sich direkt um den Datentyp handeln oder einen Variablennamen
* auch hier ist der print Befehl wieder notwendig, um das Ergebnis ausgeben zu lassen
* ohne den print -Befehl wird der type -Befehl zwar ausgeführt, aber nicht in der Konsole ausgegeben

== ''input'' -Befehl ==
<syntaxhighlight lang="python">
# Befehl:
eingabe = input()

# Beispiel:
zahl = input()
print(zahl)

# output
3 # eingegebene Zahl des Nutzers im Eingabefeld
3 # durch print-Befehl ausgegebene Zahl
‎</syntaxhighlight>
=== Funktionen ===
* ermöglicht dem Nutzer die Interaktion mit dem Programm
* so kann z.B. ein Rechenprogramm mit jeder beliebigen vom Nutzer eingegebenen Zahl rechnen und nicht nur mit vorab programmierten Zahlen

=== Syntax ===
* nach den Ausdruck "input" folgt eine Klammer, die bei Ausführung des Programms ein Eingabefeld in der Konsole erzeugt
* gleichzeitig handelt es sich beim ''input''-Befehl auch um ein ''print''-Befehl, dazu muss der entsprechende Text einfach in die Klammer eingegeben werden (s. Beispiel_2)
<syntaxhighlight lang="python">
# Beispiel_2:
zahl = input("Gib hier deine Zahl ein: ")

print(zahl)

# Output:
# Gib hier deine Zahl ein: 3
# 3
‎</syntaxhighlight>
* die Eingabe des Nutzers wird meist durch eine Variable definiert, d.h.:
eingabe = input()
* da der einzutragende Wert bei der Programmierung nicht bekannt ist, kann so „stellvertretend“ mit der Variablen programmiert werden
* s. Beispiel_3, bei der die Rechenoperation „* 2“ mit der Variablen „zahl“ programmiert wird, welche später durch die Eingabe des Nutzers einen Zahlenwert erhält
* der Wert der Variable wird also erst festgelegt, während das Programm läuft
* in der Konsole entsteht durch den ''input-Befehl'' ein „Eingabefeld“ (nicht direkt sichtbar) in das der Nutzer einen Wert (in Beispiel_1 eine Zahl) eintragen kann
* ACHTUNG!: jede Eingabe wird durch den input-Befehl automatisch als string gespeichert
* in Beispiel_3 wird die 3 in string-Form abgespeichert
* die Rechenoperation wird nicht als Multiplikation mit 2 verstanden sondern als Wiederholung des strings
<syntaxhighlight lang="python">
# Beispiel_3:
zahl = input("Gib hier deine Zahl ein: ")
ergebnis = zahl * 2
print(ergebnis)

# output
# Gib hier deine Zahl ein: 3
# 33
‎</syntaxhighlight>
* der string 3 wird wiederholt und es kommt 33 statt 6 heraus
* Lösung: man kann den Datentyp des "inputs" vorab umwandeln:
int(input()) , float(input())
* weiß man vorab nicht, um welchen Datentypen es sich handelt, ist der eval()-Befehl zu empfehlen (s. Beispiel 4) , dieser speichert die Eingabe automatisch unter dem passenden Datentypen ab (string, integer, float)
* hier ist allerdings zu beachten, das in der Konsole ein string wieder in Anführungszeichen gesetzt werden muss
der eval()-Befehl sollte auf keinen Fall benutzt werden, wenn das Programm mit der Außenwelt (z. B. dem Internet oder anderen Dateien interagiert, da dadurch beliebiger Code ausgeführt werden kann! 
<syntaxhighlight lang="python">
# Beispiel_4:
zahl = eval(input("Gib hier deine Zahl ein: "))
ergebnis = zahl * 2
print(ergebnis)

# output
# Gib hier deine Zahl ein: 3
# 6

# oder

# Gib hier deine Zahl ein: 2.4
# 4.8

# oder

# Gib hier deine Zahl ein: "a"
# aa
</syntaxhighlight>

== ''while''-Schleife ==
<syntaxhighlight lang="python">
# Befehl
while Bedingung:
Operation()

# Beispiel:
n = 1

while n < 10:
print(n)
n = n + 1
</syntaxhighlight>
output
1
2
3
4
5
6
7
8
9

=== Funktion ===
* bestimmte Operationen werden automatisch wiederholt
* erspart viel Programmierarbeit, da nicht alle Operationen einzeln programmiert werden müssen

=== Syntax ===
* die Schleife wird mit dem Ausdruck "while" begonnen
* darauf folgt eine Bedingung, die überprüft wird (z.B. n < 10) gefolgt von einem Doppelpunkt
* in den nächsten Zeilen folgen die Operationen, die innerhalb der Schleife durchgeführt werden sollen
* die zur Schleife gehörenden Operationen sind dadurch gekennzeichnet, dass der Code eingerückt ist. Dazu sollte man die Tab-Taste benutzen (nicht die Leertaste)
* die ''while''-Schleife sollte so programmiert sein, dass sie irgendwann zu einem Ende kommt und nicht endlos weiterläuft, d.h. die zu überprüfende Bedingung sollte irgendwann nicht mehr zutreffen
* --> ansonsten kommt es zu einer endlosen Schleife

==== Ablauf der Schleife ====
* am besten wird die Funktion und die Syntax einer Schleife klar, wenn man sie Schritt für Schritt durchgeht, hier am Beispiel_1:
* '''erste Zeile: der Variablen n wird der Wert 1 zugeordnet'''
* '''zweite Zeile: so lange n kleiner als 10 ist, werden folgende Operationen durchgeführt'''
*(hier wird die Bedingung überprüft, trifft sie zu werden die Operationen der Schleife durchgeführt)
* '''dritte Zeile: gebe den Wert von n aus'''
* (im ersten Durchlauf beträgt der Wert, wie in der ersten Zeile definiert, den Wert 1)
* '''vierte Zeile: definiere die Variable n neu, indem du den Wert von n nimmst und 1 addierst'''
* (n wird neu definiert als der alte Wert von n plus eins, also 1+1, damit ist n jetzt 2)
* sobald die Operationen der Schleife durchgeführt sind, beginnt sie wieder von Neuem, also mit der Überprüfung der Bedingung
* so wird der Wert n immer größer
* erst wenn n = 10 trifft die Bedingung nicht zu, die Operationen der Schleife werden nicht durchgeführt
* finden sich weiter Programmzeilen unterhalb der Schleife, die nicht Teil der Schleife sind, werden diese Programmzeilen erst nach Beendigung der Schleife ausgeführt
[[File:Flow diagram while_schleife.png|200px|thumb|center|flowchart ''while''-Schleife]]

== ''len''-Befehl ==

#Befehl
len(liste)

#Beipiel_1:
tier_1=["Hund",100,399,99,True]
print(len(tier_1))

output
5

=== Funktion ===
* gibt die Anzahl an Elementen in einer Liste, Dictionary, Tupel etc. an

=== Syntax ===
* hinter dem Ausdruck "len" wird der Name der Liste in Klammern geschrieben

=== Anwendungsmöglichkeiten ===

==== ''len''-Befehl und ''while''-Schleife ====
* wenn mit der ''while''-Schleife eine Liste ausgeben werden soll, muss die Schleife so programmiert werden, dass die Variable die für die Indexzahl steht maximal so groß wird, wie die Anzahl an Elementen in der Liste (s.Beispiel_2)

#Beispiel_2
i=0
tier_1=["Hund",100,399,99,True]
while i < 5:
print(tier_1[i])
i=i+1

# wird die Variabel "i" größer als die Länge der Liste

i=0
tier_1=["Hund",100,399,99,True]
while i < 6:
print(tier_1[i])
i=i+1

output
Hund
100
399
99
True

# wird die Variabel "i" größer als die Länge der Liste

IndexError: list index out of range

* ist die Länge einer Liste unbekannt oder zu umständlich diese zu ermitteln, hilft der ''len''-Befehl
* statt einer Zahl steht dann "len(name_der_liste)" in der Schleife, dadurch wird die Länge der Liste automatisch ermittelt (s.Beispiel_3)

#Beipiel_3
i=0
tier_1=["Hund",100,399,99,True]
while i < len(tier_1):
print(tier_1[i])
i=i+1

output
Hund
100
399
99
True

== ''for''- Schleife ==

#Befehl:
for element in sammlung:
befehl()

#Beispiel_1:
liste=[“Python”, 1, 4.5, True]

for element in liste:
print(element)

output
Python
1
4.5
True

=== Funktion ===
* erlaubt, wie die ‘‘while‘‘- Schleife, die automatische Wiederholung von Befehlen
* bietet im Gegensatz zur ‘‘while‘‘-Schleife einige Vorteile (viele Funktionen der ''for''-Schleife wären zwar auch mit einer ''while''-Schleifen lösbar, die ''for''-Schleifen macht die Programmierung jedoch deutlich einfacher)
* die ''for''- Schleife eignet sich besonders gut für die einzelne Ausgabe der Elemente von Dictionaries
* sowie die Durchführung von Befehlen, die für jedes Element einer Sequenz (z.B. str) oder Sammlung (z.B. Liste) einmal durchgeführt werden soll

=== Syntax ===
* nach den Ausdruck "for" kommt der Name der Variablen, dieser steht stellvertretend für jedes Element einer Sammlung oder Sequenz
* beim ''input''-Befehl war es vorteilhaft die beim Programmieren noch nicht bekannte (weil erst später durch den Nutzer erfolgende) Eingabe bereits im Programmcode stellvertretende durch eine Variable zu definieren
* so konnte z.B. eine Rechnungen mit einer nicht bekannten Zahl programmiert werden
* das gleiche Prinzip gilt auch für die Variable der "for"-Schleife (diese kann natürlich jeden beliebigen Namen annehmen)
* im Beispiel_1 steht die Variable "element" für die Elemente der Liste namens "liste"
* die Variable "element" steht zwar für alle Elemente der Liste, also “Python”, 1, 4.5 und True, aber nicht gleichzeitig
* im ersten Durchlauf der Schleife steht sie für das erste Element der Liste ("Python"), nun werden die Befehle der Schleife ausgeführt:
* print(element) wird im ersten Durchlauf also zu print("Python")
* im zweiten Durchlauf steht die Variable für das zweite Element (1), print(element) wird im zweiten Durchlauf also zu print(1) usw.
* der darauf folgende Ausdruck "in" dient dazu die Liste, das Dictionary, den String etc. anzugeben, mit dessen Elemente die Schleife durchgeführt werden soll
* dementsprechend folgt darauf der Namen einer Liste, eines Dictionaries oder eines Strings (ein String kann durch eine Variable gespeichert sein oder direkt angegeben werden), daraufhin folgt ein Doppelpunkt
* die zur Schleife gehörenden Operationen sind dadurch gekennzeichnet, dass der Code eingerückt ist

==== Ablauf der Schleife ====
* es wird überprüft ob es ein Element gibt, wessen Wert die Variabel annehmen kann
* trifft das zu laufen die Befehl der Schleife ab, wobei die Variable immer für den entsprechenden Wert des Elements steht
* gibt es keine Elemente mehr, dessen Wert noch nicht angenommen wurde, bricht die Schleife ab
* somit läuft eine for-Schleife immer für jedes Element einmal ab und läuft so häufig ab wie es Elemente gibt (ohne Modifikationen s. unten)

[[File:flowchart ''for''-Schleife.png|200px|thumb|center|flowchart ''for''-Schleife]]

=== Anwendungsmöglichkeiten ===

==== Ausgabe von Dictionaries ====
* einen großen Vorteil bringt die ''for''-Schleife bei der Ausgabe von Dictionaries
* da der Zugriff auf die Elemente in einem Dictionary über keys und nicht Indexzahlen erfolgt, ist die Ausgabe von Dictionaries über eine while Schleife sehr kompliziert und kann nicht in der Form s. Ausgabe von Listen mit ''while''-Schleife erfolgen
* die Ausgabe über die ''for''-Schleife ist sehr einfach und erfolgt wie bei der Ausgabe der Liste
* zu beachten ist, dass hier die Variable nicht den Wert der Elemente, sondern der keys aufnimmt
* schreibt man slo wie in Beispiel_2 die Variable in den ''print''-Befehl der Schleife, werden nur die keys des Dictionaries ausgegeben

#Beispiel_2:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

for element in buch_1:
print(element)

output
Buch
Autor
Preis

* um den Wert des entsprechenden keys ausgeben zu lassen, ist es notwendig die Variable als Index der Liste anzugeben (s. Beispiel_3)
#Beispiel_3:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

for element in buch_1:
print(buch_1[element])

output
Der Herr der Ringe
Tolkien
45

* das klingt erstmal kompliziert, ergibt aber Sinn
* die Ausgabe von Dictionaries erfolgt über die Angabe des keys in eckigen Klammern hinter dem Namen des Dictionaries, dabei steht der key stellvertretend für das jeweilige Element der Liste
* da die Variable der ''for''-Schleife den Wert der keys aufnimmt, wird folglich die Variable in die eckigen Klammern hinter dem Namen des Dictionaries geschrieben

== ''range''-Befehl ==
#Befehl
for element in range(Anzahl):
befehl()

#Beipiel_1:
for element in range(10):
print(element)

output:
0
1
2
3
4
5
6
7
8
9

=== Funktion ===
* für die Wiederholung eines Vorgangs mit einer festen Anzahl an Wiederholungen
* ist auch mit ''while''-Schleife lösbar, wird durch ''range''-Befehl deutlich einfacher

=== Syntax ===
* hinter dem Ausdruck "range" kommt eine Klammer mit der einer Zahl

==== range(stop) ====
* schreibt man in den ''range''-Befehl nur eine Zahl, wird diese als Stoppwert genommen; automatisch ist 0 der Startwert als 1 die Schrittgröße (step)

==== range(start, stop) ====
* schreibt man in den range Befehl zwei Zahlen durch ein Komma getrennt, wird die erste Zahl als Startwert und die zweite als Stoppwert definiert(Stoppwert wird nicht ausgegeben); nimmt 1 als step an

==== range(start, stop, step) ====
* schreibt man in den ''Range''-Befehl drei Zahlen, die jeweils mit einem Komma getrennt sind, wird die dritte Zahl als step definiert

== ''append''-Befehl ==

#Befehl
liste=[element_1,element_2]
liste.append(element_3)

#Beispiel_1:
liste=[1,2,"Apfel"]
liste.append("Baum")

print(liste)

output
[1, 2, 'Apfel', 'Baum']

=== Funktion ===
* fügt einer Liste ein Element hinzu
* wie in Beispiel_1 gezeigt, wird der Liste das Levent "Baum" hinzugefügt

=== Syntax ===
* hinter dem Namen der Liste folgt ein Punkt und der Ausdruck "append", dahinter folg in Klammern das Element, welches der Liste hinzugefügt werden soll
* es ist auch möglich einer Liste mehrere Elemente hinzuzufügen, der Name der hinzuzufügenden Liste wird in den ''append''-Befehl geschrieben
* die Elemente müssen allerdings auch als Liste strukturiert sein (s.Beispiel_2)

#Beispiel_2:
liste_1=[1,2,3,"Baum"]
liste_2=[4,5,6,"Strauch"]
liste_1.append(liste_2)

print(liste_1)

output
[1, 2, 3, 'Baum', [4, 5, 6, 'Strauch']]

* nun wurden zwar die Elemente der liste_2 der liste_1 hinzugefügt, allerdings als Liste in der Liste
* der Grund dafür ist, das der ''append''-Befehl einer Liste immer nur ein Element hinzufügt
* so wird eine Liste, die hinzugefügt werden soll, erst als ein einzelnes Element abgespeichert und dann hinzugefügt
* das Problem lässt sich einfach lösen, indem die Elemente der liste_2 einzeln und nacheinander der liste_1 hinzufügt werden, dafür eignet sich besonders gut eine ''for''-Schleife (s.Beispiel_3)

#Beispeil_3:
liste_1=[1,2,3,"Baum"]
liste_2=[4,5,6,"Strauch"]
for element in liste_2:
liste_1.append(element)

print(liste_1)

output
[1, 2, 3, 'Baum', 4, 5, 6, 'Strauch']

== ''if''-Befehl ==

#Befehl
if Bedingung:
Befehl

#Beispiel:
if 4 < 10:
print("4 ist kleiner als 10")

output
4 ist kleiner als 10

=== Funktion ===
* der ''if''-Befehl macht es einem Computerprorgamm möglich auf verschiedene Ereignisse unterschiedlich zu reagieren
* diese Funktion hebt ein Programm von einer einfachen Rechenanleitung ab

=== Syntax ===
* nach dem Ausdruck "if" folgt die Bedingung die überprüft werden soll, daraufhin ein Doppelpunkt
* die folgenden Kommandozeilen, die zum ''if''-Befehl gehören sind dadurch gekennzeichnet, dass sie versetzt sind

=== Ablauf der Schleife ===
* nach dem Ausdruck "if" wird überprüft ob die darauf folgende Bedingung zutrifft
* trifft die Bedingung zu, werden die Befehle ausgeführt
* trifft die Bedingung nicht zu, werden die Befehle übersprungen
* so ist der Ablauf abhängig von bestimmten Bedingungen und ändert sich je nachdem welche Bedingungen erfüllt bzw. nicht erfüllt werden

=== Bedingungen stellen ===
* die Gleichheit von zwei Werten lässt sich mit "==" überprüfen
* damit kann die Gleichheit von int, str, float und bool überprüft werden (s.Beipsiel_2)

#Befehl
if Bedingung_1 == Bedingung_2:
Befehl

#Beispiel_2:
a=1
b="hallo"
c=True

if a==1:
print(a)
if b=="hallo":
print(b)
if c==True:
print(c)

output
1
hallo
True

* um zu überprüfen ob ein Wert größer oder kleiner als ein anderer ist, werden folgende Symbole verwendet:
<, <= kleiner, kleiner gleich

>, >= größer, größer gleich
* die Ungleichheit lässt sich mit "!=" überprüfen
* mit diesen einfachen Bedingungen und dem ''if''-Befehl lässt sich ganz einfach ein kleines Ratespiel programmieren, welches abhängig von der Eingabe des Nutzers reagieren kann

#Beipiel_3:
eingabe=eval(input("Errate die richtige Zahl zwischen 1 und 10: "))
zahl=8
if eingabe==zahl:
print("du hast de richtige Zahl erraten")
if eingabe!=zahl:
print ("leider falsch, versuche es nochmal")
if eingabe>zahl:
print("versuche eine kleinere Zahl")
if eingabe<zahl:
print("versuche eine größere Zahl")

==== Zusammengesetzte Bedingungen ====
* wenn mehrere Bedingungen gleichzeitig überprüft werden sollen, können diese durch drei Operatoren miteinander verknüpft werden
* das macht einen Code kürzer und übersichtlicher, weil nicht mehrer ''if''-Befehle ineinander geschrieben werden müssen
# "and" wird benutzt wenn zwei oder mehrere Bedingungen gleichzeitig zutreffen müssen
# "or" wird benutzt wenn eine von mehreren möglichen Bedingungen zutreffen muss
# "not" wird zur Verneinung genutzt (hier ist zu beachten, dass alles worauf sich das "not" beziehen soll in klammern gesetzt werden muss, sonst bezieht sich der Ausdruck nur auf das erste Element)

#Beispiel_4:
zahl=6
if zahl <10 and zahl >5:
print("richtig")

#anstatt
if zahl <10:
if zahl>5:
print("richtig")

=== ''else''-Befehl ===

#Befehl
if Bedingung:
Befehl_1
else:
Befehl_2

#Beispiel_1:
eingabe=eval(input("Errate die richtige Zahl zwischen 1 und 10: "))
zahl=8

if eingabe==zahl:
print("du hast de richtige Zahl erraten")
else:
print("das ist nicht die gesuchte Zahl")

==== Funktion ====
* erfüllt die Funktion von ''if not''
* erspart dabei Arbeit, weil im Gegensatz zu 'if not' Operator, die Bedingungen, nicht extra im Befehl formuliert werden müssen
* der 'else'-Befehl schließt automatisch alle Bedingungen ein, die nicht vom ''if''-Befehl abgedeckt werden

==== Syntax ====
* nach dem Ausdruck "else" folgt ein Doppelpunkt und der Befehl
* wenn die Bedingung des ''if''-Befehls nicht zutreffen, wird automatisch der ''else''-Befehl ausgeführt

=== ''elif''-Befehl ===

#Befehl
if Bedingung_1:
Befehl_1
elif Bedingung_2:
Befehl_2
elif Bedingung_3:
Befehl_3

==== Funktion ====
* steht für "else if"
* ersetzt die Ineinanderschachtelungen von mehreren ''if''-Befehlen
* ein ''elif''-Befehl wird nur durchgeführt, wenn die vorangegangene ''if''-Bedingung nicht erfüllt wird

==== Syntax ====
* nach dem Ausdruck "elif" folgt die Bedingung, ein Doppelpunkt und der Befehl

== Funktionen ==

#Befehl:
def funktionsname (evtl. Übergabewerte):
Befehl

#Besipiel_1:
def begrüßung():
print("hallo")
begrüßung()

output
hallo

=== Funktion ===
* ein Befehl kann als Funktion abgespeichert werden
* wird der Befehl in einem Programm häufiger verwendet, muss dieser nicht immer wieder erneut geschrieben werden, stattdessen muss nur die Funktion abgerufen werden
* erspart Zeit und sorgt für Übersichtlichkeit des Programms
* noch übersichtlicher wird ein Code, wenn man die Funktionen nicht im Hauptprogramm sondern anderen Daten abspeichern

=== Syntax ===
* nach dem Begriff "def" folg der Name der Funktion (sinnvoll sind Namen, die die Aufgabe der Funktion beschreiben)
* danach folgt eine runde Klammer, in die Klammer können Werte aus dem Hauptprogramm übernommen werden, z.B. wenn die Funktion eine Rechnung darstellt und im Laufe des Programms mit verschiedenen Werten diese Rechnung durchgeführt werden soll (s. Funktionen mit Argumenten)
* werden keine Werte übernommen, bleibt die Klammer leer

=== Funktionen mit Argumenten ===
* wird benutzt, wenn ein bestimmter Wert aus dem Hauptprogramm übernommen werden soll und es sich nicht immer um den gleichen Wert handelt
* die im Beispiel_1 leer geblieben Klammern, haben die Aufgabe einen Wert aus dem Hauptprogramm an die Funktion zu überreichen
* dabei schreibt man den Wert, der überreicht werden soll in die Klammer hinter den Funktionsnamen im Hauptprogramm --> der Wert wird als Argument bezeichnet
* in die Klammer hinter dem Funktionsnamen in der Funktion, schreibt man einen Variablennamen, der automatisch für den Wert aus dem Hauptprogramm steht
* stellvertretend für die Werte aus dem Hauptprogramm, kann mit dem Variablennamen ein Befehl geschrieben werden (s.Beispiel_2)

#Beispiel_2:
def begrüßung(name):
print(name, "sagt hallo")
begrüßung("jack")

output
jack sagt hallo

* die Funktion hallo ist abhängig vom Argument name. Dieses Argument muss der Funktion beim Aufrufen gegeben werden, sonst funktioniert sie nicht
* der Funktion wird „Jack“ als Argument für Name übergeben
* es können nicht nur str, sondern auch int, float und alle weiteren Datentypen und Strukturen, einer Funktion übergeben werden
* es ist auch möglich Funktionen mit mehreren Argumenten zu benutzen, dafür werden die Argumente mit einem Komma voneinander getrennt (s.Beipiel_3)

#Beispeil_3:
def begrüßung(name, zahl):
print("Hallo ich heiße", name)
print("und bin", zahl, "Jahre alt")

eingabe_1=input("Gib hier dienen Namen ein: ")
eingabe_2=eval(input("Gib hier dein Alter ein: "))
begrüßung(eingabe_1, eingabe_2)

output
Hallo ich heiße Jack
und bin 20 Jahre alt

=== Funktionen mit Rückgabewerten: der ''return-Befehl ===

#Befehl
def funktionsname (evtl. Übergabewerte):
Ergebnis=Befehl
return(Ergebnis)

#Beispiel_2:
def Rechnung(zahl):
value=3*zahl**2
return(value)
Ergebnis=Rechnung(4)
print(Ergebnis)

output
48

==== Funktion ====
* die Ergebnisse aus den Funktionen können dem Hauptprogramm übergeben werden um damit weiter arbeiten zu können

==== Syntax ====
* nach dem Schlüsselbegriff "return" folgt eine runde Klammer mit dem Wert der zurückgegeben werden soll
* dieser Wert selbst kann als Variable abgespeichert werden

== Literatur ==
Michael Bonacina: Python 3 Programmieren für Einsteiger. 2. Auflage. BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2

3.Befehle

2023-06-02T09:37:03Z

Ani: Auf wichtige Sicherheitslücke hingewiesen

== ''print''-Befehl ==
‎<syntaxhighlight lang="python">
# Befehl:
print()

# Beispiel:
print("hello")

name = "Max"
print(f"Hallo, {name}!")

# Output:
# hello
# Hallo, Max!
‎</syntaxhighlight>
=== Funktion ===
* der entsprechende Inhalt des ''print''-Befehls wird in der Konsole ausgegeben

=== Syntax ===
* die runden Klammern umschließen das Argument, das ausgegeben wird
* Wörter, bei denen es sich nicht um einen Variablennamen handelt, müssen in Anführungszeichen gesetzt werden
* geschieht das nicht, wird ein Syntaxfehler angezeigt (s. Beispiel_2)
* int und floats werden ohne Anführungszeichen eingegeben
* soll eine Variable innerhalb eines Strings eingefügt werden, kann ein sogenannter f-String genutzt werden. Dazu wird vor die Anführungszeichen ein f geschrieben, innerhalb des Strings werden die geschweiften Klammern dann durch den darin enthaltenen Ausdruck ersetzt (s. Beispiel_1)
‎<syntaxhighlight lang="python">
# Beispiel_2:
print(falsch)

# Output:
# NameError: name 'falsch' is not defined
‎</syntaxhighlight>
* Python geht davon aus, dass es sich bei „falsch“ um eine Variable handelt und möchte den Wert dieser Variablen ausgeben. Es wurde aber keine Variable mit den Namen „falsch“ definiert. Der Fehler kann durch das Hinzufügen von Anführungszeichen behoben werden:

‎<syntaxhighlight lang="python">
print("falsch")

# Output:
# falsch
‎</syntaxhighlight>

== ''type''-Befehl ==
<syntaxhighlight lang="python">
# Befehl
type()

# Beispiel_1:
a = "abc"
d = True
print(type(a))
print(type(1))
print(type(1.0)
print(type(d))

buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
print(type(buch_1))

# Output:
# <class 'str'>
# <class 'int'>
# <class 'float'>
# <class 'bool'>
# <class 'dict'>
‎</syntaxhighlight>
===Funktion===
* mit dem ''type''-Befehl lässt sich der Datentyp bestimmen

=== Syntax ===
* um den Datentyp zu bestimmen wird dieser in die Klammern des ''type''-Befehls geschrieben
* dabei kann es sich direkt um den Datentyp handeln oder einen Variablennamen
* auch hier ist der print Befehl wieder notwendig, um das Ergebnis ausgeben zu lassen
* ohne den print -Befehl wird der type -Befehl zwar ausgeführt, aber nicht in der Konsole ausgegeben

== ''input'' -Befehl ==
<syntaxhighlight lang="python">
# Befehl:
eingabe = input()

# Beispiel:
zahl = input()
print(zahl)

# output
3 # eingegebene Zahl des Nutzers im Eingabefeld
3 # durch print-Befehl ausgegebene Zahl
‎</syntaxhighlight>
=== Funktionen ===
* ermöglicht dem Nutzer die Interaktion mit dem Programm
* so kann z.B. ein Rechenprogramm mit jeder beliebigen vom Nutzer eingegebenen Zahl rechnen und nicht nur mit vorab programmierten Zahlen

=== Syntax ===
* nach den Ausdruck "input" folgt eine Klammer, die bei Ausführung des Programms ein Eingabefeld in der Konsole erzeugt
* gleichzeitig handelt es sich beim ''input''-Befehl auch um ein ''print''-Befehl, dazu muss der entsprechende Text einfach in die Klammer eingegeben werden (s. Beispiel_2)
<syntaxhighlight lang="python">
# Beispiel_2:
zahl = input("Gib hier deine Zahl ein: ")

print(zahl)

# Output:
# Gib hier deine Zahl ein: 3
# 3
‎</syntaxhighlight>
* die Eingabe des Nutzers wird meist durch eine Variable definiert, d.h.:
eingabe = input()
* da der einzutragende Wert bei der Programmierung nicht bekannt ist, kann so „stellvertretend“ mit der Variablen programmiert werden
* s. Beispiel_3, bei der die Rechenoperation „* 2“ mit der Variablen „zahl“ programmiert wird, welche später durch die Eingabe des Nutzers einen Zahlenwert erhält
* der Wert der Variable wird also erst festgelegt, während das Programm läuft
* in der Konsole entsteht durch den ''input-Befehl'' ein „Eingabefeld“ (nicht direkt sichtbar) in das der Nutzer einen Wert (in Beispiel_1 eine Zahl) eintragen kann
* ACHTUNG!: jede Eingabe wird durch den input-Befehl automatisch als string gespeichert
* in Beispiel_3 wird die 3 in string-Form abgespeichert
* die Rechenoperation wird nicht als Multiplikation mit 2 verstanden sondern als Wiederholung des strings
<syntaxhighlight lang="python">
# Beispiel_3:
zahl = input("Gib hier deine Zahl ein: ")
ergebnis = zahl * 2
print(ergebnis)

# output
# Gib hier deine Zahl ein: 3
# 33
‎</syntaxhighlight>
* der string 3 wird wiederholt und es kommt 33 statt 6 heraus
* Lösung: man kann den Datentyp des "inputs" vorab umwandeln:
int(input()) , float(input())
* weiß man vorab nicht, um welchen Datentypen es sich handelt, ist der eval()-Befehl zu empfehlen (s. Beispiel 4) , dieser speichert die Eingabe automatisch unter dem passenden Datentypen ab (string, integer, float)
* hier ist allerdings zu beachten, das in der Konsole ein string wieder in Anführungszeichen gesetzt werden muss
der eval()-Befehl sollte auf keinen Fall benutzt werden, wenn das Programm mit der Außenwelt (z. B. dem Internet oder anderen Dateien interagiert, da dadurch beliebiger Code ausgeführt werden kann! 
<syntaxhighlight lang="python">
# Beispiel_4:
zahl = eval(input("Gib hier deine Zahl ein: "))
ergebnis = zahl * 2
print(ergebnis)

# output
# Gib hier deine Zahl ein: 3
# 6

# oder

# Gib hier deine Zahl ein: 2.4
# 4.8

# oder

# Gib hier deine Zahl ein: "a"
# aa
</syntaxhighlight>

== ''while''-Schleife ==

#Befehl
while Bedingung:
Operation() 
#Beispiel:
n=1
while n<10:
print(n)
n=n+1

output
1
2
3
4
5
6
7
8
9

=== Funktion ===
* bestimmte Operationen werden automatisch wiederholt
* erspart viel Programmierarbeit, da nicht alle Operationen einzeln programmiert werden müssen

=== Syntax ===
* die Schleife wird mit dem Ausdruck "while" begonnen
* darauf folgt eine Bedingung, die überprüft wird (z.B. n<10) gefolgt von einem Doppelpunkt
* in den nächsten Zeilen folgen die Operationen, die innerhalb der Schleife durchgeführt werden sollen
* die zur Schleife gehörenden Operationen sind dadurch gekennzeichnet, dass der Code eingerückt ist
* die ''while''-Schleife sollte so programmiert sein, dass sie irgendwann zu einem Ende kommt und nicht endlos weiterläuft, d.h. die zu überprüfende Bedingung darf irgendwann nicht mehr zutreffen
* --> ansonsten kommt es zu einer endlosen Schleife

==== Ablauf der Schleife ====
* am besten wird die Funktion und die Syntax einer Schleife klar, wenn man sie Schritt für Schritt durchgeht, hier am Beispiel_1:
* '''ersten Zeile: der Variablen n wir der Wert 1 zugeordnet'''
* '''zweite Zeile: so lange n kleiner als 10 ist werden folgende Operationen durchgeführt'''
*(hier wird die Bedingung überprüft, trifft sie zu werden die Operationen der Schleife durchgeführt)
* '''dritte Zeile: gebe den Wert von n aus'''
* (im ersten Durchlauf beträgt der Wert, wie in der ersten Zeile definiert, den Wert 1)
* '''vierte Zeile: definiere die Variable n neu, indem du den Wert von n nimmst und 1 addierst'''
* (n wird neu definiert als der alte Wert von n plus eins, also 1+1, damit ist n jetzt 2)
* sobald die Operationen der Schleife durchgeführt sind, beginnt sie wieder von Neuem, also mit der Überprüfung der Bedingung
* so wird der Wert n immer größer
* erst wenn n=10, trifft die Bedingung nicht zu, die Operationen der Schleife werden nicht durchgeführt
* finden sich weiter Programmzeilen unterhalb der Schleife, die nicht Teil der Schleife sind, werden diese Programmzeilen erst nach Beendigung der Schleife ausgeführt
[[File:Flow diagram while_schleife.png|200px|thumb|center|flowchart ''while''-Schleife]]

== ''len''-Befehl ==

#Befehl
len(liste)

#Beipiel_1:
tier_1=["Hund",100,399,99,True]
print(len(tier_1))

output
5

=== Funktion ===
* gibt die Anzahl an Elementen in einer Liste, Dictionary, Tupel etc. an

=== Syntax ===
* hinter dem Ausdruck "len" wird der Name der Liste in Klammern geschrieben

=== Anwendungsmöglichkeiten ===

==== ''len''-Befehl und ''while''-Schleife ====
* wenn mit der ''while''-Schleife eine Liste ausgeben werden soll, muss die Schleife so programmiert werden, dass die Variable die für die Indexzahl steht maximal so groß wird, wie die Anzahl an Elementen in der Liste (s.Beispiel_2)

#Beispiel_2
i=0
tier_1=["Hund",100,399,99,True]
while i < 5:
print(tier_1[i])
i=i+1

# wird die Variabel "i" größer als die Länge der Liste

i=0
tier_1=["Hund",100,399,99,True]
while i < 6:
print(tier_1[i])
i=i+1

output
Hund
100
399
99
True

# wird die Variabel "i" größer als die Länge der Liste

IndexError: list index out of range

* ist die Länge einer Liste unbekannt oder zu umständlich diese zu ermitteln, hilft der ''len''-Befehl
* statt einer Zahl steht dann "len(name_der_liste)" in der Schleife, dadurch wird die Länge der Liste automatisch ermittelt (s.Beispiel_3)

#Beipiel_3
i=0
tier_1=["Hund",100,399,99,True]
while i < len(tier_1):
print(tier_1[i])
i=i+1

output
Hund
100
399
99
True

== ''for''- Schleife ==

#Befehl:
for element in sammlung:
befehl()

#Beispiel_1:
liste=[“Python”, 1, 4.5, True]

for element in liste:
print(element)

output
Python
1
4.5
True

=== Funktion ===
* erlaubt, wie die ‘‘while‘‘- Schleife, die automatische Wiederholung von Befehlen
* bietet im Gegensatz zur ‘‘while‘‘-Schleife einige Vorteile (viele Funktionen der ''for''-Schleife wären zwar auch mit einer ''while''-Schleifen lösbar, die ''for''-Schleifen macht die Programmierung jedoch deutlich einfacher)
* die ''for''- Schleife eignet sich besonders gut für die einzelne Ausgabe der Elemente von Dictionaries
* sowie die Durchführung von Befehlen, die für jedes Element einer Sequenz (z.B. str) oder Sammlung (z.B. Liste) einmal durchgeführt werden soll

=== Syntax ===
* nach den Ausdruck "for" kommt der Name der Variablen, dieser steht stellvertretend für jedes Element einer Sammlung oder Sequenz
* beim ''input''-Befehl war es vorteilhaft die beim Programmieren noch nicht bekannte (weil erst später durch den Nutzer erfolgende) Eingabe bereits im Programmcode stellvertretende durch eine Variable zu definieren
* so konnte z.B. eine Rechnungen mit einer nicht bekannten Zahl programmiert werden
* das gleiche Prinzip gilt auch für die Variable der "for"-Schleife (diese kann natürlich jeden beliebigen Namen annehmen)
* im Beispiel_1 steht die Variable "element" für die Elemente der Liste namens "liste"
* die Variable "element" steht zwar für alle Elemente der Liste, also “Python”, 1, 4.5 und True, aber nicht gleichzeitig
* im ersten Durchlauf der Schleife steht sie für das erste Element der Liste ("Python"), nun werden die Befehle der Schleife ausgeführt:
* print(element) wird im ersten Durchlauf also zu print("Python")
* im zweiten Durchlauf steht die Variable für das zweite Element (1), print(element) wird im zweiten Durchlauf also zu print(1) usw.
* der darauf folgende Ausdruck "in" dient dazu die Liste, das Dictionary, den String etc. anzugeben, mit dessen Elemente die Schleife durchgeführt werden soll
* dementsprechend folgt darauf der Namen einer Liste, eines Dictionaries oder eines Strings (ein String kann durch eine Variable gespeichert sein oder direkt angegeben werden), daraufhin folgt ein Doppelpunkt
* die zur Schleife gehörenden Operationen sind dadurch gekennzeichnet, dass der Code eingerückt ist

==== Ablauf der Schleife ====
* es wird überprüft ob es ein Element gibt, wessen Wert die Variabel annehmen kann
* trifft das zu laufen die Befehl der Schleife ab, wobei die Variable immer für den entsprechenden Wert des Elements steht
* gibt es keine Elemente mehr, dessen Wert noch nicht angenommen wurde, bricht die Schleife ab
* somit läuft eine for-Schleife immer für jedes Element einmal ab und läuft so häufig ab wie es Elemente gibt (ohne Modifikationen s. unten)

[[File:flowchart ''for''-Schleife.png|200px|thumb|center|flowchart ''for''-Schleife]]

=== Anwendungsmöglichkeiten ===

==== Ausgabe von Dictionaries ====
* einen großen Vorteil bringt die ''for''-Schleife bei der Ausgabe von Dictionaries
* da der Zugriff auf die Elemente in einem Dictionary über keys und nicht Indexzahlen erfolgt, ist die Ausgabe von Dictionaries über eine while Schleife sehr kompliziert und kann nicht in der Form s. Ausgabe von Listen mit ''while''-Schleife erfolgen
* die Ausgabe über die ''for''-Schleife ist sehr einfach und erfolgt wie bei der Ausgabe der Liste
* zu beachten ist, dass hier die Variable nicht den Wert der Elemente, sondern der keys aufnimmt
* schreibt man slo wie in Beispiel_2 die Variable in den ''print''-Befehl der Schleife, werden nur die keys des Dictionaries ausgegeben

#Beispiel_2:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

for element in buch_1:
print(element)

output
Buch
Autor
Preis

* um den Wert des entsprechenden keys ausgeben zu lassen, ist es notwendig die Variable als Index der Liste anzugeben (s. Beispiel_3)
#Beispiel_3:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

for element in buch_1:
print(buch_1[element])

output
Der Herr der Ringe
Tolkien
45

* das klingt erstmal kompliziert, ergibt aber Sinn
* die Ausgabe von Dictionaries erfolgt über die Angabe des keys in eckigen Klammern hinter dem Namen des Dictionaries, dabei steht der key stellvertretend für das jeweilige Element der Liste
* da die Variable der ''for''-Schleife den Wert der keys aufnimmt, wird folglich die Variable in die eckigen Klammern hinter dem Namen des Dictionaries geschrieben

== ''range''-Befehl ==
#Befehl
for element in range(Anzahl):
befehl()

#Beipiel_1:
for element in range(10):
print(element)

output:
0
1
2
3
4
5
6
7
8
9

=== Funktion ===
* für die Wiederholung eines Vorgangs mit einer festen Anzahl an Wiederholungen
* ist auch mit ''while''-Schleife lösbar, wird durch ''range''-Befehl deutlich einfacher

=== Syntax ===
* hinter dem Ausdruck "range" kommt eine Klammer mit der einer Zahl

==== range(stop) ====
* schreibt man in den ''range''-Befehl nur eine Zahl, wird diese als Stoppwert genommen; automatisch ist 0 der Startwert als 1 die Schrittgröße (step)

==== range(start, stop) ====
* schreibt man in den range Befehl zwei Zahlen durch ein Komma getrennt, wird die erste Zahl als Startwert und die zweite als Stoppwert definiert(Stoppwert wird nicht ausgegeben); nimmt 1 als step an

==== range(start, stop, step) ====
* schreibt man in den ''Range''-Befehl drei Zahlen, die jeweils mit einem Komma getrennt sind, wird die dritte Zahl als step definiert

== ''append''-Befehl ==

#Befehl
liste=[element_1,element_2]
liste.append(element_3)

#Beispiel_1:
liste=[1,2,"Apfel"]
liste.append("Baum")

print(liste)

output
[1, 2, 'Apfel', 'Baum']

=== Funktion ===
* fügt einer Liste ein Element hinzu
* wie in Beispiel_1 gezeigt, wird der Liste das Levent "Baum" hinzugefügt

=== Syntax ===
* hinter dem Namen der Liste folgt ein Punkt und der Ausdruck "append", dahinter folg in Klammern das Element, welches der Liste hinzugefügt werden soll
* es ist auch möglich einer Liste mehrere Elemente hinzuzufügen, der Name der hinzuzufügenden Liste wird in den ''append''-Befehl geschrieben
* die Elemente müssen allerdings auch als Liste strukturiert sein (s.Beispiel_2)

#Beispiel_2:
liste_1=[1,2,3,"Baum"]
liste_2=[4,5,6,"Strauch"]
liste_1.append(liste_2)

print(liste_1)

output
[1, 2, 3, 'Baum', [4, 5, 6, 'Strauch']]

* nun wurden zwar die Elemente der liste_2 der liste_1 hinzugefügt, allerdings als Liste in der Liste
* der Grund dafür ist, das der ''append''-Befehl einer Liste immer nur ein Element hinzufügt
* so wird eine Liste, die hinzugefügt werden soll, erst als ein einzelnes Element abgespeichert und dann hinzugefügt
* das Problem lässt sich einfach lösen, indem die Elemente der liste_2 einzeln und nacheinander der liste_1 hinzufügt werden, dafür eignet sich besonders gut eine ''for''-Schleife (s.Beispiel_3)

#Beispeil_3:
liste_1=[1,2,3,"Baum"]
liste_2=[4,5,6,"Strauch"]
for element in liste_2:
liste_1.append(element)

print(liste_1)

output
[1, 2, 3, 'Baum', 4, 5, 6, 'Strauch']

== ''if''-Befehl ==

#Befehl
if Bedingung:
Befehl

#Beispiel:
if 4 < 10:
print("4 ist kleiner als 10")

output
4 ist kleiner als 10

=== Funktion ===
* der ''if''-Befehl macht es einem Computerprorgamm möglich auf verschiedene Ereignisse unterschiedlich zu reagieren
* diese Funktion hebt ein Programm von einer einfachen Rechenanleitung ab

=== Syntax ===
* nach dem Ausdruck "if" folgt die Bedingung die überprüft werden soll, daraufhin ein Doppelpunkt
* die folgenden Kommandozeilen, die zum ''if''-Befehl gehören sind dadurch gekennzeichnet, dass sie versetzt sind

=== Ablauf der Schleife ===
* nach dem Ausdruck "if" wird überprüft ob die darauf folgende Bedingung zutrifft
* trifft die Bedingung zu, werden die Befehle ausgeführt
* trifft die Bedingung nicht zu, werden die Befehle übersprungen
* so ist der Ablauf abhängig von bestimmten Bedingungen und ändert sich je nachdem welche Bedingungen erfüllt bzw. nicht erfüllt werden

=== Bedingungen stellen ===
* die Gleichheit von zwei Werten lässt sich mit "==" überprüfen
* damit kann die Gleichheit von int, str, float und bool überprüft werden (s.Beipsiel_2)

#Befehl
if Bedingung_1 == Bedingung_2:
Befehl

#Beispiel_2:
a=1
b="hallo"
c=True

if a==1:
print(a)
if b=="hallo":
print(b)
if c==True:
print(c)

output
1
hallo
True

* um zu überprüfen ob ein Wert größer oder kleiner als ein anderer ist, werden folgende Symbole verwendet:
<, <= kleiner, kleiner gleich

>, >= größer, größer gleich
* die Ungleichheit lässt sich mit "!=" überprüfen
* mit diesen einfachen Bedingungen und dem ''if''-Befehl lässt sich ganz einfach ein kleines Ratespiel programmieren, welches abhängig von der Eingabe des Nutzers reagieren kann

#Beipiel_3:
eingabe=eval(input("Errate die richtige Zahl zwischen 1 und 10: "))
zahl=8
if eingabe==zahl:
print("du hast de richtige Zahl erraten")
if eingabe!=zahl:
print ("leider falsch, versuche es nochmal")
if eingabe>zahl:
print("versuche eine kleinere Zahl")
if eingabe<zahl:
print("versuche eine größere Zahl")

==== Zusammengesetzte Bedingungen ====
* wenn mehrere Bedingungen gleichzeitig überprüft werden sollen, können diese durch drei Operatoren miteinander verknüpft werden
* das macht einen Code kürzer und übersichtlicher, weil nicht mehrer ''if''-Befehle ineinander geschrieben werden müssen
# "and" wird benutzt wenn zwei oder mehrere Bedingungen gleichzeitig zutreffen müssen
# "or" wird benutzt wenn eine von mehreren möglichen Bedingungen zutreffen muss
# "not" wird zur Verneinung genutzt (hier ist zu beachten, dass alles worauf sich das "not" beziehen soll in klammern gesetzt werden muss, sonst bezieht sich der Ausdruck nur auf das erste Element)

#Beispiel_4:
zahl=6
if zahl <10 and zahl >5:
print("richtig")

#anstatt
if zahl <10:
if zahl>5:
print("richtig")

=== ''else''-Befehl ===

#Befehl
if Bedingung:
Befehl_1
else:
Befehl_2

#Beispiel_1:
eingabe=eval(input("Errate die richtige Zahl zwischen 1 und 10: "))
zahl=8

if eingabe==zahl:
print("du hast de richtige Zahl erraten")
else:
print("das ist nicht die gesuchte Zahl")

==== Funktion ====
* erfüllt die Funktion von ''if not''
* erspart dabei Arbeit, weil im Gegensatz zu 'if not' Operator, die Bedingungen, nicht extra im Befehl formuliert werden müssen
* der 'else'-Befehl schließt automatisch alle Bedingungen ein, die nicht vom ''if''-Befehl abgedeckt werden

==== Syntax ====
* nach dem Ausdruck "else" folgt ein Doppelpunkt und der Befehl
* wenn die Bedingung des ''if''-Befehls nicht zutreffen, wird automatisch der ''else''-Befehl ausgeführt

=== ''elif''-Befehl ===

#Befehl
if Bedingung_1:
Befehl_1
elif Bedingung_2:
Befehl_2
elif Bedingung_3:
Befehl_3

==== Funktion ====
* steht für "else if"
* ersetzt die Ineinanderschachtelungen von mehreren ''if''-Befehlen
* ein ''elif''-Befehl wird nur durchgeführt, wenn die vorangegangene ''if''-Bedingung nicht erfüllt wird

==== Syntax ====
* nach dem Ausdruck "elif" folgt die Bedingung, ein Doppelpunkt und der Befehl

== Funktionen ==

#Befehl:
def funktionsname (evtl. Übergabewerte):
Befehl

#Besipiel_1:
def begrüßung():
print("hallo")
begrüßung()

output
hallo

=== Funktion ===
* ein Befehl kann als Funktion abgespeichert werden
* wird der Befehl in einem Programm häufiger verwendet, muss dieser nicht immer wieder erneut geschrieben werden, stattdessen muss nur die Funktion abgerufen werden
* erspart Zeit und sorgt für Übersichtlichkeit des Programms
* noch übersichtlicher wird ein Code, wenn man die Funktionen nicht im Hauptprogramm sondern anderen Daten abspeichern

=== Syntax ===
* nach dem Begriff "def" folg der Name der Funktion (sinnvoll sind Namen, die die Aufgabe der Funktion beschreiben)
* danach folgt eine runde Klammer, in die Klammer können Werte aus dem Hauptprogramm übernommen werden, z.B. wenn die Funktion eine Rechnung darstellt und im Laufe des Programms mit verschiedenen Werten diese Rechnung durchgeführt werden soll (s. Funktionen mit Argumenten)
* werden keine Werte übernommen, bleibt die Klammer leer

=== Funktionen mit Argumenten ===
* wird benutzt, wenn ein bestimmter Wert aus dem Hauptprogramm übernommen werden soll und es sich nicht immer um den gleichen Wert handelt
* die im Beispiel_1 leer geblieben Klammern, haben die Aufgabe einen Wert aus dem Hauptprogramm an die Funktion zu überreichen
* dabei schreibt man den Wert, der überreicht werden soll in die Klammer hinter den Funktionsnamen im Hauptprogramm --> der Wert wird als Argument bezeichnet
* in die Klammer hinter dem Funktionsnamen in der Funktion, schreibt man einen Variablennamen, der automatisch für den Wert aus dem Hauptprogramm steht
* stellvertretend für die Werte aus dem Hauptprogramm, kann mit dem Variablennamen ein Befehl geschrieben werden (s.Beispiel_2)

#Beispiel_2:
def begrüßung(name):
print(name, "sagt hallo")
begrüßung("jack")

output
jack sagt hallo

* die Funktion hallo ist abhängig vom Argument name. Dieses Argument muss der Funktion beim Aufrufen gegeben werden, sonst funktioniert sie nicht
* der Funktion wird „Jack“ als Argument für Name übergeben
* es können nicht nur str, sondern auch int, float und alle weiteren Datentypen und Strukturen, einer Funktion übergeben werden
* es ist auch möglich Funktionen mit mehreren Argumenten zu benutzen, dafür werden die Argumente mit einem Komma voneinander getrennt (s.Beipiel_3)

#Beispeil_3:
def begrüßung(name, zahl):
print("Hallo ich heiße", name)
print("und bin", zahl, "Jahre alt")

eingabe_1=input("Gib hier dienen Namen ein: ")
eingabe_2=eval(input("Gib hier dein Alter ein: "))
begrüßung(eingabe_1, eingabe_2)

output
Hallo ich heiße Jack
und bin 20 Jahre alt

=== Funktionen mit Rückgabewerten: der ''return-Befehl ===

#Befehl
def funktionsname (evtl. Übergabewerte):
Ergebnis=Befehl
return(Ergebnis)

#Beispiel_2:
def Rechnung(zahl):
value=3*zahl**2
return(value)
Ergebnis=Rechnung(4)
print(Ergebnis)

output
48

==== Funktion ====
* die Ergebnisse aus den Funktionen können dem Hauptprogramm übergeben werden um damit weiter arbeiten zu können

==== Syntax ====
* nach dem Schlüsselbegriff "return" folgt eine runde Klammer mit dem Wert der zurückgegeben werden soll
* dieser Wert selbst kann als Variable abgespeichert werden

== Literatur ==
Michael Bonacina: Python 3 Programmieren für Einsteiger. 2. Auflage. BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2

3.Befehle

2023-05-28T14:56:31Z

Ani: Print und Input-Dokumentation überarbeitet

== ''print''-Befehl ==
‎<syntaxhighlight lang="python">
# Befehl:
print()

# Beispiel:
print("hello")

name = "Max"
print(f"Hallo, {name}!")

# Output:
# hello
# Hallo, Max!
‎</syntaxhighlight>
=== Funktion ===
* der entsprechende Inhalt des ''print''-Befehls wird in der Konsole ausgegeben

=== Syntax ===
* die runden Klammern umschließen das Argument, das ausgegeben wird
* Wörter, bei denen es sich nicht um einen Variablennamen handelt, müssen in Anführungszeichen gesetzt werden
* geschieht das nicht, wird ein Syntaxfehler angezeigt (s. Beispiel_2)
* int und floats werden ohne Anführungszeichen eingegeben
* soll eine Variable innerhalb eines Strings eingefügt werden, kann ein sogenannter f-String genutzt werden. Dazu wird vor die Anführungszeichen ein f geschrieben, innerhalb des Strings werden die geschweiften Klammern dann durch den darin enthaltenen Ausdruck ersetzt (s. Beispiel_1)
‎<syntaxhighlight lang="python">
# Beispiel_2:
print(falsch)

# Output:
# NameError: name 'falsch' is not defined
‎</syntaxhighlight>
* Python geht davon aus, dass es sich bei „falsch“ um eine Variable handelt und möchte den Wert dieser Variablen ausgeben. Es wurde aber keine Variable mit den Namen „falsch“ definiert. Der Fehler kann durch das Hinzufügen von Anführungszeichen behoben werden:

‎<syntaxhighlight lang="python">
print("falsch")

# Output:
# falsch
‎</syntaxhighlight>

== ''type''-Befehl ==
<syntaxhighlight lang="python">
# Befehl
type()

# Beispiel_1:
a = "abc"
d = True
print(type(a))
print(type(1))
print(type(1.0)
print(type(d))

buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
print(type(buch_1))

# Output:
# <class 'str'>
# <class 'int'>
# <class 'float'>
# <class 'bool'>
# <class 'dict'>
‎</syntaxhighlight>
===Funktion===
* mit dem ''type''-Befehl lässt sich der Datentyp bestimmen

=== Syntax ===
* um den Datentyp zu bestimmen wird dieser in die Klammern des ''type''-Befehls geschrieben
* dabei kann es sich direkt um den Datentyp handeln oder einen Variablennamen
* auch hier ist der print Befehl wieder notwendig, um das Ergebnis ausgeben zu lassen
* ohne den print -Befehl wird der type -Befehl zwar ausgeführt, aber nicht in der Konsole ausgegeben

== ''input'' -Befehl ==
<syntaxhighlight lang="python">
# Befehl:
eingabe = input()

# Beispiel:
zahl = input()
print(zahl)

# output
3 # eingegebene Zahl des Nutzers im Eingabefeld
3 # durch print-Befehl ausgegebene Zahl
‎</syntaxhighlight>
=== Funktionen ===
* ermöglicht dem Nutzer die Interaktion mit dem Programm
* so kann z.B. ein Rechenprogramm mit jeder beliebigen vom Nutzer eingegebenen Zahl rechnen und nicht nur mit vorab programmierten Zahlen

=== Syntax ===
* nach den Ausdruck "input" folgt eine Klammer, die bei Ausführung des Programms ein Eingabefeld in der Konsole erzeugt
* gleichzeitig handelt es sich beim ''input''-Befehl auch um ein ''print''-Befehl, dazu muss der entsprechende Text einfach in die Klammer eingegeben werden (s. Beispiel_2)
<syntaxhighlight lang="python">
# Beispiel_2:
zahl = input("Gib hier deine Zahl ein: ")

print(zahl)

# Output:
# Gib hier deine Zahl ein: 3
# 3
‎</syntaxhighlight>
* die Eingabe des Nutzers wird meist durch eine Variable definiert, d.h.:
eingabe = input()
* da der einzutragende Wert bei der Programmierung nicht bekannt ist, kann so „stellvertretend“ mit der Variablen programmiert werden
* s. Beispiel_3, bei der die Rechenoperation „* 2“ mit der Variablen „zahl“ programmiert wird, welche später durch die Eingabe des Nutzers einen Zahlenwert erhält
* der Wert der Variable wird also erst festgelegt, während das Programm läuft
* in der Konsole entsteht durch den ''input-Befehl'' ein „Eingabefeld“ (nicht direkt sichtbar) in das der Nutzer einen Wert (in Beispiel_1 eine Zahl) eintragen kann
* ACHTUNG!: jede Eingabe wird durch den input-Befehl automatisch als string gespeichert
* in Beispiel_3 wird die 3 in string-Form abgespeichert
* die Rechenoperation wird nicht als Multiplikation mit 2 verstanden sondern als Wiederholung des strings
<syntaxhighlight lang="python">
# Beispiel_3:
zahl = input("Gib hier deine Zahl ein: ")
ergebnis = zahl * 2
print(ergebnis)

# output
# Gib hier deine Zahl ein: 3
# 33
‎</syntaxhighlight>
* der string 3 wird wiederholt und es kommt 33 statt 6 heraus
* Lösung: man kann den Datentyp des "inputs" vorab umwandeln:
int(input()) , float(input())
* weiß man vorab nicht, um welchen Datentypen es sich handelt, ist der eval()-Befehl zu empfehlen (s. Beispiel 4) , dieser speichert die Eingabe automatisch unter dem passenden Datentypen ab (string, integer, float)
* hier ist allerdings zu beachten, das in der Konsole ein string wieder in Anführungszeichen gesetzt werden muss
<syntaxhighlight lang="python">
# Beispiel_4:
zahl = eval(input("Gib hier deine Zahl ein: "))
ergebnis = zahl * 2
print(ergebnis)

# output
# Gib hier deine Zahl ein: 3
# 6

# oder

# Gib hier deine Zahl ein: 2.4
# 4.8

# oder

# Gib hier deine Zahl ein: "a"
# aa
</syntaxhighlight>
== ''while''-Schleife ==

#Befehl
while Bedingung:
Operation() 
#Beispiel:
n=1
while n<10:
print(n)
n=n+1

output
1
2
3
4
5
6
7
8
9

=== Funktion ===
* bestimmte Operationen werden automatisch wiederholt
* erspart viel Programmierarbeit, da nicht alle Operationen einzeln programmiert werden müssen

=== Syntax ===
* die Schleife wird mit dem Ausdruck "while" begonnen
* darauf folgt eine Bedingung, die überprüft wird (z.B. n<10) gefolgt von einem Doppelpunkt
* in den nächsten Zeilen folgen die Operationen, die innerhalb der Schleife durchgeführt werden sollen
* die zur Schleife gehörenden Operationen sind dadurch gekennzeichnet, dass der Code eingerückt ist
* die ''while''-Schleife sollte so programmiert sein, dass sie irgendwann zu einem Ende kommt und nicht endlos weiterläuft, d.h. die zu überprüfende Bedingung darf irgendwann nicht mehr zutreffen
* --> ansonsten kommt es zu einer endlosen Schleife

==== Ablauf der Schleife ====
* am besten wird die Funktion und die Syntax einer Schleife klar, wenn man sie Schritt für Schritt durchgeht, hier am Beispiel_1:
* '''ersten Zeile: der Variablen n wir der Wert 1 zugeordnet'''
* '''zweite Zeile: so lange n kleiner als 10 ist werden folgende Operationen durchgeführt'''
*(hier wird die Bedingung überprüft, trifft sie zu werden die Operationen der Schleife durchgeführt)
* '''dritte Zeile: gebe den Wert von n aus'''
* (im ersten Durchlauf beträgt der Wert, wie in der ersten Zeile definiert, den Wert 1)
* '''vierte Zeile: definiere die Variable n neu, indem du den Wert von n nimmst und 1 addierst'''
* (n wird neu definiert als der alte Wert von n plus eins, also 1+1, damit ist n jetzt 2)
* sobald die Operationen der Schleife durchgeführt sind, beginnt sie wieder von Neuem, also mit der Überprüfung der Bedingung
* so wird der Wert n immer größer
* erst wenn n=10, trifft die Bedingung nicht zu, die Operationen der Schleife werden nicht durchgeführt
* finden sich weiter Programmzeilen unterhalb der Schleife, die nicht Teil der Schleife sind, werden diese Programmzeilen erst nach Beendigung der Schleife ausgeführt
[[File:Flow diagram while_schleife.png|200px|thumb|center|flowchart ''while''-Schleife]]

== ''len''-Befehl ==

#Befehl
len(liste)

#Beipiel_1:
tier_1=["Hund",100,399,99,True]
print(len(tier_1))

output
5

=== Funktion ===
* gibt die Anzahl an Elementen in einer Liste, Dictionary, Tupel etc. an

=== Syntax ===
* hinter dem Ausdruck "len" wird der Name der Liste in Klammern geschrieben

=== Anwendungsmöglichkeiten ===

==== ''len''-Befehl und ''while''-Schleife ====
* wenn mit der ''while''-Schleife eine Liste ausgeben werden soll, muss die Schleife so programmiert werden, dass die Variable die für die Indexzahl steht maximal so groß wird, wie die Anzahl an Elementen in der Liste (s.Beispiel_2)

#Beispiel_2
i=0
tier_1=["Hund",100,399,99,True]
while i < 5:
print(tier_1[i])
i=i+1

# wird die Variabel "i" größer als die Länge der Liste

i=0
tier_1=["Hund",100,399,99,True]
while i < 6:
print(tier_1[i])
i=i+1

output
Hund
100
399
99
True

# wird die Variabel "i" größer als die Länge der Liste

IndexError: list index out of range

* ist die Länge einer Liste unbekannt oder zu umständlich diese zu ermitteln, hilft der ''len''-Befehl
* statt einer Zahl steht dann "len(name_der_liste)" in der Schleife, dadurch wird die Länge der Liste automatisch ermittelt (s.Beispiel_3)

#Beipiel_3
i=0
tier_1=["Hund",100,399,99,True]
while i < len(tier_1):
print(tier_1[i])
i=i+1

output
Hund
100
399
99
True

== ''for''- Schleife ==

#Befehl:
for element in sammlung:
befehl()

#Beispiel_1:
liste=[“Python”, 1, 4.5, True]

for element in liste:
print(element)

output
Python
1
4.5
True

=== Funktion ===
* erlaubt, wie die ‘‘while‘‘- Schleife, die automatische Wiederholung von Befehlen
* bietet im Gegensatz zur ‘‘while‘‘-Schleife einige Vorteile (viele Funktionen der ''for''-Schleife wären zwar auch mit einer ''while''-Schleifen lösbar, die ''for''-Schleifen macht die Programmierung jedoch deutlich einfacher)
* die ''for''- Schleife eignet sich besonders gut für die einzelne Ausgabe der Elemente von Dictionaries
* sowie die Durchführung von Befehlen, die für jedes Element einer Sequenz (z.B. str) oder Sammlung (z.B. Liste) einmal durchgeführt werden soll

=== Syntax ===
* nach den Ausdruck "for" kommt der Name der Variablen, dieser steht stellvertretend für jedes Element einer Sammlung oder Sequenz
* beim ''input''-Befehl war es vorteilhaft die beim Programmieren noch nicht bekannte (weil erst später durch den Nutzer erfolgende) Eingabe bereits im Programmcode stellvertretende durch eine Variable zu definieren
* so konnte z.B. eine Rechnungen mit einer nicht bekannten Zahl programmiert werden
* das gleiche Prinzip gilt auch für die Variable der "for"-Schleife (diese kann natürlich jeden beliebigen Namen annehmen)
* im Beispiel_1 steht die Variable "element" für die Elemente der Liste namens "liste"
* die Variable "element" steht zwar für alle Elemente der Liste, also “Python”, 1, 4.5 und True, aber nicht gleichzeitig
* im ersten Durchlauf der Schleife steht sie für das erste Element der Liste ("Python"), nun werden die Befehle der Schleife ausgeführt:
* print(element) wird im ersten Durchlauf also zu print("Python")
* im zweiten Durchlauf steht die Variable für das zweite Element (1), print(element) wird im zweiten Durchlauf also zu print(1) usw.
* der darauf folgende Ausdruck "in" dient dazu die Liste, das Dictionary, den String etc. anzugeben, mit dessen Elemente die Schleife durchgeführt werden soll
* dementsprechend folgt darauf der Namen einer Liste, eines Dictionaries oder eines Strings (ein String kann durch eine Variable gespeichert sein oder direkt angegeben werden), daraufhin folgt ein Doppelpunkt
* die zur Schleife gehörenden Operationen sind dadurch gekennzeichnet, dass der Code eingerückt ist

==== Ablauf der Schleife ====
* es wird überprüft ob es ein Element gibt, wessen Wert die Variabel annehmen kann
* trifft das zu laufen die Befehl der Schleife ab, wobei die Variable immer für den entsprechenden Wert des Elements steht
* gibt es keine Elemente mehr, dessen Wert noch nicht angenommen wurde, bricht die Schleife ab
* somit läuft eine for-Schleife immer für jedes Element einmal ab und läuft so häufig ab wie es Elemente gibt (ohne Modifikationen s. unten)

[[File:flowchart ''for''-Schleife.png|200px|thumb|center|flowchart ''for''-Schleife]]

=== Anwendungsmöglichkeiten ===

==== Ausgabe von Dictionaries ====
* einen großen Vorteil bringt die ''for''-Schleife bei der Ausgabe von Dictionaries
* da der Zugriff auf die Elemente in einem Dictionary über keys und nicht Indexzahlen erfolgt, ist die Ausgabe von Dictionaries über eine while Schleife sehr kompliziert und kann nicht in der Form s. Ausgabe von Listen mit ''while''-Schleife erfolgen
* die Ausgabe über die ''for''-Schleife ist sehr einfach und erfolgt wie bei der Ausgabe der Liste
* zu beachten ist, dass hier die Variable nicht den Wert der Elemente, sondern der keys aufnimmt
* schreibt man slo wie in Beispiel_2 die Variable in den ''print''-Befehl der Schleife, werden nur die keys des Dictionaries ausgegeben

#Beispiel_2:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

for element in buch_1:
print(element)

output
Buch
Autor
Preis

* um den Wert des entsprechenden keys ausgeben zu lassen, ist es notwendig die Variable als Index der Liste anzugeben (s. Beispiel_3)
#Beispiel_3:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

for element in buch_1:
print(buch_1[element])

output
Der Herr der Ringe
Tolkien
45

* das klingt erstmal kompliziert, ergibt aber Sinn
* die Ausgabe von Dictionaries erfolgt über die Angabe des keys in eckigen Klammern hinter dem Namen des Dictionaries, dabei steht der key stellvertretend für das jeweilige Element der Liste
* da die Variable der ''for''-Schleife den Wert der keys aufnimmt, wird folglich die Variable in die eckigen Klammern hinter dem Namen des Dictionaries geschrieben

== ''range''-Befehl ==
#Befehl
for element in range(Anzahl):
befehl()

#Beipiel_1:
for element in range(10):
print(element)

output:
0
1
2
3
4
5
6
7
8
9

=== Funktion ===
* für die Wiederholung eines Vorgangs mit einer festen Anzahl an Wiederholungen
* ist auch mit ''while''-Schleife lösbar, wird durch ''range''-Befehl deutlich einfacher

=== Syntax ===
* hinter dem Ausdruck "range" kommt eine Klammer mit der einer Zahl

==== range(stop) ====
* schreibt man in den ''range''-Befehl nur eine Zahl, wird diese als Stoppwert genommen; automatisch ist 0 der Startwert als 1 die Schrittgröße (step)

==== range(start, stop) ====
* schreibt man in den range Befehl zwei Zahlen durch ein Komma getrennt, wird die erste Zahl als Startwert und die zweite als Stoppwert definiert(Stoppwert wird nicht ausgegeben); nimmt 1 als step an

==== range(start, stop, step) ====
* schreibt man in den ''Range''-Befehl drei Zahlen, die jeweils mit einem Komma getrennt sind, wird die dritte Zahl als step definiert

== ''append''-Befehl ==

#Befehl
liste=[element_1,element_2]
liste.append(element_3)

#Beispiel_1:
liste=[1,2,"Apfel"]
liste.append("Baum")

print(liste)

output
[1, 2, 'Apfel', 'Baum']

=== Funktion ===
* fügt einer Liste ein Element hinzu
* wie in Beispiel_1 gezeigt, wird der Liste das Levent "Baum" hinzugefügt

=== Syntax ===
* hinter dem Namen der Liste folgt ein Punkt und der Ausdruck "append", dahinter folg in Klammern das Element, welches der Liste hinzugefügt werden soll
* es ist auch möglich einer Liste mehrere Elemente hinzuzufügen, der Name der hinzuzufügenden Liste wird in den ''append''-Befehl geschrieben
* die Elemente müssen allerdings auch als Liste strukturiert sein (s.Beispiel_2)

#Beispiel_2:
liste_1=[1,2,3,"Baum"]
liste_2=[4,5,6,"Strauch"]
liste_1.append(liste_2)

print(liste_1)

output
[1, 2, 3, 'Baum', [4, 5, 6, 'Strauch']]

* nun wurden zwar die Elemente der liste_2 der liste_1 hinzugefügt, allerdings als Liste in der Liste
* der Grund dafür ist, das der ''append''-Befehl einer Liste immer nur ein Element hinzufügt
* so wird eine Liste, die hinzugefügt werden soll, erst als ein einzelnes Element abgespeichert und dann hinzugefügt
* das Problem lässt sich einfach lösen, indem die Elemente der liste_2 einzeln und nacheinander der liste_1 hinzufügt werden, dafür eignet sich besonders gut eine ''for''-Schleife (s.Beispiel_3)

#Beispeil_3:
liste_1=[1,2,3,"Baum"]
liste_2=[4,5,6,"Strauch"]
for element in liste_2:
liste_1.append(element)

print(liste_1)

output
[1, 2, 3, 'Baum', 4, 5, 6, 'Strauch']

== ''if''-Befehl ==

#Befehl
if Bedingung:
Befehl

#Beispiel:
if 4 < 10:
print("4 ist kleiner als 10")

output
4 ist kleiner als 10

=== Funktion ===
* der ''if''-Befehl macht es einem Computerprorgamm möglich auf verschiedene Ereignisse unterschiedlich zu reagieren
* diese Funktion hebt ein Programm von einer einfachen Rechenanleitung ab

=== Syntax ===
* nach dem Ausdruck "if" folgt die Bedingung die überprüft werden soll, daraufhin ein Doppelpunkt
* die folgenden Kommandozeilen, die zum ''if''-Befehl gehören sind dadurch gekennzeichnet, dass sie versetzt sind

=== Ablauf der Schleife ===
* nach dem Ausdruck "if" wird überprüft ob die darauf folgende Bedingung zutrifft
* trifft die Bedingung zu, werden die Befehle ausgeführt
* trifft die Bedingung nicht zu, werden die Befehle übersprungen
* so ist der Ablauf abhängig von bestimmten Bedingungen und ändert sich je nachdem welche Bedingungen erfüllt bzw. nicht erfüllt werden

=== Bedingungen stellen ===
* die Gleichheit von zwei Werten lässt sich mit "==" überprüfen
* damit kann die Gleichheit von int, str, float und bool überprüft werden (s.Beipsiel_2)

#Befehl
if Bedingung_1 == Bedingung_2:
Befehl

#Beispiel_2:
a=1
b="hallo"
c=True

if a==1:
print(a)
if b=="hallo":
print(b)
if c==True:
print(c)

output
1
hallo
True

* um zu überprüfen ob ein Wert größer oder kleiner als ein anderer ist, werden folgende Symbole verwendet:
<, <= kleiner, kleiner gleich

>, >= größer, größer gleich
* die Ungleichheit lässt sich mit "!=" überprüfen
* mit diesen einfachen Bedingungen und dem ''if''-Befehl lässt sich ganz einfach ein kleines Ratespiel programmieren, welches abhängig von der Eingabe des Nutzers reagieren kann

#Beipiel_3:
eingabe=eval(input("Errate die richtige Zahl zwischen 1 und 10: "))
zahl=8
if eingabe==zahl:
print("du hast de richtige Zahl erraten")
if eingabe!=zahl:
print ("leider falsch, versuche es nochmal")
if eingabe>zahl:
print("versuche eine kleinere Zahl")
if eingabe<zahl:
print("versuche eine größere Zahl")

==== Zusammengesetzte Bedingungen ====
* wenn mehrere Bedingungen gleichzeitig überprüft werden sollen, können diese durch drei Operatoren miteinander verknüpft werden
* das macht einen Code kürzer und übersichtlicher, weil nicht mehrer ''if''-Befehle ineinander geschrieben werden müssen
# "and" wird benutzt wenn zwei oder mehrere Bedingungen gleichzeitig zutreffen müssen
# "or" wird benutzt wenn eine von mehreren möglichen Bedingungen zutreffen muss
# "not" wird zur Verneinung genutzt (hier ist zu beachten, dass alles worauf sich das "not" beziehen soll in klammern gesetzt werden muss, sonst bezieht sich der Ausdruck nur auf das erste Element)

#Beispiel_4:
zahl=6
if zahl <10 and zahl >5:
print("richtig")

#anstatt
if zahl <10:
if zahl>5:
print("richtig")

=== ''else''-Befehl ===

#Befehl
if Bedingung:
Befehl_1
else:
Befehl_2

#Beispiel_1:
eingabe=eval(input("Errate die richtige Zahl zwischen 1 und 10: "))
zahl=8

if eingabe==zahl:
print("du hast de richtige Zahl erraten")
else:
print("das ist nicht die gesuchte Zahl")

==== Funktion ====
* erfüllt die Funktion von ''if not''
* erspart dabei Arbeit, weil im Gegensatz zu 'if not' Operator, die Bedingungen, nicht extra im Befehl formuliert werden müssen
* der 'else'-Befehl schließt automatisch alle Bedingungen ein, die nicht vom ''if''-Befehl abgedeckt werden

==== Syntax ====
* nach dem Ausdruck "else" folgt ein Doppelpunkt und der Befehl
* wenn die Bedingung des ''if''-Befehls nicht zutreffen, wird automatisch der ''else''-Befehl ausgeführt

=== ''elif''-Befehl ===

#Befehl
if Bedingung_1:
Befehl_1
elif Bedingung_2:
Befehl_2
elif Bedingung_3:
Befehl_3

==== Funktion ====
* steht für "else if"
* ersetzt die Ineinanderschachtelungen von mehreren ''if''-Befehlen
* ein ''elif''-Befehl wird nur durchgeführt, wenn die vorangegangene ''if''-Bedingung nicht erfüllt wird

==== Syntax ====
* nach dem Ausdruck "elif" folgt die Bedingung, ein Doppelpunkt und der Befehl

== Funktionen ==

#Befehl:
def funktionsname (evtl. Übergabewerte):
Befehl

#Besipiel_1:
def begrüßung():
print("hallo")
begrüßung()

output
hallo

=== Funktion ===
* ein Befehl kann als Funktion abgespeichert werden
* wird der Befehl in einem Programm häufiger verwendet, muss dieser nicht immer wieder erneut geschrieben werden, stattdessen muss nur die Funktion abgerufen werden
* erspart Zeit und sorgt für Übersichtlichkeit des Programms
* noch übersichtlicher wird ein Code, wenn man die Funktionen nicht im Hauptprogramm sondern anderen Daten abspeichern

=== Syntax ===
* nach dem Begriff "def" folg der Name der Funktion (sinnvoll sind Namen, die die Aufgabe der Funktion beschreiben)
* danach folgt eine runde Klammer, in die Klammer können Werte aus dem Hauptprogramm übernommen werden, z.B. wenn die Funktion eine Rechnung darstellt und im Laufe des Programms mit verschiedenen Werten diese Rechnung durchgeführt werden soll (s. Funktionen mit Argumenten)
* werden keine Werte übernommen, bleibt die Klammer leer

=== Funktionen mit Argumenten ===
* wird benutzt, wenn ein bestimmter Wert aus dem Hauptprogramm übernommen werden soll und es sich nicht immer um den gleichen Wert handelt
* die im Beispiel_1 leer geblieben Klammern, haben die Aufgabe einen Wert aus dem Hauptprogramm an die Funktion zu überreichen
* dabei schreibt man den Wert, der überreicht werden soll in die Klammer hinter den Funktionsnamen im Hauptprogramm --> der Wert wird als Argument bezeichnet
* in die Klammer hinter dem Funktionsnamen in der Funktion, schreibt man einen Variablennamen, der automatisch für den Wert aus dem Hauptprogramm steht
* stellvertretend für die Werte aus dem Hauptprogramm, kann mit dem Variablennamen ein Befehl geschrieben werden (s.Beispiel_2)

#Beispiel_2:
def begrüßung(name):
print(name, "sagt hallo")
begrüßung("jack")

output
jack sagt hallo

* die Funktion hallo ist abhängig vom Argument name. Dieses Argument muss der Funktion beim Aufrufen gegeben werden, sonst funktioniert sie nicht
* der Funktion wird „Jack“ als Argument für Name übergeben
* es können nicht nur str, sondern auch int, float und alle weiteren Datentypen und Strukturen, einer Funktion übergeben werden
* es ist auch möglich Funktionen mit mehreren Argumenten zu benutzen, dafür werden die Argumente mit einem Komma voneinander getrennt (s.Beipiel_3)

#Beispeil_3:
def begrüßung(name, zahl):
print("Hallo ich heiße", name)
print("und bin", zahl, "Jahre alt")

eingabe_1=input("Gib hier dienen Namen ein: ")
eingabe_2=eval(input("Gib hier dein Alter ein: "))
begrüßung(eingabe_1, eingabe_2)

output
Hallo ich heiße Jack
und bin 20 Jahre alt

=== Funktionen mit Rückgabewerten: der ''return-Befehl ===

#Befehl
def funktionsname (evtl. Übergabewerte):
Ergebnis=Befehl
return(Ergebnis)

#Beispiel_2:
def Rechnung(zahl):
value=3*zahl**2
return(value)
Ergebnis=Rechnung(4)
print(Ergebnis)

output
48

==== Funktion ====
* die Ergebnisse aus den Funktionen können dem Hauptprogramm übergeben werden um damit weiter arbeiten zu können

==== Syntax ====
* nach dem Schlüsselbegriff "return" folgt eine runde Klammer mit dem Wert der zurückgegeben werden soll
* dieser Wert selbst kann als Variable abgespeichert werden

== Literatur ==
Michael Bonacina: Python 3 Programmieren für Einsteiger. 2. Auflage. BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2

2.Datentypen und Datenstrukturen

2023-05-28T12:57:28Z

Ani: /* Tupel */

__TOC__

== Datentypen ==

In Python unterscheidet man vier verschiedene Datentypen (Klassen):
{| class="wikitable"
|-
! Datentyp !! Abkürzung !! Bedeutung !! Beispiel
|-
| String || str || Zeichenkette || "abc"
|-
| Integer || int || Ganze Zahl || 1
|-
| Float || float || Dezimalzahl || 1.0
|-
| Boolean || bool || Wahrheitsgehalt || True, False
|}

Der Datentyp kann durch den ''type''-Befehl abgefragt werden.
 Beispiel:
‎<syntaxhighlight lang="python">
sequence = "ACGT"
result = type(sequence)
print(result)
# Output: <class 'str'>
‎</syntaxhighlight>

== Datenstrukturen ==

Man unterscheidet zwischen drei verscheiden Datenstrukturen:
Listen, Dictionary und Tupel. Alle diese Datenstrukturen stellen Organisationsformen
von Daten in Python dar. Das heißt sie erleichtern vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheiden sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

‎<syntaxhighlight lang="python">
#Befehl:
liste = ['string', variable, 1, 2.0, True]

# Beispiel_1:

hund = ['Hund', 100, 399, 99, True]
katze = ['Katze', 60, 249, 99, True]
fisch = ['Fisch', 3, 1, 50, False]

print(hund)
print(katze)
print(fisch)

# output
# ['Hund', 100, 399, 99, True]
# ['Katze', 60, 249, 99, True]
# ['Fisch', 3, 1, 50, False]
‎</syntaxhighlight>
==== Funktion ====
* haben dieselbe Funktion wie Listen im echten Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht das Programm übersichtlicher und erleichtert die Arbeit, weil nicht jeder einzelne Wert mit einem eigenen Variablennamen gespeichert werden muss

==== Syntax ====
* die Liste erhält einen Namen, welcher wie eine Variable durch ein Gleichheitszeichen den Elementen der Liste zugeordnet wird
* die Elemente der Liste werden in eckige Klammern gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können verschiedene Datentypen auf einmal vorkommen

===== Liste ausgeben lassen =====
* die ganze Liste lässt sich durch einen print-Befehl ausgeben (s. Beispiel_1)

====== einzelne Elemente der Liste ausgeben lassen ======
* auch einzelne Elemente der Liste können ausgegeben werden (s. Beispiel_2)
* dabei wird die Position des auszugebenden Elements durch eine Indexzahl in eckigen Klammern nach dem Listennamen angegeben
* Achtung: grundsätzlich zählt man von 0 ausgehend, d.h. das erste Element in der Liste besitzt die Position 0, das zweite die Position 1 etc.
* es kann auch von hinten gezählt werden, dabei besitzt das erste Element (welches von vorne gezählt das letzte wäre) die Position -1 usw.

====== Bereich der Liste ausgeben lassen ======
* es lässt sich auch ein bestimmter Bereich der Liste ausgeben, wobei die Positionen der Elemente durch einen Doppelpunkt getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein, welche ausgegeben wird (engl. inclusive)
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird (engl. exclusive)
* um die Syntax des Befehls zu verstehen, ist es sinnvoll, die verschiedenen Möglichkeiten einmal selbst auszuprobieren und die Aufgaben 4 und 5 auf dem Aufgabenblatt zu bearbeiten
‎<syntaxhighlight lang="python">
# Befehl:
print(liste[Position])

# Beispiel_2:
tier_1 = ["Hund", 100, 399, 99, True]

print(tier_1[0])
print(tier_1[1])
print(tier_1[-1])
print(tier_1[0:4])

# output
# Hund
# 100
# True
# ['Hund', 100, 399, 99]
‎‎</syntaxhighlight>

===== Liste verändern =====
* wie Variablen sind auch Listen veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

====== Element in Liste verändern ======
* Elemente der Liste lassen sich verändern, genau wie auch der Wert von Variablen neu definiert werden kann
* dafür schreibt man den Namen der Liste, dahinter eine Indexzahl in eckigen Klammern, wobei die Indexzahl die Position des zu verändernden Elements angibt
* die Zuweisung des neuen Werts erfolgt durch ein Gleichheitszeichen und den neuen Wert, den das Element der Liste annehmen soll (s. Beispiel_3)
‎<syntaxhighlight lang="python">
# Befehl:
liste[Position]= neuer_Wert

# Beispiel_3:
tier_1 = ['Hund', 100, 399, 99, True]
print(tier_1)
tier_1[0] = "Tiger"
tier_1[1] = 500
print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Tiger', 500, 399, 99, True]
‎</syntaxhighlight>
====== Element zu einer Liste hinzufügen ======
* Listen können erweitert werden
* dazu schreibt man den Namen der Liste ein Gleichheitszeichen, erneut den Namen der Liste, ein „+“ und das Element das hinzugefügt werden soll in eckigen Klammern (s. Beispiel_4)
‎<syntaxhighlight lang="python">
# Befehl:
liste = liste + [neues_Element]

# Beispiel_4:
tier_1 = ['Hund', 100, 399, 99, True]
print(tier_1)
tier_1 = tier_1 + ["Elefant"]
print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Hund', 100, 399, 99, True, 'Elefant']
‎</syntaxhighlight>
====== Element aus Liste löschen ======
* Elemente lassen sich mit dem del-Befehl aus der Liste entfernen (s. Beispiel_5)
* nach „del“ folgt der Listenname und die Position des zu löschenden Elements in eckigen Klammern
<syntaxhighlight lang="python">
# Befehl:
del liste[Position]

# Beispiel_5:
tier_1 = ['Hund', 100, 399, 99, True]
del tier_1[1]
print(tier_1)

# Output: ['Hund', 399, 99, True]
</syntaxhighlight>

===== Addition und Multiplikation von Listen =====
* Listen können miteinander addiert oder mit Zahlen multipliziert werden
(s. Beispiel_6)
* werden zwei Listen addiert, wird der Inhalt der Listen hintereinander ausgegeben
* wird eine Liste mit einer Zahl multipliziert, wird der Inhalt der Liste entsprechend oft hintereinander ausgegeben

‎<syntaxhighlight lang="python">
# Beispiel_6:
tier_1 = ['Hund', 100, 399, 99, True]
tier_2 = ['Katze', 60, 249, 99, True]
tier_3 = ['Fisch', 3, 1, 50, False]

print(tier_1 + tier_2)
print(tier_1 * 2)
‎</syntaxhighlight>
output
‎<syntaxhighlight lang="python">
['Hund', 100, 399, 99, True, 'Katze', 60, 249, 99, True]
['Hund', 100, 399, 99, True, 'Hund', 100, 399, 99, True]
‎</syntaxhighlight>

===== Listen in Listen =====
* Elemente einer Liste können selbst eine Liste sein, so erhält man Listen in einer Liste (s. Beispiel_7, engl. nested lists)
* es entsteht eine zweidimensionale Liste mit einer übergeordneten Liste (im Beispiel: alle_tiere) und den untergeordneten Listen (tier_1, tier_2, tier_3)
* auf die Elemente der übergeordneten Liste lässt sich wie oben gezeigt zugreifen
* möchte man nur auf ein Element der untergeordneten Liste zugreifen, sind zwei Indexzahlen notwendig
* die erste Indexzahl gibt die Position des Elements in der übergeordneten Liste an
* die zweite Indexzahl gibt die Position des Elements in der untergeordneten Liste an (s. Beispiel_7)
‎<syntaxhighlight lang="python">
# Befehl
print(liste[Position][Position])

# Beispiel_7:

tier_1 = ['Hund', 100, 399, 99, True]
tier_2 = ['Katze', 60, 249, 99, True]
tier_3 = ['Fisch', 3, 1, 50, False]

alle_tiere = [tier_1, tier_2, tier_3]
print(alle_tiere)
print(alle_tiere[0])
print(alle_tiere[0][0])

# output
# [['Hund', 100, 399, 99, True], ['Katze', 60, 249, 99, True], ['Fisch', 3, 1, 50, False]]
# ['Hund', 100, 399, 99, True]
# Hund
‎</syntaxhighlight>

=== Dictionaries ===
‎<syntaxhighlight lang="python">
# Befehl
dictionary = {'key_1': Element_1, 'key_2': Element_2}

# Beispiel_1:

buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}

print(buch_1)
print(buch_1["Buch"])
print(buch_1["Autor"])
print(buch_1["Preis"])

# output
# {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
# Der Herr der Ringe
# Tolkien
# 45
‎</syntaxhighlight>
==== Funktion ====
Listen sind zwar geeignet, um größere Mengen an Daten in übersichtlicher
und gut manipulierbarer Weise abzuspeichern, haben aber einen entscheidenden Nachteil:
Um auf ein Element in einer Liste zugreifen zu können, ist es notwendig die Position
des Elements in der Liste zu kennen. Bei kürzeren Listen lässt sich vielleicht noch der Überblick behalten. Sobald Listen aber eine gewisse Zahl an Elementen überschreiten,
in einem Programm mehrere Listen verwendet werden oder sogar Listen in Listen gespeichert sind,
ist jeglicher Versuch sich die Positionen der Elemente zu merken vergebens.
Hier bringen die sogenannten Dictionaries den entscheidenden Vorteil.
Dictionaries funktionieren wie Listen, wenn es darum geht, Informationen abzuspeichern.
Doch der Zugriff auf die Elemente erfolgt nicht durch eine Indexnummer, sondern über ein sogenannten key oder Schlüsselbegriff.
Um auf die Elemente über einen key zugreifen zu können, wird den Elementen im Dictionary jeweils ein Schlüsselbegriff zugeordnet.

==== Syntax ====
* nach dem Namen des Dictionary und dem Gleichheitszeichen folgt eine geschweifte Klammer {}
* danach folgt der Key, dabei kann es sich um ein integer, float, bool oder string handeln
* darauf folgt das Listenelement, getrennt durch einen Doppelpunkt vom Key und durch ein Komma vom nächsten Key-Element Paar

===== Dictionary ausgeben lassen =====
* das ganze Dictionary lässt sich durch einen print-Befehl ausgeben (s. Beispiel_1)

====== einzelne Elemente des Dictionaries ausgeben ======
* der Zugriff erfolgt durch den key
* die Syntax ist analog zum Abruf der Elemente einer Liste, nur das statt der Indexzahl der key in die eckige Klammer geschrieben wird (s.Beispiel_1)

===== Dictionary verändern =====
* wie Listen sind auch Dictionaries veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

====== Element in Dictionary verändern ======
* die Syntax ist analog zur Veränderung eines Elements in Listen, nur hier wird der key, statt der Position in die eckigen Klammern hinter dem Namen des Dictionaries gesetzt (s. Beispiel_2)
‎<syntaxhighlight lang="python">
# Befehl:
dictionary[(bestehender)key] = "neuer Wert"
# Beispiel_2:
buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
buch_1["Preis"] = 23
print(buch_1)

# output
# {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 23}
‎</syntaxhighlight>
====== Element zum Dictionary hinzufügen ======
* um Elemente zum Dictionary hinzuzufügen, ist es notwendig auch gleichzeitig einen key für das Element zu definieren
* nach dem Listennamen und dem Key in eckigen Klammern folgt ein Gleichheitszeichen und der Wert des neuen Elements (s. Beispiel_3)
‎<syntaxhighlight lang="python">
# Befehl:
dictionary["(neuer) key"] = "neues Element"

# Beispiel_3:
buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}

buch_1["Erscheinungsjahr"] = 1954
buch_1["Bewertung"] = "sehr gut"
print(buch_1)

# output
# {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45, 'Erscheinungsjahr': 1954, 'Bewertung': 'sehr gut'}
‎</syntaxhighlight>
====== Element aus Dictionary löschen ======
* analoger Aufbau zum del-Befehl bei Listen
* hier wird wieder anstatt der Indexzahl der key in die eckigen Klammern gesetzt (s. Besipiel_4)
‎<syntaxhighlight lang="python">
# Befehl:
del dictionary[key]

# Beispiel_4:
buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}

del buch_1["Preis"]
print(buch_1)

# output
# {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien'}
‎</syntaxhighlight>

=== Tupel ===
‎<syntaxhighlight lang="python">
# Befehl:
tupel = (element_1, element_2)

# Beispiel_1:
tier_1 = ("Hund", 100, 399, 99, True)
print(tier_1)
print(tier_1[0])

# output
# ('Hund', 100, 399, 99, True)
# Hund
‎</syntaxhighlight>
==== Funktion ====
* Tupel sind eine unveränderliche Datenstruktur d.h. die Elemente eines Tupels sind im Gegensatz zu Listen und Dictionaries nicht veränderbar oder löschbar
* sie können jedoch ergänzt werden
* Tupel werden genutzt, um Daten zu speichern, die nicht geändert werden sollen (z. B. Konstanten)
* man könnte diese natürlich auch in Dictionaries und Listen speichern, so geht man aber sicher, dass die Daten nicht ausversehen geändert werden

==== Syntax ====
* die Erstellung von Tupeln ist analog zur Erstellung von Listen, nur werden hier runde Klammern benötigt (s. Beispiel_1)
* der Zugriff auf die Elemente des Tupels ist analog zur Syntax bei Listen (s. Beispiel_1)

=====Tupel ausgeben lassen =====
* sowohl das Ausgeben des ganzen Tupels, als auch der einzelnen Elemente, folgt der selben Syntax der Listen

===== Erweiterung eines Tupels =====
* auch hier ist die Syntax analog zur Erweiterung von Listen
* das neue Element muss selbst ein Tupel sein, um es zum Tupel hinzufügen zu können
* dazu muss das neue Element erst als Tupel abgespeichert werden
* um ein neues Element als Tupel zu speichern, wird ein Tupel mit nur einem Element erstellt
* nun kann dieser Tupel dem alten hinzugefügt werden (s. Beispiel_2)
‎<syntaxhighlight lang="python">
# Beispiel_2:
tier_1 = ("Hund", 100, 399, 99, True)
farbe = ("braun",)
tier_1 = tier_1 + farbe
print(tier_1)

# output
# ('Hund', 100, 399, 99, True, 'braun')
‎</syntaxhighlight>

== Literatur ==
Michael Bonacina: Python 3 Programmieren für Einsteiger. 2. Auflage. BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2

2.Datentypen und Datenstrukturen

2023-05-28T11:57:48Z

Ani: /* Dictionaries */

__TOC__

== Datentypen ==

In Python unterscheidet man vier verschiedene Datentypen (Klassen):
{| class="wikitable"
|-
! Datentyp !! Abkürzung !! Bedeutung !! Beispiel
|-
| String || str || Zeichenkette || "abc"
|-
| Integer || int || Ganze Zahl || 1
|-
| Float || float || Dezimalzahl || 1.0
|-
| Boolean || bool || Wahrheitsgehalt || True, False
|}

Der Datentyp kann durch den ''type''-Befehl abgefragt werden.
 Beispiel:
‎<syntaxhighlight lang="python">
sequence = "ACGT"
result = type(sequence)
print(result)
# Output: <class 'str'>
‎</syntaxhighlight>

== Datenstrukturen ==

Man unterscheidet zwischen drei verscheiden Datenstrukturen:
Listen, Dictionary und Tupel. Alle diese Datenstrukturen stellen Organisationsformen
von Daten in Python dar. Das heißt sie erleichtern vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheiden sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

‎<syntaxhighlight lang="python">
#Befehl:
liste = ['string', variable, 1, 2.0, True]

# Beispiel_1:

hund = ['Hund', 100, 399, 99, True]
katze = ['Katze', 60, 249, 99, True]
fisch = ['Fisch', 3, 1, 50, False]

print(hund)
print(katze)
print(fisch)

# output
# ['Hund', 100, 399, 99, True]
# ['Katze', 60, 249, 99, True]
# ['Fisch', 3, 1, 50, False]
‎</syntaxhighlight>
==== Funktion ====
* haben dieselbe Funktion wie Listen im echten Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht das Programm übersichtlicher und erleichtert die Arbeit, weil nicht jeder einzelne Wert mit einem eigenen Variablennamen gespeichert werden muss

==== Syntax ====
* die Liste erhält einen Namen, welcher wie eine Variable durch ein Gleichheitszeichen den Elementen der Liste zugeordnet wird
* die Elemente der Liste werden in eckige Klammern gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können verschiedene Datentypen auf einmal vorkommen

===== Liste ausgeben lassen =====
* die ganze Liste lässt sich durch einen print-Befehl ausgeben (s. Beispiel_1)

====== einzelne Elemente der Liste ausgeben lassen ======
* auch einzelne Elemente der Liste können ausgegeben werden (s. Beispiel_2)
* dabei wird die Position des auszugebenden Elements durch eine Indexzahl in eckigen Klammern nach dem Listennamen angegeben
* Achtung: grundsätzlich zählt man von 0 ausgehend, d.h. das erste Element in der Liste besitzt die Position 0, das zweite die Position 1 etc.
* es kann auch von hinten gezählt werden, dabei besitzt das erste Element (welches von vorne gezählt das letzte wäre) die Position -1 usw.

====== Bereich der Liste ausgeben lassen ======
* es lässt sich auch ein bestimmter Bereich der Liste ausgeben, wobei die Positionen der Elemente durch einen Doppelpunkt getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein, welche ausgegeben wird (engl. inclusive)
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird (engl. exclusive)
* um die Syntax des Befehls zu verstehen, ist es sinnvoll, die verschiedenen Möglichkeiten einmal selbst auszuprobieren und die Aufgaben 4 und 5 auf dem Aufgabenblatt zu bearbeiten
‎<syntaxhighlight lang="python">
# Befehl:
print(liste[Position])

# Beispiel_2:
tier_1 = ["Hund", 100, 399, 99, True]

print(tier_1[0])
print(tier_1[1])
print(tier_1[-1])
print(tier_1[0:4])

# output
# Hund
# 100
# True
# ['Hund', 100, 399, 99]
‎‎</syntaxhighlight>

===== Liste verändern =====
* wie Variablen sind auch Listen veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

====== Element in Liste verändern ======
* Elemente der Liste lassen sich verändern, genau wie auch der Wert von Variablen neu definiert werden kann
* dafür schreibt man den Namen der Liste, dahinter eine Indexzahl in eckigen Klammern, wobei die Indexzahl die Position des zu verändernden Elements angibt
* die Zuweisung des neuen Werts erfolgt durch ein Gleichheitszeichen und den neuen Wert, den das Element der Liste annehmen soll (s. Beispiel_3)
‎<syntaxhighlight lang="python">
# Befehl:
liste[Position]= neuer_Wert

# Beispiel_3:
tier_1 = ['Hund', 100, 399, 99, True]
print(tier_1)
tier_1[0] = "Tiger"
tier_1[1] = 500
print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Tiger', 500, 399, 99, True]
‎</syntaxhighlight>
====== Element zu einer Liste hinzufügen ======
* Listen können erweitert werden
* dazu schreibt man den Namen der Liste ein Gleichheitszeichen, erneut den Namen der Liste, ein „+“ und das Element das hinzugefügt werden soll in eckigen Klammern (s. Beispiel_4)
‎<syntaxhighlight lang="python">
# Befehl:
liste = liste + [neues_Element]

# Beispiel_4:
tier_1 = ['Hund', 100, 399, 99, True]
print(tier_1)
tier_1 = tier_1 + ["Elefant"]
print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Hund', 100, 399, 99, True, 'Elefant']
‎</syntaxhighlight>
====== Element aus Liste löschen ======
* Elemente lassen sich mit dem del-Befehl aus der Liste entfernen (s. Beispiel_5)
* nach „del“ folgt der Listenname und die Position des zu löschenden Elements in eckigen Klammern
<syntaxhighlight lang="python">
# Befehl:
del liste[Position]

# Beispiel_5:
tier_1 = ['Hund', 100, 399, 99, True]
del tier_1[1]
print(tier_1)

# Output: ['Hund', 399, 99, True]
</syntaxhighlight>

===== Addition und Multiplikation von Listen =====
* Listen können miteinander addiert oder mit Zahlen multipliziert werden
(s. Beispiel_6)
* werden zwei Listen addiert, wird der Inhalt der Listen hintereinander ausgegeben
* wird eine Liste mit einer Zahl multipliziert, wird der Inhalt der Liste entsprechend oft hintereinander ausgegeben

‎<syntaxhighlight lang="python">
# Beispiel_6:
tier_1 = ['Hund', 100, 399, 99, True]
tier_2 = ['Katze', 60, 249, 99, True]
tier_3 = ['Fisch', 3, 1, 50, False]

print(tier_1 + tier_2)
print(tier_1 * 2)
‎</syntaxhighlight>
output
‎<syntaxhighlight lang="python">
['Hund', 100, 399, 99, True, 'Katze', 60, 249, 99, True]
['Hund', 100, 399, 99, True, 'Hund', 100, 399, 99, True]
‎</syntaxhighlight>

===== Listen in Listen =====
* Elemente einer Liste können selbst eine Liste sein, so erhält man Listen in einer Liste (s. Beispiel_7, engl. nested lists)
* es entsteht eine zweidimensionale Liste mit einer übergeordneten Liste (im Beispiel: alle_tiere) und den untergeordneten Listen (tier_1, tier_2, tier_3)
* auf die Elemente der übergeordneten Liste lässt sich wie oben gezeigt zugreifen
* möchte man nur auf ein Element der untergeordneten Liste zugreifen, sind zwei Indexzahlen notwendig
* die erste Indexzahl gibt die Position des Elements in der übergeordneten Liste an
* die zweite Indexzahl gibt die Position des Elements in der untergeordneten Liste an (s. Beispiel_7)
‎<syntaxhighlight lang="python">
# Befehl
print(liste[Position][Position])

# Beispiel_7:

tier_1 = ['Hund', 100, 399, 99, True]
tier_2 = ['Katze', 60, 249, 99, True]
tier_3 = ['Fisch', 3, 1, 50, False]

alle_tiere = [tier_1, tier_2, tier_3]
print(alle_tiere)
print(alle_tiere[0])
print(alle_tiere[0][0])

# output
# [['Hund', 100, 399, 99, True], ['Katze', 60, 249, 99, True], ['Fisch', 3, 1, 50, False]]
# ['Hund', 100, 399, 99, True]
# Hund
‎</syntaxhighlight>

=== Dictionaries ===
‎<syntaxhighlight lang="python">
# Befehl
dictionary = {'key_1': Element_1, 'key_2': Element_2}

# Beispiel_1:

buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}

print(buch_1)
print(buch_1["Buch"])
print(buch_1["Autor"])
print(buch_1["Preis"])

# output
# {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
# Der Herr der Ringe
# Tolkien
# 45
‎</syntaxhighlight>
==== Funktion ====
Listen sind zwar geeignet, um größere Mengen an Daten in übersichtlicher
und gut manipulierbarer Weise abzuspeichern, haben aber einen entscheidenden Nachteil:
Um auf ein Element in einer Liste zugreifen zu können, ist es notwendig die Position
des Elements in der Liste zu kennen. Bei kürzeren Listen lässt sich vielleicht noch der Überblick behalten. Sobald Listen aber eine gewisse Zahl an Elementen überschreiten,
in einem Programm mehrere Listen verwendet werden oder sogar Listen in Listen gespeichert sind,
ist jeglicher Versuch sich die Positionen der Elemente zu merken vergebens.
Hier bringen die sogenannten Dictionaries den entscheidenden Vorteil.
Dictionaries funktionieren wie Listen, wenn es darum geht, Informationen abzuspeichern.
Doch der Zugriff auf die Elemente erfolgt nicht durch eine Indexnummer, sondern über ein sogenannten key oder Schlüsselbegriff.
Um auf die Elemente über einen key zugreifen zu können, wird den Elementen im Dictionary jeweils ein Schlüsselbegriff zugeordnet.

==== Syntax ====
* nach dem Namen des Dictionary und dem Gleichheitszeichen folgt eine geschweifte Klammer {}
* danach folgt der Key, dabei kann es sich um ein integer, float, bool oder string handeln
* darauf folgt das Listenelement, getrennt durch einen Doppelpunkt vom Key und durch ein Komma vom nächsten Key-Element Paar

===== Dictionary ausgeben lassen =====
* das ganze Dictionary lässt sich durch einen print-Befehl ausgeben (s. Beispiel_1)

====== einzelne Elemente des Dictionaries ausgeben ======
* der Zugriff erfolgt durch den key
* die Syntax ist analog zum Abruf der Elemente einer Liste, nur das statt der Indexzahl der key in die eckige Klammer geschrieben wird (s.Beispiel_1)

===== Dictionary verändern =====
* wie Listen sind auch Dictionaries veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

====== Element in Dictionary verändern ======
* die Syntax ist analog zur Veränderung eines Elements in Listen, nur hier wird der key, statt der Position in die eckigen Klammern hinter dem Namen des Dictionaries gesetzt (s. Beispiel_2)
‎<syntaxhighlight lang="python">
# Befehl:
dictionary[(bestehender)key] = "neuer Wert"
# Beispiel_2:
buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
buch_1["Preis"] = 23
print(buch_1)

# output
# {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 23}
‎</syntaxhighlight>
====== Element zum Dictionary hinzufügen ======
* um Elemente zum Dictionary hinzuzufügen, ist es notwendig auch gleichzeitig einen key für das Element zu definieren
* nach dem Listennamen und dem Key in eckigen Klammern folgt ein Gleichheitszeichen und der Wert des neuen Elements (s. Beispiel_3)
‎<syntaxhighlight lang="python">
# Befehl:
dictionary["(neuer) key"] = "neues Element"

# Beispiel_3:
buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}

buch_1["Erscheinungsjahr"] = 1954
buch_1["Bewertung"] = "sehr gut"
print(buch_1)

# output
# {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45, 'Erscheinungsjahr': 1954, 'Bewertung': 'sehr gut'}
‎</syntaxhighlight>
====== Element aus Dictionary löschen ======
* analoger Aufbau zum del-Befehl bei Listen
* hier wird wieder anstatt der Indexzahl der key in die eckigen Klammern gesetzt (s. Besipiel_4)
‎<syntaxhighlight lang="python">
# Befehl:
del dictionary[key]

# Beispiel_4:
buch_1 = {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}

del buch_1["Preis"]
print(buch_1)

# output
# {'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien'}
‎</syntaxhighlight>

=== Tupel ===
#Befehl:
tupel= element_1, element_2 
#Beispiel_1:
tier_1="Hund",100,399,99,True 
print(tier_1)
print(tier_1[0])

output
('Hund', 100, 399, 99, True)
Hund

==== Funktion ====
* Tupelo sind unveränderliche Daten, d.h. die Elemente eines Tupels sind im Gegensatz zu Listen und Dictionaries nicht veränderbar oder löschbar
* sie können jedoch ergänzt werden
* Tupel werden genutzt, um Daten zu speichern, die nicht geändert werden sollen
* (man könnte diese natürlich auch in Dictionarie und Listen speichern, so geht man aber sicher, dass die Daten nicht ausersehen geändert werden; außerdem ist die Speicherperformance besser)

==== Syntax ====
* die Erstellung von Tupeln ist analog zur Erstellung von Listen, nur hier werden keine Klammern benötigt (s.Beispiel_1)
* der Zugriff auf die Elemente des Tupels ist analog zur Syntax bei Listen (s.Beispiel_1)

=====Tupel ausgeben lassen =====
* sowohl das ausgeben des ganzen Tupels, als auch der einzelnen Elemente folgt der selben Syntax der Listen

===== Erweiterung eines Tupels =====
* auch hier ist die Syntax analog zur Erweiterung von Listen
* das neue Element muss selbst ein Tupel sein, um es zum Tupel hinzufügen zu können
* dazu muss das neue Element erst als Tupel abgespeichert werden
* um ein neues Element als Tupel zu speichern, wird ein Tupel mit nur einem Element erstellt
* nun kann dieser Tupel dem alten hinzugefügt werden (s.Beispiel_2)

#Beispiel_2:
tier_1="Hund",100,399,99,True
farbe= "braun",
tier_1=tier_1 + farbe
print(tier_1)

output
('Hund', 100, 399, 99, True, 'braun')

== Literatur ==
Michael Bonacina: Python 3 Programmieren für Einsteiger. 2. Auflage. BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2

2.Datentypen und Datenstrukturen

2023-05-28T11:47:14Z

Ani: /* Listen in Listen */

__TOC__

== Datentypen ==

In Python unterscheidet man vier verschiedene Datentypen (Klassen):
{| class="wikitable"
|-
! Datentyp !! Abkürzung !! Bedeutung !! Beispiel
|-
| String || str || Zeichenkette || "abc"
|-
| Integer || int || Ganze Zahl || 1
|-
| Float || float || Dezimalzahl || 1.0
|-
| Boolean || bool || Wahrheitsgehalt || True, False
|}

Der Datentyp kann durch den ''type''-Befehl abgefragt werden.
 Beispiel:
‎<syntaxhighlight lang="python">
sequence = "ACGT"
result = type(sequence)
print(result)
# Output: <class 'str'>
‎</syntaxhighlight>

== Datenstrukturen ==

Man unterscheidet zwischen drei verscheiden Datenstrukturen:
Listen, Dictionary und Tupel. Alle diese Datenstrukturen stellen Organisationsformen
von Daten in Python dar. Das heißt sie erleichtern vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheiden sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

‎<syntaxhighlight lang="python">
#Befehl:
liste = ['string', variable, 1, 2.0, True]

# Beispiel_1:

hund = ['Hund', 100, 399, 99, True]
katze = ['Katze', 60, 249, 99, True]
fisch = ['Fisch', 3, 1, 50, False]

print(hund)
print(katze)
print(fisch)

# output
# ['Hund', 100, 399, 99, True]
# ['Katze', 60, 249, 99, True]
# ['Fisch', 3, 1, 50, False]
‎</syntaxhighlight>
==== Funktion ====
* haben dieselbe Funktion wie Listen im echten Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht das Programm übersichtlicher und erleichtert die Arbeit, weil nicht jeder einzelne Wert mit einem eigenen Variablennamen gespeichert werden muss

==== Syntax ====
* die Liste erhält einen Namen, welcher wie eine Variable durch ein Gleichheitszeichen den Elementen der Liste zugeordnet wird
* die Elemente der Liste werden in eckige Klammern gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können verschiedene Datentypen auf einmal vorkommen

===== Liste ausgeben lassen =====
* die ganze Liste lässt sich durch einen print-Befehl ausgeben (s. Beispiel_1)

====== einzelne Elemente der Liste ausgeben lassen ======
* auch einzelne Elemente der Liste können ausgegeben werden (s. Beispiel_2)
* dabei wird die Position des auszugebenden Elements durch eine Indexzahl in eckigen Klammern nach dem Listennamen angegeben
* Achtung: grundsätzlich zählt man von 0 ausgehend, d.h. das erste Element in der Liste besitzt die Position 0, das zweite die Position 1 etc.
* es kann auch von hinten gezählt werden, dabei besitzt das erste Element (welches von vorne gezählt das letzte wäre) die Position -1 usw.

====== Bereich der Liste ausgeben lassen ======
* es lässt sich auch ein bestimmter Bereich der Liste ausgeben, wobei die Positionen der Elemente durch einen Doppelpunkt getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein, welche ausgegeben wird (engl. inclusive)
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird (engl. exclusive)
* um die Syntax des Befehls zu verstehen, ist es sinnvoll, die verschiedenen Möglichkeiten einmal selbst auszuprobieren und die Aufgaben 4 und 5 auf dem Aufgabenblatt zu bearbeiten
‎<syntaxhighlight lang="python">
# Befehl:
print(liste[Position])

# Beispiel_2:
tier_1 = ["Hund", 100, 399, 99, True]

print(tier_1[0])
print(tier_1[1])
print(tier_1[-1])
print(tier_1[0:4])

# output
# Hund
# 100
# True
# ['Hund', 100, 399, 99]
‎‎</syntaxhighlight>

===== Liste verändern =====
* wie Variablen sind auch Listen veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

====== Element in Liste verändern ======
* Elemente der Liste lassen sich verändern, genau wie auch der Wert von Variablen neu definiert werden kann
* dafür schreibt man den Namen der Liste, dahinter eine Indexzahl in eckigen Klammern, wobei die Indexzahl die Position des zu verändernden Elements angibt
* die Zuweisung des neuen Werts erfolgt durch ein Gleichheitszeichen und den neuen Wert, den das Element der Liste annehmen soll (s. Beispiel_3)
‎<syntaxhighlight lang="python">
# Befehl:
liste[Position]= neuer_Wert

# Beispiel_3:
tier_1 = ['Hund', 100, 399, 99, True]
print(tier_1)
tier_1[0] = "Tiger"
tier_1[1] = 500
print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Tiger', 500, 399, 99, True]
‎</syntaxhighlight>
====== Element zu einer Liste hinzufügen ======
* Listen können erweitert werden
* dazu schreibt man den Namen der Liste ein Gleichheitszeichen, erneut den Namen der Liste, ein „+“ und das Element das hinzugefügt werden soll in eckigen Klammern (s. Beispiel_4)
‎<syntaxhighlight lang="python">
# Befehl:
liste = liste + [neues_Element]

# Beispiel_4:
tier_1 = ['Hund', 100, 399, 99, True]
print(tier_1)
tier_1 = tier_1 + ["Elefant"]
print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Hund', 100, 399, 99, True, 'Elefant']
‎</syntaxhighlight>
====== Element aus Liste löschen ======
* Elemente lassen sich mit dem del-Befehl aus der Liste entfernen (s. Beispiel_5)
* nach „del“ folgt der Listenname und die Position des zu löschenden Elements in eckigen Klammern
<syntaxhighlight lang="python">
# Befehl:
del liste[Position]

# Beispiel_5:
tier_1 = ['Hund', 100, 399, 99, True]
del tier_1[1]
print(tier_1)

# Output: ['Hund', 399, 99, True]
</syntaxhighlight>

===== Addition und Multiplikation von Listen =====
* Listen können miteinander addiert oder mit Zahlen multipliziert werden
(s. Beispiel_6)
* werden zwei Listen addiert, wird der Inhalt der Listen hintereinander ausgegeben
* wird eine Liste mit einer Zahl multipliziert, wird der Inhalt der Liste entsprechend oft hintereinander ausgegeben

‎<syntaxhighlight lang="python">
# Beispiel_6:
tier_1 = ['Hund', 100, 399, 99, True]
tier_2 = ['Katze', 60, 249, 99, True]
tier_3 = ['Fisch', 3, 1, 50, False]

print(tier_1 + tier_2)
print(tier_1 * 2)
‎</syntaxhighlight>
output
‎<syntaxhighlight lang="python">
['Hund', 100, 399, 99, True, 'Katze', 60, 249, 99, True]
['Hund', 100, 399, 99, True, 'Hund', 100, 399, 99, True]
‎</syntaxhighlight>

===== Listen in Listen =====
* Elemente einer Liste können selbst eine Liste sein, so erhält man Listen in einer Liste (s. Beispiel_7, engl. nested lists)
* es entsteht eine zweidimensionale Liste mit einer übergeordneten Liste (im Beispiel: alle_tiere) und den untergeordneten Listen (tier_1, tier_2, tier_3)
* auf die Elemente der übergeordneten Liste lässt sich wie oben gezeigt zugreifen
* möchte man nur auf ein Element der untergeordneten Liste zugreifen, sind zwei Indexzahlen notwendig
* die erste Indexzahl gibt die Position des Elements in der übergeordneten Liste an
* die zweite Indexzahl gibt die Position des Elements in der untergeordneten Liste an (s. Beispiel_7)
‎<syntaxhighlight lang="python">
# Befehl
print(liste[Position][Position])

# Beispiel_7:

tier_1 = ['Hund', 100, 399, 99, True]
tier_2 = ['Katze', 60, 249, 99, True]
tier_3 = ['Fisch', 3, 1, 50, False]

alle_tiere = [tier_1, tier_2, tier_3]
print(alle_tiere)
print(alle_tiere[0])
print(alle_tiere[0][0])

# output
# [['Hund', 100, 399, 99, True], ['Katze', 60, 249, 99, True], ['Fisch', 3, 1, 50, False]]
# ['Hund', 100, 399, 99, True]
# Hund
‎</syntaxhighlight>

=== Dictionaries ===

#Befehl:
dictionary={"key_1":Element_1,"key_2":Element_2}

#Beispiel_1:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

print(buch_1)
print(buch_1["Buch"])
print(buch_1["Autor"])
print(buch_1["Preis"])

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
Der Herr der Ringe
Tolkien
45

==== Funktion ====
Listen sind zwar geeignet, um größere Mengen an Daten in übersichtlicher
und gut manipulierbarer Weise abzuspeichern, haben aber einen entscheidenden Nachteil.
Um auf ein Element in einer Liste zugreifen zu können, ist es notwendig die Position
des Elements in der Liste zu kennen. Bei kürzeren Listen lässt sich vielleicht noch der Überblick behalten. Sobald Listen aber eine gewissen Anzahl an Elementen überschreiten,
in einem Programm mehrere Listen verwendet werden oder sogar Listen in Listen gespeichert sind,
ist jeglicher Versuch sich die Positionen der Elemente zu merken vergebens.
Hier bringen die sogenannten Dictionaries den entscheidenden Vorteil.
Dictionaries funktionieren wie Listen, wenn es darum geht Informationen abzuspeichern.
Doch der Zugriff auf die Elemente folgt nicht durch eine Indexnummer sondern über ein sogenannten key oder Schlüsselbegriff.
Um auf die Elemente über einen key zugreifen zu können, werden den Elementen im Dictionary ein Schlüsselbegriff zugeordnet.

==== Syntax ====
* nach dem Namen des Dictionary und dem Gleichheitszeichen folgt eine geschweifte Klammer {}
* danach folgt der Key, dabei kann es sich um ein integer, float, bool oder string handeln
* darauf folgt das Listenelement, getrennt durch einen Doppelpunkt vom Key und durch ein Komma vom nächsten Key-Element Paar

===== Dictionary ausgeben lassen =====
* das ganze Dictionary lässt sich durch einen print-Befehl ausgeben (s. Beispie_1)

====== einzelne Elemente des Dictionaries ausgeben ======
* der Zugriff erfolgt durch den key
* die Syntax ist analog zum Abruf der Elemente einer Liste, nur das statt der Indexzahl der key in die eckige Klammer geschrieben wird (s.Beispeil_1)

===== Dictionary verändern =====
* wie Listen sind auch Dictionaries veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

====== Element in Dictionary verändern ======
* die Syntax ist analog zur Veränderung eines Elements in Listen, nur hier wird der key, statt der Position in die eckigen Klammern hinter dem Namen des Dictionaries gesetzt (s.Beispiel_2)

#Befehl:
dictionary[(bestehender)key]= neuer Wert 
#Beispiel_2:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}
buch_1["Preis"]= 23
print(buch_1)

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 23}

====== Element zum Dictionary hinzufügen ======
* um Elemente zum Dictionary hinzuzufügen ist es notwendig auch gleichzeitig ein key für das Element zu definieren
* nach dem Listennamen und dem Key in eckigen Klammern folg ein Gleichheitszeichen und der Wert des neuen Elements (s.Beispiel_3)

#Befehl:
dictionary[(neuer) key]= neues Element

#Beispiel_3:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

buch_1["Erscheinungsjahr"]= 1954
buch_1["Bewertung"]="sehr gut"
print(buch_1)

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45, 'Erscheinungsjahr': 1954, 'Bewertung': 'sehr gut'}

====== Element aus Dictionary löschen ======
* analoger Aufbau zum del-Befehl bei Listen
* hier wird wieder anstatt der Indexzahl der key in die eckigen Klammern gesetzt (s.Besipiel_4)

#Befehl:
del dictionary[key]

#Beispiel_4:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

del buch_1["Preis"]
print(buch_1)

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien'}

=== Tupel ===
#Befehl:
tupel= element_1, element_2 
#Beispiel_1:
tier_1="Hund",100,399,99,True 
print(tier_1)
print(tier_1[0])

output
('Hund', 100, 399, 99, True)
Hund

==== Funktion ====
* Tupelo sind unveränderliche Daten, d.h. die Elemente eines Tupels sind im Gegensatz zu Listen und Dictionaries nicht veränderbar oder löschbar
* sie können jedoch ergänzt werden
* Tupel werden genutzt, um Daten zu speichern, die nicht geändert werden sollen
* (man könnte diese natürlich auch in Dictionarie und Listen speichern, so geht man aber sicher, dass die Daten nicht ausersehen geändert werden; außerdem ist die Speicherperformance besser)

==== Syntax ====
* die Erstellung von Tupeln ist analog zur Erstellung von Listen, nur hier werden keine Klammern benötigt (s.Beispiel_1)
* der Zugriff auf die Elemente des Tupels ist analog zur Syntax bei Listen (s.Beispiel_1)

=====Tupel ausgeben lassen =====
* sowohl das ausgeben des ganzen Tupels, als auch der einzelnen Elemente folgt der selben Syntax der Listen

===== Erweiterung eines Tupels =====
* auch hier ist die Syntax analog zur Erweiterung von Listen
* das neue Element muss selbst ein Tupel sein, um es zum Tupel hinzufügen zu können
* dazu muss das neue Element erst als Tupel abgespeichert werden
* um ein neues Element als Tupel zu speichern, wird ein Tupel mit nur einem Element erstellt
* nun kann dieser Tupel dem alten hinzugefügt werden (s.Beispiel_2)

#Beispiel_2:
tier_1="Hund",100,399,99,True
farbe= "braun",
tier_1=tier_1 + farbe
print(tier_1)

output
('Hund', 100, 399, 99, True, 'braun')

== Literatur ==
Michael Bonacina: Python 3 Programmieren für Einsteiger. 2. Auflage. BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2

2.Datentypen und Datenstrukturen

2023-05-28T11:40:07Z

Ani: /* Addition und Multiplikation von Listen */

__TOC__

== Datentypen ==

In Python unterscheidet man vier verschiedene Datentypen (Klassen):
{| class="wikitable"
|-
! Datentyp !! Abkürzung !! Bedeutung !! Beispiel
|-
| String || str || Zeichenkette || "abc"
|-
| Integer || int || Ganze Zahl || 1
|-
| Float || float || Dezimalzahl || 1.0
|-
| Boolean || bool || Wahrheitsgehalt || True, False
|}

Der Datentyp kann durch den ''type''-Befehl abgefragt werden.
 Beispiel:
‎<syntaxhighlight lang="python">
sequence = "ACGT"
result = type(sequence)
print(result)
# Output: <class 'str'>
‎</syntaxhighlight>

== Datenstrukturen ==

Man unterscheidet zwischen drei verscheiden Datenstrukturen:
Listen, Dictionary und Tupel. Alle diese Datenstrukturen stellen Organisationsformen
von Daten in Python dar. Das heißt sie erleichtern vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheiden sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

‎<syntaxhighlight lang="python">
#Befehl:
liste = ['string', variable, 1, 2.0, True]

# Beispiel_1:

hund = ['Hund', 100, 399, 99, True]
katze = ['Katze', 60, 249, 99, True]
fisch = ['Fisch', 3, 1, 50, False]

print(hund)
print(katze)
print(fisch)

# output
# ['Hund', 100, 399, 99, True]
# ['Katze', 60, 249, 99, True]
# ['Fisch', 3, 1, 50, False]
‎</syntaxhighlight>
==== Funktion ====
* haben dieselbe Funktion wie Listen im echten Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht das Programm übersichtlicher und erleichtert die Arbeit, weil nicht jeder einzelne Wert mit einem eigenen Variablennamen gespeichert werden muss

==== Syntax ====
* die Liste erhält einen Namen, welcher wie eine Variable durch ein Gleichheitszeichen den Elementen der Liste zugeordnet wird
* die Elemente der Liste werden in eckige Klammern gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können verschiedene Datentypen auf einmal vorkommen

===== Liste ausgeben lassen =====
* die ganze Liste lässt sich durch einen print-Befehl ausgeben (s. Beispiel_1)

====== einzelne Elemente der Liste ausgeben lassen ======
* auch einzelne Elemente der Liste können ausgegeben werden (s. Beispiel_2)
* dabei wird die Position des auszugebenden Elements durch eine Indexzahl in eckigen Klammern nach dem Listennamen angegeben
* Achtung: grundsätzlich zählt man von 0 ausgehend, d.h. das erste Element in der Liste besitzt die Position 0, das zweite die Position 1 etc.
* es kann auch von hinten gezählt werden, dabei besitzt das erste Element (welches von vorne gezählt das letzte wäre) die Position -1 usw.

====== Bereich der Liste ausgeben lassen ======
* es lässt sich auch ein bestimmter Bereich der Liste ausgeben, wobei die Positionen der Elemente durch einen Doppelpunkt getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein, welche ausgegeben wird (engl. inclusive)
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird (engl. exclusive)
* um die Syntax des Befehls zu verstehen, ist es sinnvoll, die verschiedenen Möglichkeiten einmal selbst auszuprobieren und die Aufgaben 4 und 5 auf dem Aufgabenblatt zu bearbeiten
‎<syntaxhighlight lang="python">
# Befehl:
print(liste[Position])

# Beispiel_2:
tier_1 = ["Hund", 100, 399, 99, True]

print(tier_1[0])
print(tier_1[1])
print(tier_1[-1])
print(tier_1[0:4])

# output
# Hund
# 100
# True
# ['Hund', 100, 399, 99]
‎‎</syntaxhighlight>

===== Liste verändern =====
* wie Variablen sind auch Listen veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

====== Element in Liste verändern ======
* Elemente der Liste lassen sich verändern, genau wie auch der Wert von Variablen neu definiert werden kann
* dafür schreibt man den Namen der Liste, dahinter eine Indexzahl in eckigen Klammern, wobei die Indexzahl die Position des zu verändernden Elements angibt
* die Zuweisung des neuen Werts erfolgt durch ein Gleichheitszeichen und den neuen Wert, den das Element der Liste annehmen soll (s. Beispiel_3)
‎<syntaxhighlight lang="python">
# Befehl:
liste[Position]= neuer_Wert

# Beispiel_3:
tier_1 = ['Hund', 100, 399, 99, True]
print(tier_1)
tier_1[0] = "Tiger"
tier_1[1] = 500
print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Tiger', 500, 399, 99, True]
‎</syntaxhighlight>
====== Element zu einer Liste hinzufügen ======
* Listen können erweitert werden
* dazu schreibt man den Namen der Liste ein Gleichheitszeichen, erneut den Namen der Liste, ein „+“ und das Element das hinzugefügt werden soll in eckigen Klammern (s. Beispiel_4)
‎<syntaxhighlight lang="python">
# Befehl:
liste = liste + [neues_Element]

# Beispiel_4:
tier_1 = ['Hund', 100, 399, 99, True]
print(tier_1)
tier_1 = tier_1 + ["Elefant"]
print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Hund', 100, 399, 99, True, 'Elefant']
‎</syntaxhighlight>
====== Element aus Liste löschen ======
* Elemente lassen sich mit dem del-Befehl aus der Liste entfernen (s. Beispiel_5)
* nach „del“ folgt der Listenname und die Position des zu löschenden Elements in eckigen Klammern
<syntaxhighlight lang="python">
# Befehl:
del liste[Position]

# Beispiel_5:
tier_1 = ['Hund', 100, 399, 99, True]
del tier_1[1]
print(tier_1)

# Output: ['Hund', 399, 99, True]
</syntaxhighlight>

===== Addition und Multiplikation von Listen =====
* Listen können miteinander addiert oder mit Zahlen multipliziert werden
(s. Beispiel_6)
* werden zwei Listen addiert, wird der Inhalt der Listen hintereinander ausgegeben
* wird eine Liste mit einer Zahl multipliziert, wird der Inhalt der Liste entsprechend oft hintereinander ausgegeben

‎<syntaxhighlight lang="python">
# Beispiel_6:
tier_1 = ['Hund', 100, 399, 99, True]
tier_2 = ['Katze', 60, 249, 99, True]
tier_3 = ['Fisch', 3, 1, 50, False]

print(tier_1 + tier_2)
print(tier_1 * 2)
‎</syntaxhighlight>
output
‎<syntaxhighlight lang="python">
['Hund', 100, 399, 99, True, 'Katze', 60, 249, 99, True]
['Hund', 100, 399, 99, True, 'Hund', 100, 399, 99, True]
‎</syntaxhighlight>

===== Listen in Listen =====
* Elemente einer Liste können selbst eine Liste sein, so erhält man Listen in einer Liste (s.Beispiel_7)
* es entsteht eine zweidimensionale Liste mit einer übergeordneten Liste (im Beispiel: alle_tiere) und den untergeordneten Listen ( tier_1, tier_2, tier_3)
* auf die Elemente der übergeordneten Liste lässt sich wie oben gezeigt zugreifen
* möchte man nur auf ein Element der untergeordneten Liste zugreifen, sind zwei Indexzahlen notwendig
* die erste Indexzahl gibt die Position des Elements in der übergeordneten Liste an
* die zweite Indexzahl gibt die Position des Elements in der untergeordneten Liste an (s.Beispiel_7)

#Befehl:
print(liste[Position][Position])

#Beispiel_7:
tier_1=["Hund",100,399,99,True]
tier_2=["Katze",60,249,99,True]
tier_3=["Fisch",3,1 ,50,False]

alle_tiere=[tier_1, tier_2, tier_3]
print(alle_tiere)
print(alle_tiere[0])
print(alle_tiere[0][0])

output
[["Hund",100,399,99,True],["Katze",60,249,99,True],["Fisch",3,1 ,50,False]]
['Hund', 100, 399, 99, True]
Hund

=== Dictionaries ===

#Befehl:
dictionary={"key_1":Element_1,"key_2":Element_2}

#Beispiel_1:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

print(buch_1)
print(buch_1["Buch"])
print(buch_1["Autor"])
print(buch_1["Preis"])

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
Der Herr der Ringe
Tolkien
45

==== Funktion ====
Listen sind zwar geeignet, um größere Mengen an Daten in übersichtlicher
und gut manipulierbarer Weise abzuspeichern, haben aber einen entscheidenden Nachteil.
Um auf ein Element in einer Liste zugreifen zu können, ist es notwendig die Position
des Elements in der Liste zu kennen. Bei kürzeren Listen lässt sich vielleicht noch der Überblick behalten. Sobald Listen aber eine gewissen Anzahl an Elementen überschreiten,
in einem Programm mehrere Listen verwendet werden oder sogar Listen in Listen gespeichert sind,
ist jeglicher Versuch sich die Positionen der Elemente zu merken vergebens.
Hier bringen die sogenannten Dictionaries den entscheidenden Vorteil.
Dictionaries funktionieren wie Listen, wenn es darum geht Informationen abzuspeichern.
Doch der Zugriff auf die Elemente folgt nicht durch eine Indexnummer sondern über ein sogenannten key oder Schlüsselbegriff.
Um auf die Elemente über einen key zugreifen zu können, werden den Elementen im Dictionary ein Schlüsselbegriff zugeordnet.

==== Syntax ====
* nach dem Namen des Dictionary und dem Gleichheitszeichen folgt eine geschweifte Klammer {}
* danach folgt der Key, dabei kann es sich um ein integer, float, bool oder string handeln
* darauf folgt das Listenelement, getrennt durch einen Doppelpunkt vom Key und durch ein Komma vom nächsten Key-Element Paar

===== Dictionary ausgeben lassen =====
* das ganze Dictionary lässt sich durch einen print-Befehl ausgeben (s. Beispie_1)

====== einzelne Elemente des Dictionaries ausgeben ======
* der Zugriff erfolgt durch den key
* die Syntax ist analog zum Abruf der Elemente einer Liste, nur das statt der Indexzahl der key in die eckige Klammer geschrieben wird (s.Beispeil_1)

===== Dictionary verändern =====
* wie Listen sind auch Dictionaries veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

====== Element in Dictionary verändern ======
* die Syntax ist analog zur Veränderung eines Elements in Listen, nur hier wird der key, statt der Position in die eckigen Klammern hinter dem Namen des Dictionaries gesetzt (s.Beispiel_2)

#Befehl:
dictionary[(bestehender)key]= neuer Wert 
#Beispiel_2:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}
buch_1["Preis"]= 23
print(buch_1)

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 23}

====== Element zum Dictionary hinzufügen ======
* um Elemente zum Dictionary hinzuzufügen ist es notwendig auch gleichzeitig ein key für das Element zu definieren
* nach dem Listennamen und dem Key in eckigen Klammern folg ein Gleichheitszeichen und der Wert des neuen Elements (s.Beispiel_3)

#Befehl:
dictionary[(neuer) key]= neues Element

#Beispiel_3:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

buch_1["Erscheinungsjahr"]= 1954
buch_1["Bewertung"]="sehr gut"
print(buch_1)

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45, 'Erscheinungsjahr': 1954, 'Bewertung': 'sehr gut'}

====== Element aus Dictionary löschen ======
* analoger Aufbau zum del-Befehl bei Listen
* hier wird wieder anstatt der Indexzahl der key in die eckigen Klammern gesetzt (s.Besipiel_4)

#Befehl:
del dictionary[key]

#Beispiel_4:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

del buch_1["Preis"]
print(buch_1)

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien'}

=== Tupel ===
#Befehl:
tupel= element_1, element_2 
#Beispiel_1:
tier_1="Hund",100,399,99,True 
print(tier_1)
print(tier_1[0])

output
('Hund', 100, 399, 99, True)
Hund

==== Funktion ====
* Tupelo sind unveränderliche Daten, d.h. die Elemente eines Tupels sind im Gegensatz zu Listen und Dictionaries nicht veränderbar oder löschbar
* sie können jedoch ergänzt werden
* Tupel werden genutzt, um Daten zu speichern, die nicht geändert werden sollen
* (man könnte diese natürlich auch in Dictionarie und Listen speichern, so geht man aber sicher, dass die Daten nicht ausersehen geändert werden; außerdem ist die Speicherperformance besser)

==== Syntax ====
* die Erstellung von Tupeln ist analog zur Erstellung von Listen, nur hier werden keine Klammern benötigt (s.Beispiel_1)
* der Zugriff auf die Elemente des Tupels ist analog zur Syntax bei Listen (s.Beispiel_1)

=====Tupel ausgeben lassen =====
* sowohl das ausgeben des ganzen Tupels, als auch der einzelnen Elemente folgt der selben Syntax der Listen

===== Erweiterung eines Tupels =====
* auch hier ist die Syntax analog zur Erweiterung von Listen
* das neue Element muss selbst ein Tupel sein, um es zum Tupel hinzufügen zu können
* dazu muss das neue Element erst als Tupel abgespeichert werden
* um ein neues Element als Tupel zu speichern, wird ein Tupel mit nur einem Element erstellt
* nun kann dieser Tupel dem alten hinzugefügt werden (s.Beispiel_2)

#Beispiel_2:
tier_1="Hund",100,399,99,True
farbe= "braun",
tier_1=tier_1 + farbe
print(tier_1)

output
('Hund', 100, 399, 99, True, 'braun')

== Literatur ==
Michael Bonacina: Python 3 Programmieren für Einsteiger. 2. Auflage. BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2

2.Datentypen und Datenstrukturen

2023-05-28T11:38:16Z

Ani: /* Element aus Liste löschen */

__TOC__

== Datentypen ==

In Python unterscheidet man vier verschiedene Datentypen (Klassen):
{| class="wikitable"
|-
! Datentyp !! Abkürzung !! Bedeutung !! Beispiel
|-
| String || str || Zeichenkette || "abc"
|-
| Integer || int || Ganze Zahl || 1
|-
| Float || float || Dezimalzahl || 1.0
|-
| Boolean || bool || Wahrheitsgehalt || True, False
|}

Der Datentyp kann durch den ''type''-Befehl abgefragt werden.
 Beispiel:
‎<syntaxhighlight lang="python">
sequence = "ACGT"
result = type(sequence)
print(result)
# Output: <class 'str'>
‎</syntaxhighlight>

== Datenstrukturen ==

Man unterscheidet zwischen drei verscheiden Datenstrukturen:
Listen, Dictionary und Tupel. Alle diese Datenstrukturen stellen Organisationsformen
von Daten in Python dar. Das heißt sie erleichtern vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheiden sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

‎<syntaxhighlight lang="python">
#Befehl:
liste = ['string', variable, 1, 2.0, True]

# Beispiel_1:

hund = ['Hund', 100, 399, 99, True]
katze = ['Katze', 60, 249, 99, True]
fisch = ['Fisch', 3, 1, 50, False]

print(hund)
print(katze)
print(fisch)

# output
# ['Hund', 100, 399, 99, True]
# ['Katze', 60, 249, 99, True]
# ['Fisch', 3, 1, 50, False]
‎</syntaxhighlight>
==== Funktion ====
* haben dieselbe Funktion wie Listen im echten Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht das Programm übersichtlicher und erleichtert die Arbeit, weil nicht jeder einzelne Wert mit einem eigenen Variablennamen gespeichert werden muss

==== Syntax ====
* die Liste erhält einen Namen, welcher wie eine Variable durch ein Gleichheitszeichen den Elementen der Liste zugeordnet wird
* die Elemente der Liste werden in eckige Klammern gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können verschiedene Datentypen auf einmal vorkommen

===== Liste ausgeben lassen =====
* die ganze Liste lässt sich durch einen print-Befehl ausgeben (s. Beispiel_1)

====== einzelne Elemente der Liste ausgeben lassen ======
* auch einzelne Elemente der Liste können ausgegeben werden (s. Beispiel_2)
* dabei wird die Position des auszugebenden Elements durch eine Indexzahl in eckigen Klammern nach dem Listennamen angegeben
* Achtung: grundsätzlich zählt man von 0 ausgehend, d.h. das erste Element in der Liste besitzt die Position 0, das zweite die Position 1 etc.
* es kann auch von hinten gezählt werden, dabei besitzt das erste Element (welches von vorne gezählt das letzte wäre) die Position -1 usw.

====== Bereich der Liste ausgeben lassen ======
* es lässt sich auch ein bestimmter Bereich der Liste ausgeben, wobei die Positionen der Elemente durch einen Doppelpunkt getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein, welche ausgegeben wird (engl. inclusive)
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird (engl. exclusive)
* um die Syntax des Befehls zu verstehen, ist es sinnvoll, die verschiedenen Möglichkeiten einmal selbst auszuprobieren und die Aufgaben 4 und 5 auf dem Aufgabenblatt zu bearbeiten
‎<syntaxhighlight lang="python">
# Befehl:
print(liste[Position])

# Beispiel_2:
tier_1 = ["Hund", 100, 399, 99, True]

print(tier_1[0])
print(tier_1[1])
print(tier_1[-1])
print(tier_1[0:4])

# output
# Hund
# 100
# True
# ['Hund', 100, 399, 99]
‎‎</syntaxhighlight>

===== Liste verändern =====
* wie Variablen sind auch Listen veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

====== Element in Liste verändern ======
* Elemente der Liste lassen sich verändern, genau wie auch der Wert von Variablen neu definiert werden kann
* dafür schreibt man den Namen der Liste, dahinter eine Indexzahl in eckigen Klammern, wobei die Indexzahl die Position des zu verändernden Elements angibt
* die Zuweisung des neuen Werts erfolgt durch ein Gleichheitszeichen und den neuen Wert, den das Element der Liste annehmen soll (s. Beispiel_3)
‎<syntaxhighlight lang="python">
# Befehl:
liste[Position]= neuer_Wert

# Beispiel_3:
tier_1 = ['Hund', 100, 399, 99, True]
print(tier_1)
tier_1[0] = "Tiger"
tier_1[1] = 500
print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Tiger', 500, 399, 99, True]
‎</syntaxhighlight>
====== Element zu einer Liste hinzufügen ======
* Listen können erweitert werden
* dazu schreibt man den Namen der Liste ein Gleichheitszeichen, erneut den Namen der Liste, ein „+“ und das Element das hinzugefügt werden soll in eckigen Klammern (s. Beispiel_4)
‎<syntaxhighlight lang="python">
# Befehl:
liste = liste + [neues_Element]

# Beispiel_4:
tier_1 = ['Hund', 100, 399, 99, True]
print(tier_1)
tier_1 = tier_1 + ["Elefant"]
print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Hund', 100, 399, 99, True, 'Elefant']
‎</syntaxhighlight>
====== Element aus Liste löschen ======
* Elemente lassen sich mit dem del-Befehl aus der Liste entfernen (s. Beispiel_5)
* nach „del“ folgt der Listenname und die Position des zu löschenden Elements in eckigen Klammern
<syntaxhighlight lang="python">
# Befehl:
del liste[Position]

# Beispiel_5:
tier_1 = ['Hund', 100, 399, 99, True]
del tier_1[1]
print(tier_1)

# Output: ['Hund', 399, 99, True]
</syntaxhighlight>

===== Addition und Multiplikation von Listen =====
* Listen können miteinander addiert oder mit Zahlen multipliziert werden
(s. Beispiel_6)
* werden zwei Listen addiert, wird der Inhalt der Listen hintereinander ausgegeben
* wird eine Liste mit einer Zahl multipliziert, wird der Inhalt der Liste entsprechend oft hintereinander ausgegeben

#Beispiel_6:
tier_1=["Hund",100,399,99,True]
tier_2=["Katze",60,249,99,True]
tier_3=["Fisch",3,1 ,50,False]

print(tier_1 + tier_2)
print(tier_1 *2)

output
['Hund', 100, 399, 99, True, 'Katze', 60, 249, 99, True]
['Hund', 100, 399, 99, True, 'Hund', 100, 399, 99, True]

===== Listen in Listen =====
* Elemente einer Liste können selbst eine Liste sein, so erhält man Listen in einer Liste (s.Beispiel_7)
* es entsteht eine zweidimensionale Liste mit einer übergeordneten Liste (im Beispiel: alle_tiere) und den untergeordneten Listen ( tier_1, tier_2, tier_3)
* auf die Elemente der übergeordneten Liste lässt sich wie oben gezeigt zugreifen
* möchte man nur auf ein Element der untergeordneten Liste zugreifen, sind zwei Indexzahlen notwendig
* die erste Indexzahl gibt die Position des Elements in der übergeordneten Liste an
* die zweite Indexzahl gibt die Position des Elements in der untergeordneten Liste an (s.Beispiel_7)

#Befehl:
print(liste[Position][Position])

#Beispiel_7:
tier_1=["Hund",100,399,99,True]
tier_2=["Katze",60,249,99,True]
tier_3=["Fisch",3,1 ,50,False]

alle_tiere=[tier_1, tier_2, tier_3]
print(alle_tiere)
print(alle_tiere[0])
print(alle_tiere[0][0])

output
[["Hund",100,399,99,True],["Katze",60,249,99,True],["Fisch",3,1 ,50,False]]
['Hund', 100, 399, 99, True]
Hund

=== Dictionaries ===

#Befehl:
dictionary={"key_1":Element_1,"key_2":Element_2}

#Beispiel_1:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

print(buch_1)
print(buch_1["Buch"])
print(buch_1["Autor"])
print(buch_1["Preis"])

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
Der Herr der Ringe
Tolkien
45

==== Funktion ====
Listen sind zwar geeignet, um größere Mengen an Daten in übersichtlicher
und gut manipulierbarer Weise abzuspeichern, haben aber einen entscheidenden Nachteil.
Um auf ein Element in einer Liste zugreifen zu können, ist es notwendig die Position
des Elements in der Liste zu kennen. Bei kürzeren Listen lässt sich vielleicht noch der Überblick behalten. Sobald Listen aber eine gewissen Anzahl an Elementen überschreiten,
in einem Programm mehrere Listen verwendet werden oder sogar Listen in Listen gespeichert sind,
ist jeglicher Versuch sich die Positionen der Elemente zu merken vergebens.
Hier bringen die sogenannten Dictionaries den entscheidenden Vorteil.
Dictionaries funktionieren wie Listen, wenn es darum geht Informationen abzuspeichern.
Doch der Zugriff auf die Elemente folgt nicht durch eine Indexnummer sondern über ein sogenannten key oder Schlüsselbegriff.
Um auf die Elemente über einen key zugreifen zu können, werden den Elementen im Dictionary ein Schlüsselbegriff zugeordnet.

==== Syntax ====
* nach dem Namen des Dictionary und dem Gleichheitszeichen folgt eine geschweifte Klammer {}
* danach folgt der Key, dabei kann es sich um ein integer, float, bool oder string handeln
* darauf folgt das Listenelement, getrennt durch einen Doppelpunkt vom Key und durch ein Komma vom nächsten Key-Element Paar

===== Dictionary ausgeben lassen =====
* das ganze Dictionary lässt sich durch einen print-Befehl ausgeben (s. Beispie_1)

====== einzelne Elemente des Dictionaries ausgeben ======
* der Zugriff erfolgt durch den key
* die Syntax ist analog zum Abruf der Elemente einer Liste, nur das statt der Indexzahl der key in die eckige Klammer geschrieben wird (s.Beispeil_1)

===== Dictionary verändern =====
* wie Listen sind auch Dictionaries veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

====== Element in Dictionary verändern ======
* die Syntax ist analog zur Veränderung eines Elements in Listen, nur hier wird der key, statt der Position in die eckigen Klammern hinter dem Namen des Dictionaries gesetzt (s.Beispiel_2)

#Befehl:
dictionary[(bestehender)key]= neuer Wert 
#Beispiel_2:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}
buch_1["Preis"]= 23
print(buch_1)

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 23}

====== Element zum Dictionary hinzufügen ======
* um Elemente zum Dictionary hinzuzufügen ist es notwendig auch gleichzeitig ein key für das Element zu definieren
* nach dem Listennamen und dem Key in eckigen Klammern folg ein Gleichheitszeichen und der Wert des neuen Elements (s.Beispiel_3)

#Befehl:
dictionary[(neuer) key]= neues Element

#Beispiel_3:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

buch_1["Erscheinungsjahr"]= 1954
buch_1["Bewertung"]="sehr gut"
print(buch_1)

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45, 'Erscheinungsjahr': 1954, 'Bewertung': 'sehr gut'}

====== Element aus Dictionary löschen ======
* analoger Aufbau zum del-Befehl bei Listen
* hier wird wieder anstatt der Indexzahl der key in die eckigen Klammern gesetzt (s.Besipiel_4)

#Befehl:
del dictionary[key]

#Beispiel_4:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

del buch_1["Preis"]
print(buch_1)

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien'}

=== Tupel ===
#Befehl:
tupel= element_1, element_2 
#Beispiel_1:
tier_1="Hund",100,399,99,True 
print(tier_1)
print(tier_1[0])

output
('Hund', 100, 399, 99, True)
Hund

==== Funktion ====
* Tupelo sind unveränderliche Daten, d.h. die Elemente eines Tupels sind im Gegensatz zu Listen und Dictionaries nicht veränderbar oder löschbar
* sie können jedoch ergänzt werden
* Tupel werden genutzt, um Daten zu speichern, die nicht geändert werden sollen
* (man könnte diese natürlich auch in Dictionarie und Listen speichern, so geht man aber sicher, dass die Daten nicht ausersehen geändert werden; außerdem ist die Speicherperformance besser)

==== Syntax ====
* die Erstellung von Tupeln ist analog zur Erstellung von Listen, nur hier werden keine Klammern benötigt (s.Beispiel_1)
* der Zugriff auf die Elemente des Tupels ist analog zur Syntax bei Listen (s.Beispiel_1)

=====Tupel ausgeben lassen =====
* sowohl das ausgeben des ganzen Tupels, als auch der einzelnen Elemente folgt der selben Syntax der Listen

===== Erweiterung eines Tupels =====
* auch hier ist die Syntax analog zur Erweiterung von Listen
* das neue Element muss selbst ein Tupel sein, um es zum Tupel hinzufügen zu können
* dazu muss das neue Element erst als Tupel abgespeichert werden
* um ein neues Element als Tupel zu speichern, wird ein Tupel mit nur einem Element erstellt
* nun kann dieser Tupel dem alten hinzugefügt werden (s.Beispiel_2)

#Beispiel_2:
tier_1="Hund",100,399,99,True
farbe= "braun",
tier_1=tier_1 + farbe
print(tier_1)

output
('Hund', 100, 399, 99, True, 'braun')

== Literatur ==
Michael Bonacina: Python 3 Programmieren für Einsteiger. 2. Auflage. BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2

2.Datentypen und Datenstrukturen

2023-05-28T11:20:13Z

Ani: Formatierung und Kleinigkeiten in 1. Hälfte des Artikels verbessert

__TOC__

== Datentypen ==

In Python unterscheidet man vier verschiedene Datentypen (Klassen):
{| class="wikitable"
|-
! Datentyp !! Abkürzung !! Bedeutung !! Beispiel
|-
| String || str || Zeichenkette || "abc"
|-
| Integer || int || Ganze Zahl || 1
|-
| Float || float || Dezimalzahl || 1.0
|-
| Boolean || bool || Wahrheitsgehalt || True, False
|}

Der Datentyp kann durch den ''type''-Befehl abgefragt werden.
 Beispiel:
‎<syntaxhighlight lang="python">
sequence = "ACGT"
result = type(sequence)
print(result)
# Output: <class 'str'>
‎</syntaxhighlight>

== Datenstrukturen ==

Man unterscheidet zwischen drei verscheiden Datenstrukturen:
Listen, Dictionary und Tupel. Alle diese Datenstrukturen stellen Organisationsformen
von Daten in Python dar. Das heißt sie erleichtern vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheiden sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

‎<syntaxhighlight lang="python">
#Befehl:
liste = ['string', variable, 1, 2.0, True]

# Beispiel_1:

hund = ['Hund', 100, 399, 99, True]
katze = ['Katze', 60, 249, 99, True]
fisch = ['Fisch', 3, 1, 50, False]

print(hund)
print(katze)
print(fisch)

# output
# ['Hund', 100, 399, 99, True]
# ['Katze', 60, 249, 99, True]
# ['Fisch', 3, 1, 50, False]
‎</syntaxhighlight>
==== Funktion ====
* haben dieselbe Funktion wie Listen im echten Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht das Programm übersichtlicher und erleichtert die Arbeit, weil nicht jeder einzelne Wert mit einem eigenen Variablennamen gespeichert werden muss

==== Syntax ====
* die Liste erhält einen Namen, welcher wie eine Variable durch ein Gleichheitszeichen den Elementen der Liste zugeordnet wird
* die Elemente der Liste werden in eckige Klammern gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können verschiedene Datentypen auf einmal vorkommen

===== Liste ausgeben lassen =====
* die ganze Liste lässt sich durch einen print-Befehl ausgeben (s. Beispiel_1)

====== einzelne Elemente der Liste ausgeben lassen ======
* auch einzelne Elemente der Liste können ausgegeben werden (s. Beispiel_2)
* dabei wird die Position des auszugebenden Elements durch eine Indexzahl in eckigen Klammern nach dem Listennamen angegeben
* Achtung: grundsätzlich zählt man von 0 ausgehend, d.h. das erste Element in der Liste besitzt die Position 0, das zweite die Position 1 etc.
* es kann auch von hinten gezählt werden, dabei besitzt das erste Element (welches von vorne gezählt das letzte wäre) die Position -1 usw.

====== Bereich der Liste ausgeben lassen ======
* es lässt sich auch ein bestimmter Bereich der Liste ausgeben, wobei die Positionen der Elemente durch einen Doppelpunkt getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein, welche ausgegeben wird (engl. inclusive)
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird (engl. exclusive)
* um die Syntax des Befehls zu verstehen, ist es sinnvoll, die verschiedenen Möglichkeiten einmal selbst auszuprobieren und die Aufgaben 4 und 5 auf dem Aufgabenblatt zu bearbeiten
‎<syntaxhighlight lang="python">
# Befehl:
print(liste[Position])

# Beispiel_2:
tier_1 = ["Hund", 100, 399, 99, True]

print(tier_1[0])
print(tier_1[1])
print(tier_1[-1])
print(tier_1[0:4])

# output
# Hund
# 100
# True
# ['Hund', 100, 399, 99]
‎‎</syntaxhighlight>

===== Liste verändern =====
* wie Variablen sind auch Listen veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

====== Element in Liste verändern ======
* Elemente der Liste lassen sich verändern, genau wie auch der Wert von Variablen neu definiert werden kann
* dafür schreibt man den Namen der Liste, dahinter eine Indexzahl in eckigen Klammern, wobei die Indexzahl die Position des zu verändernden Elements angibt
* die Zuweisung des neuen Werts erfolgt durch ein Gleichheitszeichen und den neuen Wert, den das Element der Liste annehmen soll (s. Beispiel_3)
‎<syntaxhighlight lang="python">
# Befehl:
liste[Position]= neuer_Wert

# Beispiel_3:
tier_1 = ['Hund', 100, 399, 99, True]
print(tier_1)
tier_1[0] = "Tiger"
tier_1[1] = 500
print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Tiger', 500, 399, 99, True]
‎</syntaxhighlight>
====== Element zu einer Liste hinzufügen ======
* Listen können erweitert werden
* dazu schreibt man den Namen der Liste ein Gleichheitszeichen, erneut den Namen der Liste, ein „+“ und das Element das hinzugefügt werden soll in eckigen Klammern (s. Beispiel_4)
‎<syntaxhighlight lang="python">
# Befehl:
liste = liste + [neues_Element]

# Beispiel_4:
tier_1 = ['Hund', 100, 399, 99, True]
print(tier_1)
tier_1 = tier_1 + ["Elefant"]
print(tier_1)

# output
# ['Hund', 100, 399, 99, True]
# ['Hund', 100, 399, 99, True, 'Elefant']
‎</syntaxhighlight>
====== Element aus Liste löschen ======
* Elemente lassen sich mit dem del-Befehl aus der Liste entfernen (s.Beispiel_5)
* nach „del“ folgt der Listenname und die Position des zu löschenden Elements in eckigen Klammern

Befehl:
del liste[]

#Beispiel_5:
tier_1=["Hund",100,399,99,True] 
del tier_1[1]
print(tier_1)

output
['Hund', 399, 99, True]

===== Addition und Multiplikation von Listen =====
* Listen können miteinander addiert oder mit Zahlen multipliziert werden
(s. Beispiel_6)
* werden zwei Listen addiert, wird der Inhalt der Listen hintereinander ausgegeben
* wird eine Liste mit einer Zahl multipliziert, wird der Inhalt der Liste entsprechend oft hintereinander ausgegeben

#Beispiel_6:
tier_1=["Hund",100,399,99,True]
tier_2=["Katze",60,249,99,True]
tier_3=["Fisch",3,1 ,50,False]

print(tier_1 + tier_2)
print(tier_1 *2)

output
['Hund', 100, 399, 99, True, 'Katze', 60, 249, 99, True]
['Hund', 100, 399, 99, True, 'Hund', 100, 399, 99, True]

===== Listen in Listen =====
* Elemente einer Liste können selbst eine Liste sein, so erhält man Listen in einer Liste (s.Beispiel_7)
* es entsteht eine zweidimensionale Liste mit einer übergeordneten Liste (im Beispiel: alle_tiere) und den untergeordneten Listen ( tier_1, tier_2, tier_3)
* auf die Elemente der übergeordneten Liste lässt sich wie oben gezeigt zugreifen
* möchte man nur auf ein Element der untergeordneten Liste zugreifen, sind zwei Indexzahlen notwendig
* die erste Indexzahl gibt die Position des Elements in der übergeordneten Liste an
* die zweite Indexzahl gibt die Position des Elements in der untergeordneten Liste an (s.Beispiel_7)

#Befehl:
print(liste[Position][Position])

#Beispiel_7:
tier_1=["Hund",100,399,99,True]
tier_2=["Katze",60,249,99,True]
tier_3=["Fisch",3,1 ,50,False]

alle_tiere=[tier_1, tier_2, tier_3]
print(alle_tiere)
print(alle_tiere[0])
print(alle_tiere[0][0])

output
[["Hund",100,399,99,True],["Katze",60,249,99,True],["Fisch",3,1 ,50,False]]
['Hund', 100, 399, 99, True]
Hund

=== Dictionaries ===

#Befehl:
dictionary={"key_1":Element_1,"key_2":Element_2}

#Beispiel_1:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

print(buch_1)
print(buch_1["Buch"])
print(buch_1["Autor"])
print(buch_1["Preis"])

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45}
Der Herr der Ringe
Tolkien
45

==== Funktion ====
Listen sind zwar geeignet, um größere Mengen an Daten in übersichtlicher
und gut manipulierbarer Weise abzuspeichern, haben aber einen entscheidenden Nachteil.
Um auf ein Element in einer Liste zugreifen zu können, ist es notwendig die Position
des Elements in der Liste zu kennen. Bei kürzeren Listen lässt sich vielleicht noch der Überblick behalten. Sobald Listen aber eine gewissen Anzahl an Elementen überschreiten,
in einem Programm mehrere Listen verwendet werden oder sogar Listen in Listen gespeichert sind,
ist jeglicher Versuch sich die Positionen der Elemente zu merken vergebens.
Hier bringen die sogenannten Dictionaries den entscheidenden Vorteil.
Dictionaries funktionieren wie Listen, wenn es darum geht Informationen abzuspeichern.
Doch der Zugriff auf die Elemente folgt nicht durch eine Indexnummer sondern über ein sogenannten key oder Schlüsselbegriff.
Um auf die Elemente über einen key zugreifen zu können, werden den Elementen im Dictionary ein Schlüsselbegriff zugeordnet.

==== Syntax ====
* nach dem Namen des Dictionary und dem Gleichheitszeichen folgt eine geschweifte Klammer {}
* danach folgt der Key, dabei kann es sich um ein integer, float, bool oder string handeln
* darauf folgt das Listenelement, getrennt durch einen Doppelpunkt vom Key und durch ein Komma vom nächsten Key-Element Paar

===== Dictionary ausgeben lassen =====
* das ganze Dictionary lässt sich durch einen print-Befehl ausgeben (s. Beispie_1)

====== einzelne Elemente des Dictionaries ausgeben ======
* der Zugriff erfolgt durch den key
* die Syntax ist analog zum Abruf der Elemente einer Liste, nur das statt der Indexzahl der key in die eckige Klammer geschrieben wird (s.Beispeil_1)

===== Dictionary verändern =====
* wie Listen sind auch Dictionaries veränderbar, es können Elemente hinzugefügt, geändert und sogar gelöscht werden

====== Element in Dictionary verändern ======
* die Syntax ist analog zur Veränderung eines Elements in Listen, nur hier wird der key, statt der Position in die eckigen Klammern hinter dem Namen des Dictionaries gesetzt (s.Beispiel_2)

#Befehl:
dictionary[(bestehender)key]= neuer Wert 
#Beispiel_2:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}
buch_1["Preis"]= 23
print(buch_1)

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 23}

====== Element zum Dictionary hinzufügen ======
* um Elemente zum Dictionary hinzuzufügen ist es notwendig auch gleichzeitig ein key für das Element zu definieren
* nach dem Listennamen und dem Key in eckigen Klammern folg ein Gleichheitszeichen und der Wert des neuen Elements (s.Beispiel_3)

#Befehl:
dictionary[(neuer) key]= neues Element

#Beispiel_3:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

buch_1["Erscheinungsjahr"]= 1954
buch_1["Bewertung"]="sehr gut"
print(buch_1)

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien', 'Preis': 45, 'Erscheinungsjahr': 1954, 'Bewertung': 'sehr gut'}

====== Element aus Dictionary löschen ======
* analoger Aufbau zum del-Befehl bei Listen
* hier wird wieder anstatt der Indexzahl der key in die eckigen Klammern gesetzt (s.Besipiel_4)

#Befehl:
del dictionary[key]

#Beispiel_4:
buch_1={"Buch":"Der Herr der Ringe", "Autor":"Tolkien", "Preis":45}

del buch_1["Preis"]
print(buch_1)

output
{'Buch': 'Der Herr der Ringe', 'Autor': 'Tolkien'}

=== Tupel ===
#Befehl:
tupel= element_1, element_2 
#Beispiel_1:
tier_1="Hund",100,399,99,True 
print(tier_1)
print(tier_1[0])

output
('Hund', 100, 399, 99, True)
Hund

==== Funktion ====
* Tupelo sind unveränderliche Daten, d.h. die Elemente eines Tupels sind im Gegensatz zu Listen und Dictionaries nicht veränderbar oder löschbar
* sie können jedoch ergänzt werden
* Tupel werden genutzt, um Daten zu speichern, die nicht geändert werden sollen
* (man könnte diese natürlich auch in Dictionarie und Listen speichern, so geht man aber sicher, dass die Daten nicht ausersehen geändert werden; außerdem ist die Speicherperformance besser)

==== Syntax ====
* die Erstellung von Tupeln ist analog zur Erstellung von Listen, nur hier werden keine Klammern benötigt (s.Beispiel_1)
* der Zugriff auf die Elemente des Tupels ist analog zur Syntax bei Listen (s.Beispiel_1)

=====Tupel ausgeben lassen =====
* sowohl das ausgeben des ganzen Tupels, als auch der einzelnen Elemente folgt der selben Syntax der Listen

===== Erweiterung eines Tupels =====
* auch hier ist die Syntax analog zur Erweiterung von Listen
* das neue Element muss selbst ein Tupel sein, um es zum Tupel hinzufügen zu können
* dazu muss das neue Element erst als Tupel abgespeichert werden
* um ein neues Element als Tupel zu speichern, wird ein Tupel mit nur einem Element erstellt
* nun kann dieser Tupel dem alten hinzugefügt werden (s.Beispiel_2)

#Beispiel_2:
tier_1="Hund",100,399,99,True
farbe= "braun",
tier_1=tier_1 + farbe
print(tier_1)

output
('Hund', 100, 399, 99, True, 'braun')

== Literatur ==
Michael Bonacina: Python 3 Programmieren für Einsteiger. 2. Auflage. BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2

1.Einführung

2023-05-28T11:02:50Z

Ani: Inhaltliche und sprachliche Fehler korrigiert

__TOC__

== Was ist Programmieren? ==

Was ist Programmieren?
„Programmieren bezeichnet die Tätigkeit, Computerprogramme zu erstellen.“<ref group="Weblinks"> https://de.wikipedia.org/wiki/Programmierung (Stand:[12.07.21]) </ref>
Ein Computerprogramm wird in einer sogenannten Programmiersprache verfasst (wir benutzen dafür Python), welche wie gesprochene Sprachen bestimmten Regeln folgen.
Diese formalen Regeln, also die einzelnen Befehle und Ausdrücke, aus denen Python aufgebaut ist,
werden als Syntax bezeichnet.<ref group="Literatur"> Michael Bonacina: ''Python 3 Programmieren für Einsteiger. 2. Auflage.'' BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2 </ref>

Ein Programm besteht also aus einer Abfolge von Anweisungen, verfasst in einer Programmiersprache. Programme dienen dazu bestimmte Aufgaben zu bearbeiten, Funktionen zu erfüllen oder Probleme zu lösen.<ref group="Weblinks"> https://de.wikipedia.org/wiki/Computerprogramm (Stand:[12.07.21]) </ref> 
Eine Abfolge von Anweisungen, also eine Verarbeitungsvorschrift, die aus einer endlichen Folge von eindeutig ausführbaren Anweisungen besteht, mit der man eine Vielzahl gleichartiger Aufgaben lösen kann, wird als Algorithmus bezeichnet. So lassen sich mit Hilfe von Algorithmen,
(ausgedrückt in vielen einzelnen Befehlen der Programmiersprache) komplexe Probleme lösen.

Ein Beispiel dafür ist der Smith-Waterman-Algorithmus. Dabei wird das Problem in viele Unterprobleme aufgeteilt, die nacheinander gelöst werden und als Zwischenergebnisse gespeichert werden.
Diese Art der algorithmischen Lösung eines (Optimierungs-)Problems wird als dynamische Programmierung bezeichnet,<ref group="Weblinks"> https://en.wikipedia.org/wiki/Dynamic_programming (Stand:[12.07.21]) </ref> stellt aber nur eine Art der algorithmischen Programmierung dar.

== Eine interpretierte Programmiersprache ==

Ein Programm wird zwar nach den Regeln der Syntax verfasst, der Computer kann aber erstmal nichts mit diesem Programm anfangen.
Das Programm besteht nämlich aus gewöhnlichem Text (Ziffern, Buchstaben und anderen Zeichen).
Der Computer arbeitet jedoch mit Anweisungen, die binär als Maschinensprache codiert werden. Bei dieser wird jede einzelne Information als ein Bit dargestellt.

Damit der Computer also ein Programm ausführen kann, muss das Programm in Maschinensprache übersetzt werden. Dafür gibt es zwei Möglichkeiten, die Kompilation oder die Interpretation.
Bei der Kompilation wird nach Verfassen des Codes, das Programm über eine Zwischenstufe in Anweisungen für den Computer übersetzt. Erst dann erhält man ein ausführbares Programm.
Bei der Interpretation durch einen Interpreter, findet die Übersetzung in den Binärcode während der Ausführung statt. Bei Python wird ein Interpreter verwendet, darum handelt es sich um eine interpretierte Programmiersprache. Diese Beziehungen sind noch mal übersichtlich in der Präsentationsfolie Seite 16 zu sehen (s. unten).
Beide Methoden haben Vor- und Nachteileile.<ref group="Literatur"> Michael Bonacina: ''Python 3 Programmieren für Einsteiger. 2. Auflage.'' BMU Verlag, Landshut 2019, ISBN: 978-3-96645-007-2 </ref>
[[File:Beziehung Programmiersprache und Computersprache.png|200px|thumb|center|Kommunikationsdiagramm zwischen Computer und Mensch]]

== Literatur ==
<references group="Literatur" />
== Weblinks ==
<references group="Weblinks" />