Bioinformatik Wiki - User contributions [en]

6.Normalisierungen

2022-06-01T11:53:02Z

Mka: /* a: Normalisierung mit RPKM */

==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 = Set 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

6 Normalisierungen

2022-06-01T11:24:17Z

Mka: /* RPKM */

=Normalisierungen=
Unter Normalisierung versteht man in der Biologie die Verringerung von Verzerrungen innerhalb eines Datensatzes. Systematische Verzerrungen sind z.B. verschiedene Durchführungsrunden, unterschiedliche Bedingungen, Laborausstattung, Experimentatoren ect.
Auch die heterologe Geneigenschaften können zu unterschiedlichen Ergebnissen bei eigentlich gleicher Genexpression führen, wie z.B. Genlänge.
Normalisierungen der RNASeq-Daten sind deshalb notwendig, um diese vergleichen. zu können und die tatsächliche Genexpression quantifizieren zu können.

==RPKM==
RPKM steht für 'Reads per kilobase of transcript per Million mapped reads' und ist eine Normalisierungsmethode für Expressionsstärken. 
{| class="wikitable"
|-
! Formel !! Parameter
|-
| <math> RPKM = \frac{ c_\text{i}}{L_\text{i} \cdot N} *10^6</math> || ci = Anzahl an ausrichtbaren reads für ein Transkript 'i'
Li = Länge des Transkripts/Gens 'i' in kbp 
N = Gesamtanzahl an ausrichtbaren reads in Millionen
|}

<math> \frac{ c_\text{i}}{L_\text{i}} </math> → Normalisierung der Genlänge 
<math> L_\text{i} \cdot N </math> → Normalisierung der Sequenziertiefe
Je höher der RPKM-Wert ist, desto höher ist die Genexpression. 
RPKM-Werte können gut zum Vergleich der Genexpressionen innerhalb einer Probe genutzt werden, jedoch sind sie nicht dafür geeignet mehrere Experimente bzw. Proben miteinander zu vergleichen.

'''Beispiel:'''

[[File:Beispiel Probe.png|Beispiel Probe]] 
<math> N=6*10^6 reads </math> 

* <math> RPKM (A) = \frac{12}{0,6 kbp \cdot 6} * 10^6 = 3,33 \cdot 10^{6} </math> 

* <math> RPKM (B) = \frac{24}{1,1 kbp \cdot 6} * 10^6 = 3,64 \cdot 10^{6} </math> 

* <math> RPKM (C) = \frac{11}{1,4 kbp \cdot 6} * 10^6= 1,31 \cdot 10^{6} </math> 

Durch die Normalisierung der Expressionsstärken können diese nun miteinander vergleichen werden.In diesem Beispiel wird Gen B am stärksten exprimiert und Gen C am schwächsten.

==TPM==
TPM steht für 'Transcripts per Million' und ist eine Normalisierungsmethode für Expressionsstärken. 

{| class="wikitable"
|-
! Formel !! Parameter
|-
|<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> || 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
|}
Wenn 1 Millionen Transkripte sequenziert würden, wäre TPMi die Anzahl an Transkripten des Types 'i'. 

'''Beispiel:''' 
[[File:Beispiel Probe.png|Beispiel Probe]] 

*<math> TPM (A) = \frac{ 12}{600} \cdot \dfrac {1}{ \dfrac {12}{600} + \dfrac {24}{1100} + \dfrac {11}{1400}} \cdot 10^6 = 402614 </math> 

*<math> TPM (B) = \frac{ 24}{1100} \cdot \dfrac {1}{ \dfrac {12}{600} + \dfrac {24}{1100} + \dfrac {11}{1400}} \cdot 10^6 = 439216 </math> 

*<math> TPM (C) = \frac{ 11}{1400} \cdot \dfrac {1}{ \dfrac {12}{600} + \dfrac {24}{1100} + \dfrac {11}{1400}} \cdot 10^6 = 158170 </math> 

Nach der Normalisierung ist ein Vergleich der Genexpressionen möglich. Das Ergebnis gibt an, wie viele Transkripte der Gene entstehen würden, wenn 1 Millionen Transkripte sequenziert werden würden. So würde man z.B. für Gen B 429216 Transkripte erhalten und für Gen C 158170 Transkripte, somit wird Gen B stärker exprimiert, als Gen C. Die Summe der reads ergibt 1 Million.

'''Probleme von RPKM und TPM:'''

Die beiden Methoden sind nur gut geeignet, um Expressionswerte bzw. Expressionslevel innerhalb einer Probe zu vergleichen.Von sehr heterologen Expressionsprofilen zwischen zwei Proben können identische Genexpressionen fälschlicherweise als unterschiedlich erkannt werden.

Lösung: TMM als Normalisierungsmethode zwischen Proben

==TMM==
TMM steht für 'Trimmed mean of M-values normalization method'. 
*Gesamtexpressionsstärke pro Probe wird bestimmt, um einzelne Genexpressionen zu bestimmen.
*Das Expressionsverhältnis zwischen zwei Bedingungen für ein Gen 'g' wird bestimmt.
*Genexpressionen von zwei Proben mit unterschiedlichen Bedingungen (z.B. krank und gesund) können miteinander verglichen werden. 

'''1.''' Bestimmung des '''Gewichtungsfaktors''' für das Expressionsverhältnis für Gen 'g' zwischen Probe 'k' ' und 'k'. 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. 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. Gewichtete Mittelwerte aller Expressionsverhältnisse''' können berechnet werden. Einsetzen der in 1. und 2. ermittelten Werte. 
<div align="center"> <math> TMM = 2^{log_2 (TMM_\text{k}^\text{k`})} </math></div> 

'''Gesamt:'''
{| 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 = Set 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

== Beispielrechnung ==
Gen Zustand 1[bp] Zustand 2[bp]
A 200 600
B 600 0
C 800 960
D 400 480

Summe 2000 1680

Folgende Dinge gelten nun:
* TMM braucht immer einen Referenzwert (hier: Zustand 1); Wenn man mehrere Proben hätte, könnte man diese alle an Zustand 1 messen.

* Zuerst normalisiert man die Counts innerhalb der Probe
Ya/N Yb/N 
A <math>\frac{200}{2000}=0,1</math> <math>\frac{240}{1680}=0,143</math> 
B <math>\frac{600}{2000}=0,3</math> <math>\frac{0}{1680}=0</math> 
C <math>\frac{800}{2000}=0,4</math> <math>\frac{960}{1680}=0,571</math> 
D <math>\frac{400}{2000}=0,2</math> <math>\frac{2480}{1680}=0,286</math>

* Mittelwert der Expressionsverhältnisse
Ma/b
A <math>log_{2} \frac{0,143}{0,1}=0,516</math> 
B <math>log_{2} \frac{0}{0,3}= -Inf </math> 
C <math>log_{2} \frac{0,571}{0,4}=0,513</math> 
D <math>log_{2} \frac{0,286}{0,2}=0,516</math> 
*'''kleiner Praxistipp von eurem Admin''': <math>log_{2}</math> ist der Logarithmus von 2, Es ist nicht der natürliche log, es ist nicht ln, es ist nichts mit eulerscher Zahl oder was eure Taschenrechner sonst noch so hergeben. Also sucht eine Funktion, in der ihr die Basis des log eintragen könnt und gebt dort eine 2 ein.

*Nun kommt der Gewichtungsfaktor ins Spiel
Wa/b
A <math> \frac{1680-240}{1680*240} + \frac{2000-200}{2000*200}=0,081</math> 
B <math> \frac{1680-0}{1680*0} + \frac{2000-600}{2000*600}= -Inf </math> 
C <math> \frac{1680-960}{1680*960} + \frac{2000-800}{2000*800}=0,0012</math> 
D <math> \frac{1680-480}{1680*480} + \frac{2000-400}{2000*400}=0,0035</math> 
'''Summe der Gewichtung 0,0128'''

*Nun werden die Mittelwerte der Expressionsverhältnisse gewichtet (durch den Gewichtungsfaktor)

A 0,516 * 0,081 = 0,0042
B -
C 0,513 * 0,0012 = 0,0006
D 0,516 * 0,0018 = 0,0018
Summe 0,0066

Nun wird TMM berechnet: 
<math>\frac{\text{Summe der gewichteten Mittelwerte der Expressionsverhältnisse}}{\text{Summe Gewichtungsfaktoren}}=log_{2}(TMM)</math>

<math>\frac{0,0066}{0,0128}=0,51=log_{2}(TMM)</math> 
* Jetzt noch die Formel umsetzen:
<math>log_{2}(TMM)= x</math>
<math>2^{x} = TMM </math>
<math>2^{0,51} = 1,4296 </math>

Main Page

2021-08-01T10:56:57Z

Mka: /* Ansprechpartner */

3.Befehle

2021-08-01T10:49:09Z

Mka: /* while-Schleife */

== ''print''-Befehl ==

#Befehl:
print()

#Beispiel:
print(“hello“)

output
hello

=== Funktion ===
* der entsprechende Inhalt des ''print''-Befehls wird in der Console ausgegeben

=== Syntax ===
* die runden Klammern dienen dazu den Anfang und das Ende der Ausgabe zu markieren
* 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

#Beipsiel_2:
print(falsch)

output
NameError: name 'falsch' is not defined

* Python geht davon aus das 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

== ''type''-Befehl ==

#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'>

===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 Varibalennamen
* 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 Console ausgegeben

== ''input'' -Befehl ==

#Befehl:
eingabe=input()

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

output
3 #eingegebene Zahl des Nutzers im Eingabefeld
3 #durch print-Befehl ausgegebene Zahl

=== 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
* gleichzeitig handelt es sich beim ''input''-Befehl auch um ein ''print''-Befehl, dazu muss der

=== Syntax ===
* nach den Ausdruck "input" folgt eine Klammer, die bei Ausführung des Programms ein Eingabefeld in der Console 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)

#Beispiel_2:
zahl=input("Gib hier diene Zahl ein: ")

print(zahl)

output
Gib hier deine Zahl ein: 3
3

* 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 Variablen wird also erst festgelegt, während das Programm läuft
* in der Console entsteht durch den ''input-Befehl'' ein „Eingabefeld“ (nicht direkt sichtbar) in das der Nutzer einen Wert (in Beispiel_1 eine Zahl) eintrage kann
* ACHTUNG!: jede Eingabe wird durch den input-Befehl automatisch als string gespeichert
* in Bespiel_3 wird die 3 in string-Form abgespeichert
* die Rechenoperation wird nicht als Multiplikation mit 2 verstanden sondern als Wiederholung des strings

#Beispiel_3:
zahl=input("Gib hier diene Zahl ein: ")
ergebnis= zahl*2
print(ergebnis)

output
Gib hier deine Zahl ein: 3
33

* der string 3 wird wiederholt und es kommt 33 statt 6 heraus
* Lösung: man kann den Datentyp des "inputs" vorab definieren:
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, dass in der Konsole, ein string wieder in Anführungszeichen gesetzt werden muss

#Beispiel_4:
zahl=eval(input("Gib hier diene 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

== ''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]]

== ''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 (die Funktionen der for-schleife wären zwar auch mit einer while schleifen lösbar, sind aber mit for schleifen deutlich einfacher zu lösen)
* 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]]

3.Befehle

2021-08-01T10:48:40Z

Mka: /* Syntax */

== ''print''-Befehl ==

#Befehl:
print()

#Beispiel:
print(“hello“)

output
hello

=== Funktion ===
* der entsprechende Inhalt des ''print''-Befehls wird in der Console ausgegeben

=== Syntax ===
* die runden Klammern dienen dazu den Anfang und das Ende der Ausgabe zu markieren
* 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

#Beipsiel_2:
print(falsch)

output
NameError: name 'falsch' is not defined

* Python geht davon aus das 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

== ''type''-Befehl ==

#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'>

===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 Varibalennamen
* 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 Console ausgegeben

== ''input'' -Befehl ==

#Befehl:
eingabe=input()

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

output
3 #eingegebene Zahl des Nutzers im Eingabefeld
3 #durch print-Befehl ausgegebene Zahl

=== 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
* gleichzeitig handelt es sich beim ''input''-Befehl auch um ein ''print''-Befehl, dazu muss der

=== Syntax ===
* nach den Ausdruck "input" folgt eine Klammer, die bei Ausführung des Programms ein Eingabefeld in der Console 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)

#Beispiel_2:
zahl=input("Gib hier diene Zahl ein: ")

print(zahl)

output
Gib hier deine Zahl ein: 3
3

* 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 Variablen wird also erst festgelegt, während das Programm läuft
* in der Console entsteht durch den ''input-Befehl'' ein „Eingabefeld“ (nicht direkt sichtbar) in das der Nutzer einen Wert (in Beispiel_1 eine Zahl) eintrage kann
* ACHTUNG!: jede Eingabe wird durch den input-Befehl automatisch als string gespeichert
* in Bespiel_3 wird die 3 in string-Form abgespeichert
* die Rechenoperation wird nicht als Multiplikation mit 2 verstanden sondern als Wiederholung des strings

#Beispiel_3:
zahl=input("Gib hier diene Zahl ein: ")
ergebnis= zahl*2
print(ergebnis)

output
Gib hier deine Zahl ein: 3
33

* der string 3 wird wiederholt und es kommt 33 statt 6 heraus
* Lösung: man kann den Datentyp des "inputs" vorab definieren:
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, dass in der Konsole, ein string wieder in Anführungszeichen gesetzt werden muss

#Beispiel_4:
zahl=eval(input("Gib hier diene 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

== ''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]]

== ''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 (die Funktionen der for-schleife wären zwar auch mit einer while schleifen lösbar, sind aber mit for schleifen deutlich einfacher zu lösen)
* 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]]

3.Befehle

2021-08-01T10:47:37Z

Mka: /* Syntax */

== ''print''-Befehl ==

#Befehl:
print()

#Beispiel:
print(“hello“)

output
hello

=== Funktion ===
* der entsprechende Inhalt des ''print''-Befehls wird in der Console ausgegeben

=== Syntax ===
* die runden Klammern dienen dazu den Anfang und das Ende der Ausgabe zu markieren
* 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

#Beipsiel_2:
print(falsch)

output
NameError: name 'falsch' is not defined

* Python geht davon aus das 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

== ''type''-Befehl ==

#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'>

===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 Varibalennamen
* 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 Console ausgegeben

== ''input'' -Befehl ==

#Befehl:
eingabe=input()

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

output
3 #eingegebene Zahl des Nutzers im Eingabefeld
3 #durch print-Befehl ausgegebene Zahl

=== 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
* gleichzeitig handelt es sich beim ''input''-Befehl auch um ein ''print''-Befehl, dazu muss der

=== Syntax ===
* nach den Ausdruck "input" folgt eine Klammer, die bei Ausführung des Programms ein Eingabefeld in der Console 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)

#Beispiel_2:
zahl=input("Gib hier diene Zahl ein: ")

print(zahl)

output
Gib hier deine Zahl ein: 3
3

* 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 Variablen wird also erst festgelegt, während das Programm läuft
* in der Console entsteht durch den ''input-Befehl'' ein „Eingabefeld“ (nicht direkt sichtbar) in das der Nutzer einen Wert (in Beispiel_1 eine Zahl) eintrage kann
* ACHTUNG!: jede Eingabe wird durch den input-Befehl automatisch als string gespeichert
* in Bespiel_3 wird die 3 in string-Form abgespeichert
* die Rechenoperation wird nicht als Multiplikation mit 2 verstanden sondern als Wiederholung des strings

#Beispiel_3:
zahl=input("Gib hier diene Zahl ein: ")
ergebnis= zahl*2
print(ergebnis)

output
Gib hier deine Zahl ein: 3
33

* der string 3 wird wiederholt und es kommt 33 statt 6 heraus
* Lösung: man kann den Datentyp des "inputs" vorab definieren:
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, dass in der Konsole, ein string wieder in Anführungszeichen gesetzt werden muss

#Beispiel_4:
zahl=eval(input("Gib hier diene 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

== ''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]]

== ''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 (die Funktionen der for-schleife wären zwar auch mit einer while schleifen lösbar, sind aber mit for schleifen deutlich einfacher zu lösen)
* 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]]

3.Befehle

2021-08-01T10:37:37Z

Mka: /* type-Befehl */

== ''print''-Befehl ==

#Befehl:
print()

#Beispiel:
print(“hello“)

output
hello

=== Funktion ===
* der entsprechende Inhalt des ''print''-Befehls wird in der Console ausgegeben

=== Syntax ===
* die runden Klammern dienen dazu den Anfang und das Ende der Ausgabe zu markieren
* 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

#Beipsiel_2:
print(falsch)

output
NameError: name 'falsch' is not defined

* Python geht davon aus das 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

== ''type''-Befehl ==

#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'>

===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 Varibalennamen
* 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 Console ausgegeben

== ''input'' -Befehl ==

#Befehl:
eingabe=input()

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

output
3 #eingegebene Zahl des Nutzers im Eingabefeld
3 #durch print-Befehl ausgegebene Zahl

=== 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
* gleichzeitig handelt es sich beim ''input''-Befehl auch um ein ''print''-Befehl, dazu muss der

=== Syntax ===
* nach den Ausdruck "input" folgt eine Klammer, die bei Ausführung des Programms ein Eingabefeld in der Console 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)

#Beispiel_2:
zahl=input("Gib hier diene Zahl ein: ")

print(zahl)

output
Gib hier deine Zahl ein: 3
3

* 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 Variablen wird also erst festgelegt, während das Programm läuft
* in der Console entsteht durch den ''input-Befehl'' ein „Eingabefeld“ (nicht direkt sichtbar) in das der Nutzer einen Wert (in Beispiel_1 eine Zahl) eintrage kann
* ACHTUNG!: jede Eingabe wird durch den input-Befehl automatisch als string gespeichert
* in Bespiel_3 wird die 3 in string-Form abgespeichert
* die Rechenoperation wird nicht als Multiplikation mit 2 verstanden sondern als Wiederholung des strings

#Beispiel_3:
zahl=input("Gib hier diene Zahl ein: ")
ergebnis= zahl*2
print(ergebnis)

output
Gib hier deine Zahl ein: 3
33

* der string 3 wird wiederholt und es kommt 33 statt 6 heraus
* Lösung: man kann den Datentyp des "inputs" vorab definieren:
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, dass ein string wieder in Anführungszeichen gesetzt werden muss

#Beispiel_4:
zahl=eval(input("Gib hier diene 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

== ''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]]

== ''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 (die Funktionen der for-schleife wären zwar auch mit einer while schleifen lösbar, sind aber mit for schleifen deutlich einfacher zu lösen)
* 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]]

2.Datentypen und Datenstrukturen

2021-08-01T10:34:49Z

Mka: /* 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.

== 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 erleichtert vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheide sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

#Befehl:
liste= ["string",variable,1, 2.0,True]

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

print(tier_1)
print(tier_2)
print(tier_3)

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

==== Funktion ====
* haben dieselbe Funktion wie Listen im realen Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht ein Programmcode ü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 Klammer gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können alle unterschiedlichen Datentypen 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: bei Python wird das Zählen bei 0 gestartet, d.h. das erste Element in der Liste besitzt die Position 0
* 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 Bereich der Liste ausgeben, wobei die Positionen der Elemente durch ein Doppelzeichen getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein,welche ausgegeben wird
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird
* 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

#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]

===== 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, sowie 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)

#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]

====== Element zur 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)

#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']

====== 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')

2.Datentypen und Datenstrukturen

2021-08-01T10:33:25Z

Mka: /* Element in Dictionary verändern */

__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.

== 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 erleichtert vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheide sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

#Befehl:
liste= ["string",variable,1, 2.0,True]

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

print(tier_1)
print(tier_2)
print(tier_3)

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

==== Funktion ====
* haben dieselbe Funktion wie Listen im realen Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht ein Programmcode ü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 Klammer gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können alle unterschiedlichen Datentypen 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: bei Python wird das Zählen bei 0 gestartet, d.h. das erste Element in der Liste besitzt die Position 0
* 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 Bereich der Liste ausgeben, wobei die Positionen der Elemente durch ein Doppelzeichen getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein,welche ausgegeben wird
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird
* 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

#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]

===== 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, sowie 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)

#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]

====== Element zur 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)

#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']

====== 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')

2.Datentypen und Datenstrukturen

2021-08-01T10:32:21Z

Mka: /* 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.

== 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 erleichtert vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheide sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

#Befehl:
liste= ["string",variable,1, 2.0,True]

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

print(tier_1)
print(tier_2)
print(tier_3)

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

==== Funktion ====
* haben dieselbe Funktion wie Listen im realen Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht ein Programmcode ü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 Klammer gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können alle unterschiedlichen Datentypen 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: bei Python wird das Zählen bei 0 gestartet, d.h. das erste Element in der Liste besitzt die Position 0
* 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 Bereich der Liste ausgeben, wobei die Positionen der Elemente durch ein Doppelzeichen getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein,welche ausgegeben wird
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird
* 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

#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]

===== 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, sowie 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)

#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]

====== Element zur 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)

#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']

====== 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')

2.Datentypen und Datenstrukturen

2021-08-01T10:29:01Z

Mka: /* 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.

== 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 erleichtert vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheide sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

#Befehl:
liste= ["string",variable,1, 2.0,True]

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

print(tier_1)
print(tier_2)
print(tier_3)

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

==== Funktion ====
* haben dieselbe Funktion wie Listen im realen Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht ein Programmcode ü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 Klammer gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können alle unterschiedlichen Datentypen 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: bei Python wird das Zählen bei 0 gestartet, d.h. das erste Element in der Liste besitzt die Position 0
* 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 Bereich der Liste ausgeben, wobei die Positionen der Elemente durch ein Doppelzeichen getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein,welche ausgegeben wird
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird
* 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

#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]

===== 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, sowie 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)

#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]

====== Element zur 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)

#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']

====== 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[0])
print(alle_tiere[0][0])

output
['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')

2.Datentypen und Datenstrukturen

2021-08-01T10:28:40Z

Mka: /* Element zur Liste hinzufügen */

__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.

== 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 erleichtert vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheide sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

#Befehl:
liste= ["string",variable,1, 2.0,True]

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

print(tier_1)
print(tier_2)
print(tier_3)

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

==== Funktion ====
* haben dieselbe Funktion wie Listen im realen Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht ein Programmcode ü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 Klammer gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können alle unterschiedlichen Datentypen 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: bei Python wird das Zählen bei 0 gestartet, d.h. das erste Element in der Liste besitzt die Position 0
* 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 Bereich der Liste ausgeben, wobei die Positionen der Elemente durch ein Doppelzeichen getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein,welche ausgegeben wird
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird
* 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

#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]

===== 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, sowie 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)

#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]

====== Element zur 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)

#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']

====== 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[0])
print(alle_tiere[0][0])

output
['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')

2.Datentypen und Datenstrukturen

2021-08-01T10:28:16Z

Mka: /* Element zur Liste hinzufügen */

__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.

== 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 erleichtert vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheide sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

#Befehl:
liste= ["string",variable,1, 2.0,True]

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

print(tier_1)
print(tier_2)
print(tier_3)

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

==== Funktion ====
* haben dieselbe Funktion wie Listen im realen Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht ein Programmcode ü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 Klammer gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können alle unterschiedlichen Datentypen 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: bei Python wird das Zählen bei 0 gestartet, d.h. das erste Element in der Liste besitzt die Position 0
* 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 Bereich der Liste ausgeben, wobei die Positionen der Elemente durch ein Doppelzeichen getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein,welche ausgegeben wird
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird
* 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

#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]

===== 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, sowie 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)

#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]

====== Element zur 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)

#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']

====== 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[0])
print(alle_tiere[0][0])

output
['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')

2.Datentypen und Datenstrukturen

2021-08-01T10:27:58Z

Mka: /* Element zur Liste hinzufügen */

__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.

== 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 erleichtert vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheide sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

#Befehl:
liste= ["string",variable,1, 2.0,True]

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

print(tier_1)
print(tier_2)
print(tier_3)

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

==== Funktion ====
* haben dieselbe Funktion wie Listen im realen Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht ein Programmcode ü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 Klammer gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können alle unterschiedlichen Datentypen 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: bei Python wird das Zählen bei 0 gestartet, d.h. das erste Element in der Liste besitzt die Position 0
* 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 Bereich der Liste ausgeben, wobei die Positionen der Elemente durch ein Doppelzeichen getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein,welche ausgegeben wird
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird
* 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

#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]

===== 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, sowie 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)

#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]

====== Element zur 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)

#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']

====== 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[0])
print(alle_tiere[0][0])

output
['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')

2.Datentypen und Datenstrukturen

2021-08-01T10:25:15Z

Mka: /* Element in Liste verändern */

__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.

== 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 erleichtert vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheide sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

#Befehl:
liste= ["string",variable,1, 2.0,True]

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

print(tier_1)
print(tier_2)
print(tier_3)

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

==== Funktion ====
* haben dieselbe Funktion wie Listen im realen Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht ein Programmcode ü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 Klammer gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können alle unterschiedlichen Datentypen 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: bei Python wird das Zählen bei 0 gestartet, d.h. das erste Element in der Liste besitzt die Position 0
* 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 Bereich der Liste ausgeben, wobei die Positionen der Elemente durch ein Doppelzeichen getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein,welche ausgegeben wird
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird
* 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

#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]

===== 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, sowie 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)

#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]

====== Element zur 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)

#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']

====== 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[0])
print(alle_tiere[0][0])

output
['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')

2.Datentypen und Datenstrukturen

2021-08-01T10:23:31Z

Mka: /* Element in Liste verändern */

__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.

== 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 erleichtert vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheide sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

#Befehl:
liste= ["string",variable,1, 2.0,True]

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

print(tier_1)
print(tier_2)
print(tier_3)

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

==== Funktion ====
* haben dieselbe Funktion wie Listen im realen Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht ein Programmcode ü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 Klammer gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können alle unterschiedlichen Datentypen 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: bei Python wird das Zählen bei 0 gestartet, d.h. das erste Element in der Liste besitzt die Position 0
* 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 Bereich der Liste ausgeben, wobei die Positionen der Elemente durch ein Doppelzeichen getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein,welche ausgegeben wird
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird
* 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

#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]

===== 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, sowie 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)

#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]

====== Element zur 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)

#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']

====== 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[0])
print(alle_tiere[0][0])

output
['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')

2.Datentypen und Datenstrukturen

2021-08-01T10:23:12Z

Mka: /* Element in Liste verändern */

__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.

== 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 erleichtert vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheide sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

#Befehl:
liste= ["string",variable,1, 2.0,True]

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

print(tier_1)
print(tier_2)
print(tier_3)

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

==== Funktion ====
* haben dieselbe Funktion wie Listen im realen Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht ein Programmcode ü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 Klammer gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können alle unterschiedlichen Datentypen 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: bei Python wird das Zählen bei 0 gestartet, d.h. das erste Element in der Liste besitzt die Position 0
* 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 Bereich der Liste ausgeben, wobei die Positionen der Elemente durch ein Doppelzeichen getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein,welche ausgegeben wird
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird
* 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

#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]

===== 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, sowie 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)

#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]

====== Element zur 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)

#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']

====== 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[0])
print(alle_tiere[0][0])

output
['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')

2.Datentypen und Datenstrukturen

2021-08-01T10:21:32Z

Mka: /* Bereich der Liste ausgeben lassen */

__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.

== 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 erleichtert vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheide sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

#Befehl:
liste= ["string",variable,1, 2.0,True]

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

print(tier_1)
print(tier_2)
print(tier_3)

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

==== Funktion ====
* haben dieselbe Funktion wie Listen im realen Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht ein Programmcode ü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 Klammer gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können alle unterschiedlichen Datentypen 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: bei Python wird das Zählen bei 0 gestartet, d.h. das erste Element in der Liste besitzt die Position 0
* 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 Bereich der Liste ausgeben, wobei die Positionen der Elemente durch ein Doppelzeichen getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein,welche ausgegeben wird
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird
* 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

#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]

===== 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, sowie 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)

#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]

====== Element zur 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)

#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']

====== 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[0])
print(alle_tiere[0][0])

output
['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')

2.Datentypen und Datenstrukturen

2021-08-01T10:17:44Z

Mka: /* Liste ausgeben lassen */

__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.

== 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 erleichtert vor allem die Handhabung größerer Datenmengen,
indem sie diese in geeigneter Form darstellen und speichern.
Sie unterscheide sich jedoch in ihrem Aufbau und ihren spezifischen Funktionen.

=== Listen ===

#Befehl:
liste= ["string",variable,1, 2.0,True]

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

print(tier_1)
print(tier_2)
print(tier_3)

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

==== Funktion ====
* haben dieselbe Funktion wie Listen im realen Leben
* mit Listen können mehrere Werte unter einem Namen abgespeichert werden
* macht ein Programmcode ü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 Klammer gesetzt und müssen mit einem Komma voneinander getrennt werden
* in einer Liste können alle unterschiedlichen Datentypen 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: bei Python wird das Zählen bei 0 gestartet, d.h. das erste Element in der Liste besitzt die Position 0
* 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 Bereich der Liste ausgeben, wobei die Positionen der Elemente durch ein Doppelzeichen getrennt werden (s.Beispiel_2)
* die erste Indexzahl schließt die Position des Elements ein,welche ausgegeben wird
* die zweite gibt die Position des Elements an, welches nicht mehr im Bereich liegt und demnach nicht ausgegeben wird
* 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

#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]
['Hund', 100, 399, 99]

===== 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, sowie 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)

#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]

====== Element zur 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)

#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']

====== 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[0])
print(alle_tiere[0][0])

output
['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')

Main Page

2021-08-01T10:14:00Z

Mka:

Main Page

2021-08-01T10:10:50Z

Mka: /* Bioinformatik Grundkurs */

Main Page

2021-08-01T10:00:26Z

Mka:

6 Normalisierungen

2021-06-08T11:34:34Z

Mka: /* RPKM */

=Normalisierungen=
Normalisierungen der RNASeq-Daten sind notwendig, um diese vergleichbar machen zu können und die tatsächliche Genexpression quantifizieren zu können.
==RPKM==
RPKM steht für 'Reads per kilobase of transcript per Million mapped reads' und ist eine Normalisierungsmethode für Expressionsstärken. 
{| class="wikitable"
|-
! Formel !! Parameter
|-
| <math> RPKM = \frac{ c_\text{i}}{L_\text{i} \cdot N} </math> || ci = Anzahl an ausrichtbaren reads für ein Transkript 'i'
Li = Länge des Transkripts/Gens 'i' in kbp 
N = Gesamtanzahl an ausrichtbaren reads in Millionen
|}

<math> \frac{ c_\text{i}}{L_\text{i}} </math> → Normalisierung der Genlänge 
<math> L_\text{i} \cdot N </math> → Normalisierung der Sequenziertiefe
Je höher der RPKM-Wert ist, desto höher ist die Genexpression. 
RPKM-Werte können gut zum Vergleich der Genexpressionen innerhalb einer Probe genutzt werden, jedoch sind sie nicht dafür geeignet mehrere Experimente bzw. Proben miteinander zu vergleichen.

'''Beispiel:'''

[[File:Beispiel Probe.png|Beispiel Probe]] 
<math> N=6*10^6 reads </math> 

* <math> RPKM (A) = \frac{12}{0,6 kbp \cdot 6 \cdot 10^6} = 3,33 \cdot 10^{-6} </math> 

* <math> RPKM (B) = \frac{24}{1,1 kbp \cdot 6 \cdot 10^6} = 3,64 \cdot 10^{-6} </math> 

* <math> RPKM (C) = \frac{11}{1,4 kbp \cdot 6 \cdot 10^6} = 1,31 \cdot 10^{-6} </math> 

Durch die Normalisierung der Expressionsstärken können diese nun miteinander vergleichen werden.In diesem Beispiel wird Gen B am stärksten exprimiert und Gen C am schwächsten.

==TPM==
TPM steht für 'Transcripts per Million' und ist eine Normalisierungsmethode für Expressionsstärken. 

{| class="wikitable"
|-
! Formel !! Parameter
|-
|<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> || 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
|}
Wenn 1 Millionen Transkripte sequenziert würden, wäre TPMi die Anzahl an Transkripten des Types 'i'. 

'''Beispiel:''' 
[[File:Beispiel Probe.png|Beispiel Probe]] 

*<math> TPM (A) = \frac{ 12}{600} \cdot \dfrac {1}{ \dfrac {12}{600} + \dfrac {24}{1100} + \dfrac {11}{1400}} \cdot 10^6 = 402614 </math> 

*<math> TPM (B) = \frac{ 24}{1100} \cdot \dfrac {1}{ \dfrac {12}{600} + \dfrac {24}{1100} + \dfrac {11}{1400}} \cdot 10^6 = 439216 </math> 

*<math> TPM (C) = \frac{ 11}{1400} \cdot \dfrac {1}{ \dfrac {12}{600} + \dfrac {24}{1100} + \dfrac {11}{1400}} \cdot 10^6 = 158170 </math> 

Nach der Normalisierung ist ein Vergleich der Genexpressionen möglich. Das Ergebnis gibt an, wie viele Transkripte der Gene entstehen würden, wenn 1 Millionen Transkripte sequenziert werden würden. So würde man z.B. für Gen B 429216 Transkripte erhalten und für Gen C 158170 Transkripte, somit wird Gen B stärker exprimiert, als Gen C. Die Summe der reads ergibt 1 Million.

'''Probleme von RPKM und TPM:'''

Die beiden Methoden sind nur gut geeignet, um Expressionswerte bzw. Expressionslevel innerhalb einer Probe zu vergleichen.Von sehr heterologen Expressionsprofilen zwischen zwei Proben können identische Genexpressionen fälschlicherweise als unterschiedlich erkannt werden.

Lösung: TMM als Normalisierungsmethode zwischen Proben

==TMM==
TMM steht für 'Trimmed mean of M-values normalization method'. 
*Gesamtexpressionsstärke pro Probe wird bestimmt, um einzelne Genexpressionen zu bestimmen.
*Das Expressionsverhältnis zwischen zwei Bedingungen für ein Gen 'g' wird bestimmt.
*Genexpressionen von zwei Proben mit unterschiedlichen Bedingungen (z.B. krank und gesund) können miteinander verglichen werden. 

'''1.''' Bestimmung des '''Gewichtungsfaktors''' für das Expressionsverhältnis für Gen 'g' zwischen Probe 'k' ' und 'k'. 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. 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. Gewichtete Mittelwerte aller Expressionsverhältnisse''' können berechnet werden. Einsetzen der in 1. und 2. ermittelten Werte. 
<div align="center"> <math> TMM = 2^{log_2 (TMM_\text{k}^\text{k`})} </math></div> 

'''Gesamt:'''
{| 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 = Set 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

== Beispielrechnung ==
Gen Zustand 1[bp] Zustand 2[bp]
A 200 600
B 600 0
C 800 960
D 400 480

Summe 2000 1680

Folgende Dinge gelten nun:
* TMM braucht immer einen Referenzwert (hier: Zustand 1); Wenn man mehrere Proben hätte, könnte man diese alle an Zustand 1 messen.

* Zuerst normalisiert man die Counts innerhalb der Probe
Ya/N Yb/N 
A <math>\frac{200}{2000}=0,1</math> <math>\frac{240}{1680}=0,143</math> 
B <math>\frac{600}{2000}=0,3</math> <math>\frac{0}{1680}=0</math> 
C <math>\frac{800}{2000}=0,4</math> <math>\frac{960}{1680}=0,571</math> 
D <math>\frac{400}{2000}=0,2</math> <math>\frac{2480}{1680}=0,286</math>

* Mittelwert der Expressionsverhältnisse
Ma/b
A <math>log_{2} \frac{0,143}{0,1}=0,516</math> 
B <math>log_{2} \frac{0}{0,3}= -Inf </math> 
C <math>log_{2} \frac{0,571}{0,4}=0,513</math> 
D <math>log_{2} \frac{0,286}{0,2}=0,516</math> 
*'''kleiner Praxistipp von eurem Admin''': <math>log_{2}</math> ist der Logarithmus von 2, Es ist nicht der natürliche log, es ist nicht ln, es ist nichts mit eulerscher Zahl oder was eure Taschenrechner sonst noch so hergeben. Also sucht eine Funktion, in der ihr die Basis des log eintragen könnt und gebt dort eine 2 ein.

*Nun kommt der Gewichtungsfaktor ins Spiel
Wa/b
A <math> \frac{1680-240}{1680*240} + \frac{2000-200}{2000*200}=0,081</math> 
B <math> \frac{1680-0}{1680*0} + \frac{2000-600}{2000*600}= -Inf </math> 
C <math> \frac{1680-960}{1680*960} + \frac{2000-800}{2000*800}=0,0012</math> 
D <math> \frac{1680-480}{1680*480} + \frac{2000-400}{2000*400}=0,0035</math> 
'''Summe der Gewichtung 0,0128'''

*Nun werden die Mittelwerte der Expressionsverhältnisse gewichtet (durch den Gewichtungsfaktor)

A 0,516 * 0,081 = 0,0042
B -
C 0,513 * 0,0012 = 0,0006
D 0,516 * 0,0018 = 0,0018
Summe 0,0066

Nun wird TMM berechnet: 
<math>\frac{\text{Summe der gewichteten Mittelwerte der Expressionsverhältnisse}}{\text{Summe Gewichtungsfaktoren}}=log_{2}(TMM)</math>

<math>\frac{0,0066}{0,0128}=0,51=log_{2}(TMM)</math> 
* Jetzt noch die Formel umsetzen:
<math>log_{2}(TMM)= x</math>
<math>2^{x} = TMM </math>
<math>2^{0,51} = 1,4296 </math>

6 Normalisierungen

2021-06-08T11:12:45Z

Mka: /* RPKM */

=Normalisierungen=
Normalisierungen der RNASeq-Daten sind notwendig, um diese vergleichbar machen zu können und die tatsächliche Genexpression quantifizieren zu können.
==RPKM==
RPKM steht für 'Reads per kilobase of transcript per Million mapped reads' und ist eine Normalisierungsmethode für Expressionsstärken. 
{| class="wikitable"
|-
! Formel !! Parameter
|-
| <math> RPKM = \frac{ c_\text{i}}{L_\text{i} \cdot N}{ * 10^6} </math> || ci = Anzahl an ausrichtbaren reads für ein Transkript 'i'
Li = Länge des Transkripts/Gens 'i' in kbp 
N = Gesamtanzahl an ausrichtbaren reads in Millionen
|}

<math> \frac{ c_\text{i}}{L_\text{i}} </math> → Normalisierung der Genlänge 
<math> L_\text{i} \cdot N </math> → Normalisierung der Sequenziertiefe
Je höher der RPKM-Wert ist, desto höher ist die Genexpression. 
RPKM-Werte können gut zum Vergleich der Genexpressionen innerhalb einer Probe genutzt werden, jedoch sind sie nicht dafür geeignet mehrere Experimente bzw. Proben miteinander zu vergleichen.

'''Beispiel:'''

[[File:Beispiel Probe.png|Beispiel Probe]] 
<math> N=6*10^6 reads </math> 

* <math> RPKM (A) = \frac{12}{0,6 kbp \cdot 6 \cdot 10^6} = 3,33 \cdot 10^{-6} </math> 

* <math> RPKM (B) = \frac{24}{1,1 kbp \cdot 6 \cdot 10^6} = 3,64 \cdot 10^{-6} </math> 

* <math> RPKM (C) = \frac{11}{1,4 kbp \cdot 6 \cdot 10^6} = 1,31 \cdot 10^{-6} </math> 

Durch die Normalisierung der Expressionsstärken können diese nun miteinander vergleichen werden.In diesem Beispiel wird Gen B am stärksten exprimiert und Gen C am schwächsten.

==TPM==
TPM steht für 'Transcripts per Million' und ist eine Normalisierungsmethode für Expressionsstärken. 

{| class="wikitable"
|-
! Formel !! Parameter
|-
|<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> || 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
|}
Wenn 1 Millionen Transkripte sequenziert würden, wäre TPMi die Anzahl an Transkripten des Types 'i'. 

'''Beispiel:''' 
[[File:Beispiel Probe.png|Beispiel Probe]] 

*<math> TPM (A) = \frac{ 12}{600} \cdot \dfrac {1}{ \dfrac {12}{600} + \dfrac {24}{1100} + \dfrac {11}{1400}} \cdot 10^6 = 402614 </math> 

*<math> TPM (B) = \frac{ 24}{1100} \cdot \dfrac {1}{ \dfrac {12}{600} + \dfrac {24}{1100} + \dfrac {11}{1400}} \cdot 10^6 = 439216 </math> 

*<math> TPM (C) = \frac{ 11}{1400} \cdot \dfrac {1}{ \dfrac {12}{600} + \dfrac {24}{1100} + \dfrac {11}{1400}} \cdot 10^6 = 158170 </math> 

Nach der Normalisierung ist ein Vergleich der Genexpressionen möglich. Das Ergebnis gibt an, wie viele Transkripte der Gene entstehen würden, wenn 1 Millionen Transkripte sequenziert werden würden. So würde man z.B. für Gen B 429216 Transkripte erhalten und für Gen C 158170 Transkripte, somit wird Gen B stärker exprimiert, als Gen C. Die Summe der reads ergibt 1 Million.

'''Probleme von RPKM und TPM:'''

Die beiden Methoden sind nur gut geeignet, um Expressionswerte bzw. Expressionslevel innerhalb einer Probe zu vergleichen.Von sehr heterologen Expressionsprofilen zwischen zwei Proben können identische Genexpressionen fälschlicherweise als unterschiedlich erkannt werden.

Lösung: TMM als Normalisierungsmethode zwischen Proben

==TMM==
TMM steht für 'Trimmed mean of M-values normalization method'. 
*Gesamtexpressionsstärke pro Probe wird bestimmt, um einzelne Genexpressionen zu bestimmen.
*Das Expressionsverhältnis zwischen zwei Bedingungen für ein Gen 'g' wird bestimmt.
*Genexpressionen von zwei Proben mit unterschiedlichen Bedingungen (z.B. krank und gesund) können miteinander verglichen werden. 

'''1.''' Bestimmung des '''Gewichtungsfaktors''' für das Expressionsverhältnis für Gen 'g' zwischen Probe 'k' ' und 'k'. 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. 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. Gewichtete Mittelwerte aller Expressionsverhältnisse''' können berechnet werden. Einsetzen der in 1. und 2. ermittelten Werte. 
<div align="center"> <math> TMM = 2^{log_2 (TMM_\text{k}^\text{k`})} </math></div> 

'''Gesamt:'''
{| 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 = Set 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

== Beispielrechnung ==
Gen Zustand 1[bp] Zustand 2[bp]
A 200 600
B 600 0
C 800 960
D 400 480

Summe 2000 1680

Folgende Dinge gelten nun:
* TMM braucht immer einen Referenzwert (hier: Zustand 1); Wenn man mehrere Proben hätte, könnte man diese alle an Zustand 1 messen.

* Zuerst normalisiert man die Counts innerhalb der Probe
Ya/N Yb/N 
A <math>\frac{200}{2000}=0,1</math> <math>\frac{240}{1680}=0,143</math> 
B <math>\frac{600}{2000}=0,3</math> <math>\frac{0}{1680}=0</math> 
C <math>\frac{800}{2000}=0,4</math> <math>\frac{960}{1680}=0,571</math> 
D <math>\frac{400}{2000}=0,2</math> <math>\frac{2480}{1680}=0,286</math>

* Mittelwert der Expressionsverhältnisse
Ma/b
A <math>log_{2} \frac{0,143}{0,1}=0,516</math> 
B <math>log_{2} \frac{0}{0,3}= -Inf </math> 
C <math>log_{2} \frac{0,571}{0,4}=0,513</math> 
D <math>log_{2} \frac{0,286}{0,2}=0,516</math> 
*'''kleiner Praxistipp von eurem Admin''': <math>log_{2}</math> ist der Logarithmus von 2, Es ist nicht der natürliche log, es ist nicht ln, es ist nichts mit eulerscher Zahl oder was eure Taschenrechner sonst noch so hergeben. Also sucht eine Funktion, in der ihr die Basis des log eintragen könnt und gebt dort eine 2 ein.

*Nun kommt der Gewichtungsfaktor ins Spiel
Wa/b
A <math> \frac{1680-240}{1680*240} + \frac{2000-200}{2000*200}=0,081</math> 
B <math> \frac{1680-0}{1680*0} + \frac{2000-600}{2000*600}= -Inf </math> 
C <math> \frac{1680-960}{1680*960} + \frac{2000-800}{2000*800}=0,0012</math> 
D <math> \frac{1680-480}{1680*480} + \frac{2000-400}{2000*400}=0,0035</math> 
'''Summe der Gewichtung 0,0128'''

*Nun werden die Mittelwerte der Expressionsverhältnisse gewichtet (durch den Gewichtungsfaktor)

A 0,516 * 0,081 = 0,0042
B -
C 0,513 * 0,0012 = 0,0006
D 0,516 * 0,0018 = 0,0018
Summe 0,0066

Nun wird TMM berechnet: 
<math>\frac{\text{Summe der gewichteten Mittelwerte der Expressionsverhältnisse}}{\text{Summe Gewichtungsfaktoren}}=log_{2}(TMM)</math>

<math>\frac{0,0066}{0,0128}=0,51=log_{2}(TMM)</math> 
* Jetzt noch die Formel umsetzen:
<math>log_{2}(TMM)= x</math>
<math>2^{x} = TMM </math>
<math>2^{0,51} = 1,4296 </math>

Glossar

2021-01-31T19:50:53Z

Mka: /* T */

== A ==
[[3_Alignments#Alignments|Alignment]] 
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Algorithmus]] 
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Assembly]]

== B ==
[[7_Multiples_Testen#L.C3.B6sung_2:_Benjamini-Hochberg-Prozedur|Benjamini-Hochberg-Prozedur]] 
[[7_Multiples_Testen#L.C3.B6sung_1:_Bonferroni-Korrektur|Bonferroni-Korrektur]] 
[[4.Burrows-Wheeler|Burrows-Wheeler Transformation]]

== C ==
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Contiq]] 
[[2_Transkriptom_RNA_Seq_1#Sequenzabdeckung|Coverage]]

== D ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Dynamic programming]]

== E ==
== F ==
[[1_Datenbanken#FASTA|FASTA-Format]] 
[[2_Transkriptom_RNA_Seq_1#FASTQ|FASTQ-Format]]

== G ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|gap penalty]]

== H ==
== I ==
[[2_Transkriptom_RNA_Seq_1#Illumina_Sequencing_.282nd_Generation_Sequencing.29|Illumina]]

== J ==
== K ==
== L ==
[[2_Transkriptom_RNA_Seq_1#Lander-Waterman-Modell|Lander-Waterman-Modell]] 
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|Library]]

== M ==
[[Microarrays]]

== N ==
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|NGS]] 
[[7_Multiples_Testen#t-Test|Nullhypothese]]

== O ==
== P ==
[[7_Multiples_Testen#P-Wert|p-value]]

== Q ==
== R ==
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|reads]] 
[[RNAseq|RNASeq]] 
[[6_Normalisierungen#RPKM|RPKM]]

== S ==
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Scaffold]] 
[[3_Alignments#Smith-Waterman_Algorithmus|Smith-Waterman Algorithmus]]

== T ==
[[7_Multiples_Testen#t-Test|t-Test]] 
[[6_Normalisierungen#TMM|TMM]] 
[[6_Normalisierungen#TPM|TPM]] 
[[Transkriptom]]

== U ==
== V ==
== W ==
== X ==
== Y ==
== Z ==

Glossar

2021-01-31T19:48:19Z

Mka: /* S */

== A ==
[[3_Alignments#Alignments|Alignment]] 
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Algorithmus]] 
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Assembly]]

== B ==
[[7_Multiples_Testen#L.C3.B6sung_2:_Benjamini-Hochberg-Prozedur|Benjamini-Hochberg-Prozedur]] 
[[7_Multiples_Testen#L.C3.B6sung_1:_Bonferroni-Korrektur|Bonferroni-Korrektur]] 
[[4.Burrows-Wheeler|Burrows-Wheeler Transformation]]

== C ==
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Contiq]] 
[[2_Transkriptom_RNA_Seq_1#Sequenzabdeckung|Coverage]]

== D ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Dynamic programming]]

== E ==
== F ==
[[1_Datenbanken#FASTA|FASTA-Format]] 
[[2_Transkriptom_RNA_Seq_1#FASTQ|FASTQ-Format]]

== G ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|gap penalty]]

== H ==
== I ==
[[2_Transkriptom_RNA_Seq_1#Illumina_Sequencing_.282nd_Generation_Sequencing.29|Illumina]]

== J ==
== K ==
== L ==
[[2_Transkriptom_RNA_Seq_1#Lander-Waterman-Modell|Lander-Waterman-Modell]] 
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|Library]]

== M ==
[[Microarrays]]

== N ==
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|NGS]] 
[[7_Multiples_Testen#t-Test|Nullhypothese]]

== O ==
== P ==
[[7_Multiples_Testen#P-Wert|p-value]]

== Q ==
== R ==
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|reads]] 
[[RNAseq|RNASeq]] 
[[6_Normalisierungen#RPKM|RPKM]]

== S ==
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Scaffold]] 
[[3_Alignments#Smith-Waterman_Algorithmus|Smith-Waterman Algorithmus]]

== T ==
[[t-Test]] 
[[TMM]] 
[[TPM]] 
[[Transkriptom]]

== U ==
== V ==
== W ==
== X ==
== Y ==
== Z ==

Glossar

2021-01-31T19:46:44Z

Mka: /* R */

== A ==
[[3_Alignments#Alignments|Alignment]] 
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Algorithmus]] 
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Assembly]]

== B ==
[[7_Multiples_Testen#L.C3.B6sung_2:_Benjamini-Hochberg-Prozedur|Benjamini-Hochberg-Prozedur]] 
[[7_Multiples_Testen#L.C3.B6sung_1:_Bonferroni-Korrektur|Bonferroni-Korrektur]] 
[[4.Burrows-Wheeler|Burrows-Wheeler Transformation]]

== C ==
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Contiq]] 
[[2_Transkriptom_RNA_Seq_1#Sequenzabdeckung|Coverage]]

== D ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Dynamic programming]]

== E ==
== F ==
[[1_Datenbanken#FASTA|FASTA-Format]] 
[[2_Transkriptom_RNA_Seq_1#FASTQ|FASTQ-Format]]

== G ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|gap penalty]]

== H ==
== I ==
[[2_Transkriptom_RNA_Seq_1#Illumina_Sequencing_.282nd_Generation_Sequencing.29|Illumina]]

== J ==
== K ==
== L ==
[[2_Transkriptom_RNA_Seq_1#Lander-Waterman-Modell|Lander-Waterman-Modell]] 
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|Library]]

== M ==
[[Microarrays]]

== N ==
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|NGS]] 
[[7_Multiples_Testen#t-Test|Nullhypothese]]

== O ==
== P ==
[[7_Multiples_Testen#P-Wert|p-value]]

== Q ==
== R ==
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|reads]] 
[[RNAseq|RNASeq]] 
[[6_Normalisierungen#RPKM|RPKM]]

== S ==
[[Scaffold]] 
[[Smith-Waterman Algorithmus]]
== T ==
[[t-Test]] 
[[TMM]] 
[[TPM]] 
[[Transkriptom]]

== U ==
== V ==
== W ==
== X ==
== Y ==
== Z ==

Glossar

2021-01-31T19:44:58Z

Mka: /* P */

== A ==
[[3_Alignments#Alignments|Alignment]] 
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Algorithmus]] 
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Assembly]]

== B ==
[[7_Multiples_Testen#L.C3.B6sung_2:_Benjamini-Hochberg-Prozedur|Benjamini-Hochberg-Prozedur]] 
[[7_Multiples_Testen#L.C3.B6sung_1:_Bonferroni-Korrektur|Bonferroni-Korrektur]] 
[[4.Burrows-Wheeler|Burrows-Wheeler Transformation]]

== C ==
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Contiq]] 
[[2_Transkriptom_RNA_Seq_1#Sequenzabdeckung|Coverage]]

== D ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Dynamic programming]]

== E ==
== F ==
[[1_Datenbanken#FASTA|FASTA-Format]] 
[[2_Transkriptom_RNA_Seq_1#FASTQ|FASTQ-Format]]

== G ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|gap penalty]]

== H ==
== I ==
[[2_Transkriptom_RNA_Seq_1#Illumina_Sequencing_.282nd_Generation_Sequencing.29|Illumina]]

== J ==
== K ==
== L ==
[[2_Transkriptom_RNA_Seq_1#Lander-Waterman-Modell|Lander-Waterman-Modell]] 
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|Library]]

== M ==
[[Microarrays]]

== N ==
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|NGS]] 
[[7_Multiples_Testen#t-Test|Nullhypothese]]

== O ==
== P ==
[[7_Multiples_Testen#P-Wert|p-value]]

== Q ==
== R ==
[[reads]] 
[[RNASeq]] 
[[RPKM]]

== S ==
[[Scaffold]] 
[[Smith-Waterman Algorithmus]]
== T ==
[[t-Test]] 
[[TMM]] 
[[TPM]] 
[[Transkriptom]]

== U ==
== V ==
== W ==
== X ==
== Y ==
== Z ==

Glossar

2021-01-31T19:44:30Z

Mka: /* N */

== A ==
[[3_Alignments#Alignments|Alignment]] 
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Algorithmus]] 
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Assembly]]

== B ==
[[7_Multiples_Testen#L.C3.B6sung_2:_Benjamini-Hochberg-Prozedur|Benjamini-Hochberg-Prozedur]] 
[[7_Multiples_Testen#L.C3.B6sung_1:_Bonferroni-Korrektur|Bonferroni-Korrektur]] 
[[4.Burrows-Wheeler|Burrows-Wheeler Transformation]]

== C ==
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Contiq]] 
[[2_Transkriptom_RNA_Seq_1#Sequenzabdeckung|Coverage]]

== D ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Dynamic programming]]

== E ==
== F ==
[[1_Datenbanken#FASTA|FASTA-Format]] 
[[2_Transkriptom_RNA_Seq_1#FASTQ|FASTQ-Format]]

== G ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|gap penalty]]

== H ==
== I ==
[[2_Transkriptom_RNA_Seq_1#Illumina_Sequencing_.282nd_Generation_Sequencing.29|Illumina]]

== J ==
== K ==
== L ==
[[2_Transkriptom_RNA_Seq_1#Lander-Waterman-Modell|Lander-Waterman-Modell]] 
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|Library]]

== M ==
[[Microarrays]]

== N ==
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|NGS]] 
[[7_Multiples_Testen#t-Test|Nullhypothese]]

== O ==
== P ==
[[p-value]]
== Q ==
== R ==
[[reads]] 
[[RNASeq]] 
[[RPKM]]

== S ==
[[Scaffold]] 
[[Smith-Waterman Algorithmus]]
== T ==
[[t-Test]] 
[[TMM]] 
[[TPM]] 
[[Transkriptom]]

== U ==
== V ==
== W ==
== X ==
== Y ==
== Z ==

Glossar

2021-01-31T19:40:48Z

Mka: /* M */

== A ==
[[3_Alignments#Alignments|Alignment]] 
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Algorithmus]] 
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Assembly]]

== B ==
[[7_Multiples_Testen#L.C3.B6sung_2:_Benjamini-Hochberg-Prozedur|Benjamini-Hochberg-Prozedur]] 
[[7_Multiples_Testen#L.C3.B6sung_1:_Bonferroni-Korrektur|Bonferroni-Korrektur]] 
[[4.Burrows-Wheeler|Burrows-Wheeler Transformation]]

== C ==
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Contiq]] 
[[2_Transkriptom_RNA_Seq_1#Sequenzabdeckung|Coverage]]

== D ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Dynamic programming]]

== E ==
== F ==
[[1_Datenbanken#FASTA|FASTA-Format]] 
[[2_Transkriptom_RNA_Seq_1#FASTQ|FASTQ-Format]]

== G ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|gap penalty]]

== H ==
== I ==
[[2_Transkriptom_RNA_Seq_1#Illumina_Sequencing_.282nd_Generation_Sequencing.29|Illumina]]

== J ==
== K ==
== L ==
[[2_Transkriptom_RNA_Seq_1#Lander-Waterman-Modell|Lander-Waterman-Modell]] 
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|Library]]

== M ==
[[Microarrays]]

== N ==
[[NGS]] 
[[Nullhypothese]]
== O ==
== P ==
[[p-value]]
== Q ==
== R ==
[[reads]] 
[[RNASeq]] 
[[RPKM]]

== S ==
[[Scaffold]] 
[[Smith-Waterman Algorithmus]]
== T ==
[[t-Test]] 
[[TMM]] 
[[TPM]] 
[[Transkriptom]]

== U ==
== V ==
== W ==
== X ==
== Y ==
== Z ==

Glossar

2021-01-31T19:40:01Z

Mka: /* L */

== A ==
[[3_Alignments#Alignments|Alignment]] 
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Algorithmus]] 
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Assembly]]

== B ==
[[7_Multiples_Testen#L.C3.B6sung_2:_Benjamini-Hochberg-Prozedur|Benjamini-Hochberg-Prozedur]] 
[[7_Multiples_Testen#L.C3.B6sung_1:_Bonferroni-Korrektur|Bonferroni-Korrektur]] 
[[4.Burrows-Wheeler|Burrows-Wheeler Transformation]]

== C ==
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Contiq]] 
[[2_Transkriptom_RNA_Seq_1#Sequenzabdeckung|Coverage]]

== D ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Dynamic programming]]

== E ==
== F ==
[[1_Datenbanken#FASTA|FASTA-Format]] 
[[2_Transkriptom_RNA_Seq_1#FASTQ|FASTQ-Format]]

== G ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|gap penalty]]

== H ==
== I ==
[[2_Transkriptom_RNA_Seq_1#Illumina_Sequencing_.282nd_Generation_Sequencing.29|Illumina]]

== J ==
== K ==
== L ==
[[2_Transkriptom_RNA_Seq_1#Lander-Waterman-Modell|Lander-Waterman-Modell]] 
[[2.Transkriptom_RNA_Seq_1#Aufgabe_1:_Definitionen|Library]]

== M ==
[[Microarrays]]
== N ==
[[NGS]] 
[[Nullhypothese]]
== O ==
== P ==
[[p-value]]
== Q ==
== R ==
[[reads]] 
[[RNASeq]] 
[[RPKM]]

== S ==
[[Scaffold]] 
[[Smith-Waterman Algorithmus]]
== T ==
[[t-Test]] 
[[TMM]] 
[[TPM]] 
[[Transkriptom]]

== U ==
== V ==
== W ==
== X ==
== Y ==
== Z ==

Glossar

2021-01-31T19:38:52Z

Mka: /* I */

== A ==
[[3_Alignments#Alignments|Alignment]] 
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Algorithmus]] 
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Assembly]]

== B ==
[[7_Multiples_Testen#L.C3.B6sung_2:_Benjamini-Hochberg-Prozedur|Benjamini-Hochberg-Prozedur]] 
[[7_Multiples_Testen#L.C3.B6sung_1:_Bonferroni-Korrektur|Bonferroni-Korrektur]] 
[[4.Burrows-Wheeler|Burrows-Wheeler Transformation]]

== C ==
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Contiq]] 
[[2_Transkriptom_RNA_Seq_1#Sequenzabdeckung|Coverage]]

== D ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Dynamic programming]]

== E ==
== F ==
[[1_Datenbanken#FASTA|FASTA-Format]] 
[[2_Transkriptom_RNA_Seq_1#FASTQ|FASTQ-Format]]

== G ==
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|gap penalty]]

== H ==
== I ==
[[2_Transkriptom_RNA_Seq_1#Illumina_Sequencing_.282nd_Generation_Sequencing.29|Illumina]]

== J ==
== K ==
== L ==
[[Lander-Waterman-Modell]] 
[[Library]]
== M ==
[[Microarrays]]
== N ==
[[NGS]] 
[[Nullhypothese]]
== O ==
== P ==
[[p-value]]
== Q ==
== R ==
[[reads]] 
[[RNASeq]] 
[[RPKM]]

== S ==
[[Scaffold]] 
[[Smith-Waterman Algorithmus]]
== T ==
[[t-Test]] 
[[TMM]] 
[[TPM]] 
[[Transkriptom]]

== U ==
== V ==
== W ==
== X ==
== Y ==
== Z ==

Glossar

2021-01-31T19:38:22Z

Mka: /* G */

Glossar

2021-01-31T19:37:02Z

Mka: /* F */

Glossar

2021-01-31T19:35:37Z

Mka: /* D */

Glossar

2021-01-31T19:33:43Z

Mka: /* C */

Glossar

2021-01-31T19:30:41Z

Mka: /* B */

Glossar

2021-01-31T19:28:26Z

Mka: /* A */

== A ==
[[3_Alignments#Alignments|Alignment]] 
[[3.Smith-Waterman#Aufgabe_1:_Definitionen|Algorithmus]] 
[[2_Transkriptom_RNA_Seq_1#Assemblierung_der_reads|Assembly]]

== B ==
[[Benjamini-Hochberg-Prozedur]] 
[[Bonferroni-Korrektur]] 
[[Burrows-Wheeler Transformation]]
== C ==
[[Contiq]] 
[[Coverage]]

== D ==
[[Dynamic programming]]
== E ==
== F ==
[[FASTA-Format]] 
[[FASTQ-Format]]
== G ==
[[gap penalty]]
== H ==
== I ==
[[Illumina]]
== J ==
== K ==
== L ==
[[Lander-Waterman-Modell]] 
[[Library]]
== M ==
[[Microarrays]]
== N ==
[[NGS]] 
[[Nullhypothese]]
== O ==
== P ==
[[p-value]]
== Q ==
== R ==
[[reads]] 
[[RNASeq]] 
[[RPKM]]

== S ==
[[Scaffold]] 
[[Smith-Waterman Algorithmus]]
== T ==
[[t-Test]] 
[[TMM]] 
[[TPM]] 
[[Transkriptom]]

== U ==
== V ==
== W ==
== X ==
== Y ==
== Z ==

3.Smith-Waterman

2021-01-31T19:26:39Z

Mka: /* Aufgabe 1: Definitionen */

== Aufgabe 1: Definitionen ==

'''a''': Definiere die folgenden Begriffe:

* '''Alignment''': Methode, bei der verschiedene Sequenzen optimal aneinander ausgerichtet werden, um übereinstimmende Teile untereinander sichtbar zu machen. Die kann entweder zwischen einem Read und einem Referenzgenom passieren oder zwischen zwei Reads im Zuge der RNAseq.

* '''Dynamic Programming''': Algorithmus zum Lösen von informatischen Problemen. Dabei wird ein Problem in Teilprobleme unterteilt, die nach und nach gelöst und gespeichert werden. Die kann auf Assemblies angewandt werden, indem man die reads nach und nach aneinanderfügt, anstatt dies in einem einzigen Programmschritt durchzuführen. Dabei wird stets ein Paar mit maximalem Match verbunden bevor das nächste Paar verwendet wird.

* '''lokales Alignment''': Alignment von zwei (Teil)-Sequenzen, wird mit dem Smith-Waterman-Algorithmus durchgeführt. Zur Berechnung müssen die Teilsequenzen gefunden werden, die den höchsten Alignmentscore besitzen.

* '''Gap penalty''': Bewertung von Lücken, die in ein Alignment eingefügt wurden. Als Folge ein Abzug im Alignmentscore, wenn bei einem lokalen Alignment eine Base ungepaart ist (Das Beispiel hat an Position 3 ein Gap und somit eine Gap penalty.
<center>
AATTGGCC
TT-AACCGG
</center>
*'''Algorithmus''': Verarbeitungsvorschfrift, die aus einer endlichen Folge von eindeutig ausführbaren Anweisungen besteht, mit der man eine Vielzahl gleichartiger Probleme lösen kann. Alternative Definition: Handlungsanweisung zur Lösung eines Problems, besteht aus definierten, sequentiellen Abschnitten.

* '''Fasta-Format''': textbasiertes Format in dem DNA, RNA und '''Protein'''sequenzen gespeichert werden. Besteht aus 2-3 Zeilen pro Sequenz. Die erste Zeile besteht aus einem Header, der mit > beginnt und Namen und Beschreibung der Sequenz beinhaltet. Danach folgt eine optinale Kommentarzeile, gefolgt von der Zeile mit der eigentlichen Sequenz. Mehrere Sequenzen können in einer Datei gespeichert werden, wenn man einen neuen Header für jede Sequenz beginnt.

Beispiel:

{|
|-
|
>Probesequenz_1_20190502_ABC
AATTAAGCATAAATAGGCTAGCTAAGCTAGCCA
>Probesequenz_2_20190502_ABC
GGGATTCGACCGATCGAAGCTTAGCGAACGAGA
|}

'''b''': Welche grundsätzlichen Arten von Alignment gibt es?

Lokales Alignment: Alignment von unterschiedlichen (Teil)-Sequenzen, normalerweise unter der Verwendung des Smith-Waterman-Algorithmuses. Wird mit längeren Teilsequenzen immer aufwändiger.

Globales Alignment: Volle Sequenzen werden miteinander alignt. Wird oftmals mit dem Needleman-Wunsch Algorithmus bearbeitet.

Globales Alignment: Vergleich von Gesamtsequenzen
Lokales Alignment: Vergleich von Teilsequenzen

== Aufgabe 2: Smith-Waterman ==

'''a''': Erkläre welche Funktion der Smith-Waterman-Algorithmus hat und wie er funktioniert.

Der Smith-Waterman Algorithmus wird verwendet um lokale Alignments zu finden.

Berechnet wird es mit folgender Matrix:

[[file:Smith_Waterman_Algorithmus.jpg|center|frameless|500px]]

Erklärt bedeutet dies, das eine Matrix aufgespannt wird mit der Größe Länge von Sequenz A x Länge der Sequenz B, so repräsentiert jede Zelle in der Matrix eine Kombination von einer Base aus Sequenz A und einer Base aus Sequenz B und kann somit als Match oder Mismatch identifiziert werden.
Eine Zahlenbewertung (Score) für Match, Mismatch und Gap muss vorgegeben werden.
Für jede Zelle der Matrix wird ein Wert berechnet, angefangen oben links und beendet unten rechts in der Matrix.
Der Wert für eine bestimmte Zelle ist der höchste Wert aus den folgenden 4:

* Der höchste Wert für die Zelle links oben diagonal (oder 0 falls dies außerhalb der Matrix liegt) plus den Score der Zelle (Match oder Mismatch).

* Der höchste Wert aus der Zelle links daneben plus den Score für einen Gap.

* Der höchste Wert aus Zelle oberhalb plus den Score für einen Gap.

* Null

Die Matrix wird berechnet bis alle Werte bestimmt sind. Dann wird der höchste Wert der gesamten Matrix gesucht. Von diesem Punkt beginnt das Alignment. Von dort aus wird rückwärts die Sequenz bestimmt, indem die Rechnung rückwärts verfolgt wird. Der nächste Sequenzteil ist dann jeweils immer die Zelle von der aus man den höchsten Wert berechnet hat. Sobald man jedoch nach links oder nach oben geht anstatt diagonal zu gehen, muss man beachten dass man hierbei ein Gap in das Alignment einbaut und dies auch so aufschreiben muss.

Zuerst berechnet man jede Zelle der Matrix, dann findet man das Aligment
[[File:Matrix berechnen.png|left|frameless|340px]]
[[File:Alignment finden.png|right|frameless|340px]]
 

'''b''': Wo in der Smith-Waterman-Matrix beginnt und endet das optimale Alignment?

Das optimale Alignment beginnt bei den höchsten Wert, folgt dann dem Berechnungsstrang bis das erste Mal auf eine 0 getroffen wird. Dort bricht das Alignment ab.

'''c''': Welche Alignment-Art wird durch den Smith-Waterman Algorithmus bestimmt?

Mit dem Algorithmus wird ein lokales Alignment bestimmt.

== Aufgabe 3: lokales Alignment ==

Führe ein Alignment der folgenden Sequenzen durch: GCDGC GDG

Verwende den Ähnlichkeitsscore S: Match = 3 | Mismatch = -2 | Gap = -4

Berechne für die beiden Sequenzen ein optimales lokales Alignment nach Smith-Waterman mit den gleichen Bedingungen.
Welches optimale lokale Alignment ergibt sich?
Rechts ist die Lösungsmatrix dargestellt, der Score des Alignments ist 6.
[[File:Smith waterman2.png|frameless|center]]

== Aufgabe 4: Alignment ==

Während deiner Bachelorarbeit sollst du ein Protein, das du gerade versuchst zu
charakterisieren, in einen groben Kontext bringen. Leider weißt du noch nicht viel über das
Protein.
Daher ist dein erster Schritt, gemeinsame Domänen zwischen den Proteinen zu finden.
Für das Protein hat sich folgende Sequenz ergeben: DDCGDC

Durch einen Abgleich der Sequenz mit einer Datenbank kann die Sequenz mit anderen
Sequenzen verglichen und ein optimales Alignment gefunden werden.
Wieso eignet sich hier der Smith-Waterman Algorithmus?
Führe ein Alignment zwischen der oben ermittelten Sequenz und der folgenden durch:
DGGD

Ähnlichkeitsscore S: match = 3 | mismatch = -1 | gap penalty = -4

Smith-Waterman nutzt man für lokale Alignments, hier ist dies nützlich da wir Ausschnitte aus zwei funktionell ähnlichen Domänen vergleichen.

[[File:Smith waterman3.png|frameless|400px|center]]

== Aufgabe 5: Lander-Waterman-Modell ==

'''a''': Was sagt das Lander-Waterman-Modell aus? Benne die darauf beruhende Formel
sowie ihre Bestandteile.

Mit dem Lander-Waterman-Modell kann man berechnen wie viele Gaps in einem Alignment zu erwarten sind.

Die Formel zur Berechung lautet: P(nicht abgedecktes bp)= <math>e^{-C} </math> wobei <math> C= \frac{N*L}{G} </math>

Hierbei ist C die Coverage, die sich aus der Anzahl der reads N, der durchschnittlichen readlänge L und der Templatesequenz G berechnet.

'''b''': Suche im Internet die Länge des menschlichen Genoms heraus. Verwende dafür folgende
Internetseite: https://www.ncbi.nlm.nih.gov/

Wie viele Reads müssen sequenziert werden, um das humane Genom mit einer
Coverage von 30 abzudecken? Gehe hierfür von einer durchschnittlichen Read Länge
von 600 bp aus.

Je nach gefundenem Wert für die Genomlänge, die ja nach Genotyp variiert hat man leicht unterschiedliche Werte.

Coverage <math>
C = 30 = \frac{N*600}{3257320000}
</math>

<math>
N = 162866000
</math>

'''c''': Wie hoch ist die Häufigkeit nicht abgedeckter bp bei einer Coverage von 40?

Hier können wir das Lander-Waterman-Modell anwenden:
<math> P=e^{-C} = e^{-40} = 4,24835*10^{-18}</math>

'''d''': Wie müsste die Anzahl der Reads gewählt werden, sodass eine möglichst komplette
Übersicht über die Genomsequenz erhalten wird?

Generell gilt, dass je mehr reads desto geringer die Wahrscheinlichkeit dass Gaps autreten. Jedoch verlängert sich damit die Dauer der Sequenzierung auch. Man kann die Lander-Waterman-Formel umstellen um zu berechnen welche Coverage man braucht um nur ein Contig zu haben

<math> -C=\ln(\frac{1}{3257320000})=-21,904 </math>

Es würde also eine Coverage von über 21 gebraucht werden um statistisch gesehen keine Gaps mehr zu erwarten.
[[File:LWM.png|frameless|center]]

Glossar

2021-01-31T19:21:01Z

Mka: /* C */

== A ==
[[Alignment]] 
[[Algorithmus]] 
[[Assembly]]
== B ==
[[Benjamini-Hochberg-Prozedur]] 
[[Bonferroni-Korrektur]] 
[[Burrows-Wheeler Transformation]]
== C ==
[[Contiq]] 
[[Coverage]]

== D ==
[[Dynamic programming]]
== E ==
== F ==
[[FASTA-Format]] 
[[FASTQ-Format]]
== G ==
[[gap penalty]]
== H ==
== I ==
[[Illumina]]
== J ==
== K ==
== L ==
[[Lander-Waterman-Modell]] 
[[Library]]
== M ==
[[Microarrays]]
== N ==
[[NGS]] 
[[Nullhypothese]]
== O ==
== P ==
[[p-value]]
== Q ==
== R ==
[[reads]] 
[[RNASeq]] 
[[RPKM]]

== S ==
[[Scaffold]] 
[[Smith-Waterman Algorithmus]]
== T ==
[[t-Test]] 
[[TMM]] 
[[TPM]] 
[[Transkriptom]]

== U ==
== V ==
== W ==
== X ==
== Y ==
== Z ==

10.BLAST

2021-01-31T19:12:10Z

Mka: /* Durchführung */

== Grundlagen ==

'''a''': Was ist BLAST?

*'''B'''asic '''l'''ocal '''a'''lignment '''s'''earch '''t'''ool
* Schnelle Suche einer Sequenz in einer Sequenzdatenbank
* Sequenz wird zur Suche in Teilsequenzen zerlegt
* kann zur Strukur- und Funktionsvorhersage dienen

'''b''': Auf welchem Prinzip beruht BLAST? Erkläre die Funktionsweise.

''' Er sucht nach homologen Sequenzen in der Datenbank und berechnet zusätzlich eine statistische Signifikanz'''

Die Idee des Algorithmus basiert auf der Wahrscheinlichkeit, dass Alignment mit vielen Treffern auch viele zufällig ausgewählte Stücke von großerer Identität (im Sinne von identisch) besitzen. Diese gefunden Teilstücke werden dann während der Suche nach besseren und längeren Alignments weiter vergrößert. Indem diese Segmente kurz gehalten werden, ist es möglich, die Abfragesequenz vor einer Suche zu bearbeiten. Dadurch kann eine Tabelle mit möglichen Teilstücken mit ihrem Ursprung in der Orginalsequenz vorgehalten werden.

Dabei stellt der Algorithmus eine Liste aller benachbarten Worte fester Länge auf, die einen Treffer auf der Abfragesequenz mit einem höheren Scoring als ein zu wählender Parameter erzeugen würden. Anschließend wird die Zieldatenbank nach Wörtern in dieser Liste abgefragt und die gefundenen Treffer erweitert, um mögliche maximal zusammenhängende Treffer -in beide Richtungen- zu finden.

Der Ablauf dafür ist:

*1. Die 'query' Sequenz wird in Worte der Länge 'l' zerlegt (l = 3 für Proteine; l = 11 für DNA)
*2. Für jedes Wort wird eine Liste ähnlicher Wörter (w-mers) mit Score S>Threshold erzeugt (Threshold=13 bei Aminosäuresequenzen; basierend auf der BLOSUM62 Matrix)
*3. Alle w-mers der Liste werden in der Datenbank gesucht und die Position bestimmt
*4. Die Treffer werden erweitert, bis der Score kleiner wird
*5. Ist der Score größer als der cutoff, handelt es sich um ein 'high-scoring-pair' ('''HSP''')
*6. HSPs werden durch lokales Alignment erweiter (Smith Waterman), der echte Alignment Score wird berechnet. Gaps können nun berücksichtig werden.

[[File:BLOSUM62 MATRIX.png|700px|center|thumb]] 

'''c''': Um was für einen Algorithmus handelt es sich bei BLAST? Nenne einen Vor- und einen Nachteil.

*heuristischer Algorithmus

Vorteil: schnell
Nachteil: nichts zwangsläufig das beste Alignment wird gefunden, abhängig von den Eingangsparametern; kann Fusionproteine nicht finden

'''d''': Bestimme manuell für die Sequenz 'PRAKTIKA' sämtliche w-mers der Länge 3, die bei Verwendung der BLOSUM62 Matrix einen Score T>13 besitzen.

[[File:BLAST1.jpeg|400px|center|thumb]] 

== Durchführung ==
Datensatz vom 06/2020

Du erhälst folgende Sequenz:

MQIELSTCFFLCLLRFCFSATRRYYLGAVELSWDYMQSDLGELPVDARFPPRVPKSFPFNTSVVYKKTLFVE FTDHLFNIAKPRPPWMGLLGPTIQAEVYDTVVITLKNMASHPVSLHAVGVSYWKASEGAEYDDQTSQREK EDDKVFPGGSHTYVWQVLKENGPMASDPLCLTYSYLSHVDLVKDLNSGLIGALLVCREGSLAKEKTQTLH KFILLFAVFDEGKSWHSETKNSLMQDRDAASARAWPKMHTVNGYVNRSLPGLIGCHRKSVYWHVIGMGT TPEVHSIFLEGHTFLVRNHRQASLEISPITFLTAQTLLMDLGQFLLFCHISSHQHDGMEAYVKVDSCPEEPQ LRMKNNEEAEDYDDDLTDSEMDVVRFDDDNSPSFIQIRSVAKKHPKTWVHYIAAEEEDWDYAPLVLAPDD RSYKSQYLNNGPQRIGRKYKKVRFMAYTDETFKTREAIQHESGILGPLLYGEVGDTL

Starte nun den BLAST-Server des NCBI. Achte darauf, als Algorithmus unter Program Selection 'blastp (protein-protein BLAST)' auszuwählen.

'''a''': Gib die Sequenz ein und starte die Suche. Um welches Protein handelt es sich? Welche Domänen enthält es?

Coagulation faktor VIII (Homo sapiens)
Domäne: Cupredoxin 1,2,3 und Multicopper Oxi- dase

Suche nun in einer geeigneten Datenbank nach dem Protein. (Uniprot)

'''b''': Welche molekulare Funktion hat das Protein und an welchen biologischen Prozessen ist es beteiligt? An welcher Krankheit ist es beteiligt?

Molekulare Funktion: Kupferion- bindend und besitzt eine Oxidoreduktase Aktivität.
'''Biologische Prozesse:'''
Akute-Phase-Antwort: eine akute entzündliche Reaktion, die nicht Antikörperproteine beinhaltet. Deren Konzentration steigt aufgrund einer Verletzung oder Infektion an
Blutgerinnung
Aktivierung der Blutplättchen ( bei Blutgerinnung)
Vesikel Ummantelung
Transport: Endoplasmatisches Retikulum zum Golgi

'''Krankheit:'''
Hämophilie A (häufige, rezessive X-chromosomale Koagulationsstörung)

11.BLAST II

2021-01-31T19:11:37Z

Mka: /* Durchführung */

== Datenanalyse ==

'''a''': Was ist das Problem bei der Bewertung von BLAST Ergebnissen?

*Der Score hängt auch von der Sequenzlänge, der Substitutionsmatrix und gap penalty ab und kann deshalb nicht direkt verglichen werden.

'''b''': Was ist der Bit-Score und wie wird er berechnet?

*log_2 skalierte Version des normalisierten Scores
*Durch folgende Formel berechnet:
<center><math> S' = \frac{\lambda S-ln(k)}{ln(2)}</math></center>
λ und k sind Karlin-Altschul-Paramter und ergeben sich aus der Scoring-Funktion.

'''c''': Wie ist der Suchraum definiert? In welchem Zusammenhang steht dieser mit dem Bit-Score?
Der Suchraum N ist durch folgende Formel definiert:

N = n * m

n = Länge der ’query’ Sequenz und m = Länge der Datenbank
*Der Bit-Score beschreibt die Größe des Suchraums, der zufällig einen Treffer mit gleichem oder besseren Bit- Score enthält.

'''d''': Was gibt der e-value an und wie wird er berechnet? Sind e-values, die an verschiedenen Tagen errechnet wurden, vergleichbar?

*Der e-value oder expectation value korrigiert den P-Value für einen Suchraum der Größe N. Es ist die Wahrscheinlichkeit, dass ein Ereignis im Suchraum N durch Zufall eintritt.
<center><math>P = {2^{-S'}} E = \frac{ N}{2^{S'}} = \frac{ m*n}{2^{S'}}
</math></center>

*An verschiedenen Zeitpunkten berechnete e-values sind nicht vergleichbar, weil die Größe der Datenbank m an verschiedenen Zetipunkten unterschiedlich sein kann. Die Wahrscheinlichkeit für einen Zufallstreffer ist umso höher, je größer die Datenbank war, in der der e-Value bestimmt wurde.

== Durchführung ==
Datensatz vom 06/2020

Du erhältst folgende Sequenz:

MSKTQEFRPLTLPPKLSLSDFNEFIQDIIRIVGSENVEVISSKDQIVDGSYMKPTHTHDPHHVMDQDYFLAS AIVAPRNVADVQSIVGLANKFSFPLWPISIGRNSGYGGAAPRVSGSVVLDMGKNMNRVLEVNVEGAYCVV EPGVTYHDLHNYLEANNLRDKLWLDVPDLGGGSVLGNVERGVGYTLFPYGFGPYIDGLFSQSNMGIVTK IGIWLMPNPRGYQSYLITLPKDGDLKQAVDIIRPLRLGMALQNVPTIRHILLDAAVLGDKRSYSSRTEPLSD EELDKIAKQLNLGRWNFYGALYGPEPIRRVLWETIKDAFSAIPGVKFYFPEDTPENSVLRVRDKTMQGIPT YDELKWIDWLPNGAHLFFSPIAKVSGEDAMMQYAVTKKRCQEAGLDFIGTFTVGMREMHHIVCIVFNKKDLIQ

Starte nun den BLAST-Server des NCBI. Achte darauf, als Algorithmus unter Program Selection „ blastp (protein-protein BLAST)“ auszuwählen.

'''a''': Gib die Sequenz ein und starte die Suche. Um welches Protein handelt es sich?
Vanillyl-alcohol Oxidase

'''b''': Wie hoch sind der e-value und der bit-score? Was bedeutet dieser e-value? Wie groß wäre der hier benötigte Suchraum um einen zufälligen Treffer mit diesem score zu finden?

*e-value geht gegen 0 → Wahrscheinlichkeit, dass das Ergebnis durch Zufall gefunden wurde. Da der Wert so klein ist, ist die Irrtumswahrscheinlichkeit minimal.
*bit-Score=852
*Suchraum= N = 2^{852} =3.003 * 10^{256}

'''c''': Welche Parameter sind außerdem signifikant?

*Die Abdeckung: Anteil der Aminosäuren der ’query’ Sequenz, die beim Vergleich abgedeckt wurden

*Identität: Anteil der verglichenen Aminosäuren, die tatsächlich identisch sind

Starte eine neue Suche. Wähle in dem eingeklappten Menü „Algorithm parameters“ im Bereich „Scoring parameters“ unter „Compositional adjustments“ die Einstellung „No adjustment“ aus. Führe nun BLAST nacheinander mit der BLOSUM80-Matrix und der BLOSUM45-Matrix aus. Speichere den Anfang der jeweiligen Tabelle und vergleiche die Ergebnisse.

'''d''': Wie unterscheiden sich die Parameter?

*BLOSUM 45: Niedrigerer Score, Höherer e-value (untere Tabelle)
*BLOSUM 80: Höherer Score und niedrigerer e-value bei BLOSUM 80; insgesamt weniger Ergebnisse (obere Tabelle)

Die Erstellung von BLOSUM X basiert auf dem Sequenzvergleich von solchen Sequenzen, die zu mind. X% verwandt sind. Bei BLOSUM80 wurden also näherverwandte Sequenzen verglichen als bei BLOSUM45, weswegen höhere Scores in der Diagonalen vorhanden sind.

[[File:BLAST2.jpeg|600px|center|thumb]]

11.BLAST II

2021-01-31T19:09:37Z

Mka: /* Durchführung */

== Datenanalyse ==

'''a''': Was ist das Problem bei der Bewertung von BLAST Ergebnissen?

*Der Score hängt auch von der Sequenzlänge, der Substitutionsmatrix und gap penalty ab und kann deshalb nicht direkt verglichen werden.

'''b''': Was ist der Bit-Score und wie wird er berechnet?

*log_2 skalierte Version des normalisierten Scores
*Durch folgende Formel berechnet:
<center><math> S' = \frac{\lambda S-ln(k)}{ln(2)}</math></center>
λ und k sind Karlin-Altschul-Paramter und ergeben sich aus der Scoring-Funktion.

'''c''': Wie ist der Suchraum definiert? In welchem Zusammenhang steht dieser mit dem Bit-Score?
Der Suchraum N ist durch folgende Formel definiert:

N = n * m

n = Länge der ’query’ Sequenz und m = Länge der Datenbank
*Der Bit-Score beschreibt die Größe des Suchraums, der zufällig einen Treffer mit gleichem oder besseren Bit- Score enthält.

'''d''': Was gibt der e-value an und wie wird er berechnet? Sind e-values, die an verschiedenen Tagen errechnet wurden, vergleichbar?

*Der e-value oder expectation value korrigiert den P-Value für einen Suchraum der Größe N. Es ist die Wahrscheinlichkeit, dass ein Ereignis im Suchraum N durch Zufall eintritt.
<center><math>P = {2^{-S'}} E = \frac{ N}{2^{S'}} = \frac{ m*n}{2^{S'}}
</math></center>

*An verschiedenen Zeitpunkten berechnete e-values sind nicht vergleichbar, weil die Größe der Datenbank m an verschiedenen Zetipunkten unterschiedlich sein kann. Die Wahrscheinlichkeit für einen Zufallstreffer ist umso höher, je größer die Datenbank war, in der der e-Value bestimmt wurde.

== Durchführung ==

Du erhältst folgende Sequenz:

MSKTQEFRPLTLPPKLSLSDFNEFIQDIIRIVGSENVEVISSKDQIVDGSYMKPTHTHDPHHVMDQDYFLAS AIVAPRNVADVQSIVGLANKFSFPLWPISIGRNSGYGGAAPRVSGSVVLDMGKNMNRVLEVNVEGAYCVV EPGVTYHDLHNYLEANNLRDKLWLDVPDLGGGSVLGNVERGVGYTLFPYGFGPYIDGLFSQSNMGIVTK IGIWLMPNPRGYQSYLITLPKDGDLKQAVDIIRPLRLGMALQNVPTIRHILLDAAVLGDKRSYSSRTEPLSD EELDKIAKQLNLGRWNFYGALYGPEPIRRVLWETIKDAFSAIPGVKFYFPEDTPENSVLRVRDKTMQGIPT YDELKWIDWLPNGAHLFFSPIAKVSGEDAMMQYAVTKKRCQEAGLDFIGTFTVGMREMHHIVCIVFNKKDLIQ

Starte nun den BLAST-Server des NCBI. Achte darauf, als Algorithmus unter Program Selection „ blastp (protein-protein BLAST)“ auszuwählen.

'''a''': Gib die Sequenz ein und starte die Suche. Um welches Protein handelt es sich?
Vanillyl-alcohol Oxidase

'''b''': Wie hoch sind der e-value und der bit-score? Was bedeutet dieser e-value? Wie groß wäre der hier benötigte Suchraum um einen zufälligen Treffer mit diesem score zu finden?

*e-value geht gegen 0 → Wahrscheinlichkeit, dass das Ergebnis durch Zufall gefunden wurde. Da der Wert so klein ist, ist die Irrtumswahrscheinlichkeit minimal.
*bit-Score=852
*Suchraum= N = 2^{852} =3.003 * 10^{256}

'''c''': Welche Parameter sind außerdem signifikant?

*Die Abdeckung: Anteil der Aminosäuren der ’query’ Sequenz, die beim Vergleich abgedeckt wurden

*Identität: Anteil der verglichenen Aminosäuren, die tatsächlich identisch sind

Starte eine neue Suche. Wähle in dem eingeklappten Menü „Algorithm parameters“ im Bereich „Scoring parameters“ unter „Compositional adjustments“ die Einstellung „No adjustment“ aus. Führe nun BLAST nacheinander mit der BLOSUM80-Matrix und der BLOSUM45-Matrix aus. Speichere den Anfang der jeweiligen Tabelle und vergleiche die Ergebnisse.

'''d''': Wie unterscheiden sich die Parameter?

*BLOSUM 45: Niedrigerer Score, Höherer e-value (untere Tabelle)
*BLOSUM 80: Höherer Score und niedrigerer e-value bei BLOSUM 80; insgesamt weniger Ergebnisse (obere Tabelle)

Die Erstellung von BLOSUM X basiert auf dem Sequenzvergleich von solchen Sequenzen, die zu mind. X% verwandt sind. Bei BLOSUM80 wurden also näherverwandte Sequenzen verglichen als bei BLOSUM45, weswegen höhere Scores in der Diagonalen vorhanden sind.

[[File:BLAST2.jpeg|600px|center|thumb]]

11.BLAST II

2021-01-31T19:02:59Z

Mka: /* Datenanalyse */

== Datenanalyse ==

'''a''': Was ist das Problem bei der Bewertung von BLAST Ergebnissen?

*Der Score hängt auch von der Sequenzlänge, der Substitutionsmatrix und gap penalty ab und kann deshalb nicht direkt verglichen werden.

'''b''': Was ist der Bit-Score und wie wird er berechnet?

*log_2 skalierte Version des normalisierten Scores
*Durch folgende Formel berechnet:
<center><math> S' = \frac{\lambda S-ln(k)}{ln(2)}</math></center>
λ und k sind Karlin-Altschul-Paramter und ergeben sich aus der Scoring-Funktion.

'''c''': Wie ist der Suchraum definiert? In welchem Zusammenhang steht dieser mit dem Bit-Score?
Der Suchraum N ist durch folgende Formel definiert:

N = n * m

n = Länge der ’query’ Sequenz und m = Länge der Datenbank
*Der Bit-Score beschreibt die Größe des Suchraums, der zufällig einen Treffer mit gleichem oder besseren Bit- Score enthält.

'''d''': Was gibt der e-value an und wie wird er berechnet? Sind e-values, die an verschiedenen Tagen errechnet wurden, vergleichbar?

*Der e-value oder expectation value korrigiert den P-Value für einen Suchraum der Größe N. Es ist die Wahrscheinlichkeit, dass ein Ereignis im Suchraum N durch Zufall eintritt.
<center><math>P = {2^{-S'}} E = \frac{ N}{2^{S'}} = \frac{ m*n}{2^{S'}}
</math></center>

*An verschiedenen Zeitpunkten berechnete e-values sind nicht vergleichbar, weil die Größe der Datenbank m an verschiedenen Zetipunkten unterschiedlich sein kann. Die Wahrscheinlichkeit für einen Zufallstreffer ist umso höher, je größer die Datenbank war, in der der e-Value bestimmt wurde.

== Durchführung ==

Du erhältst folgende Sequenz:

MSKTQEFRPLTLPPKLSLSDFNEFIQDIIRIVGSENVEVISSKDQIVDGSYMKPTHTHDPHHVMDQDYFLAS AIVAPRNVADVQSIVGLANKFSFPLWPISIGRNSGYGGAAPRVSGSVVLDMGKNMNRVLEVNVEGAYCVV EPGVTYHDLHNYLEANNLRDKLWLDVPDLGGGSVLGNVERGVGYTLFPYGFGPYIDGLFSQSNMGIVTK IGIWLMPNPRGYQSYLITLPKDGDLKQAVDIIRPLRLGMALQNVPTIRHILLDAAVLGDKRSYSSRTEPLSD EELDKIAKQLNLGRWNFYGALYGPEPIRRVLWETIKDAFSAIPGVKFYFPEDTPENSVLRVRDKTMQGIPT YDELKWIDWLPNGAHLFFSPIAKVSGEDAMMQYAVTKKRCQEAGLDFIGTFTVGMREMHHIVCIVFNKKDLIQ

Starte nun den BLAST-Server des NCBI. Achte darauf, als Algorithmus unter Program Selection „ blastp (protein-protein BLAST)“ auszuwählen.

'''a''': Gib die Sequenz ein und starte die Suche. Um welches Protein handelt es sich?
Vanillyl-alcohol Oxidase

'''b''': Wie hoch sind der e-value und der bit-score? Was bedeutet dieser e-value? Wie groß wäre der hier benötigte Suchraum um einen zufälligen Treffer mit diesem score zu finden?

e-value geht gegen 0
*Wahrscheinlichkeit, dass das Ergebnis durch Zufall gefunden wurde. Da der Wert so klein ist, ist die Irrtumswahrscheinlichkeit minimal.

bit-Score=852
Suchraum= N = 2^852 =3.003 * 10^256

'''c''': Welche Parameter sind außerdem signifikant?

*Die Abdeckung: Anteil der Aminosäuren der ’query’ Sequenz, die beim Vergleich abgedeckt wurden

*Identität: Anteil der verglichenen Aminosäuren, die tatsächlich identisch sind

Starte eine neue Suche. Wähle in dem eingeklappten Menü „Algorithm parameters“ im Bereich „Scoring parameters“ unter „Compositional adjustments“ die Einstellung „No adjustment“ aus. Führe nun BLAST nacheinander mit der BLOSUM80-Matrix und der BLOSUM45-Matrix aus. Speichere den Anfang der jeweiligen Tabelle und vergleiche die Ergebnisse.

'''d''': Wie unterscheiden sich die Parameter?

*BLOSUM 45: Niedrigerer Score, Höherer e-value (untere Tabelle)
*BLOSUM 80: Höherer Score und niedrigerer e-value bei BLOSUM 80; insgesamt weniger Ergebnisse (obere Tabelle)

Die Erstellung von BLOSUM X basiert auf dem Sequenzvergleich von solchen Sequenzen, die zu mind. X% verwandt sind. Bei BLOSUM80 wurden also näherverwandte Sequenzen verglichen als bei BLOSUM45, weswegen höhere Scores in der Diagonalen vorhanden sind.

[[File:BLAST2.jpeg|600px|center|thumb]]

10.BLAST

2021-01-31T18:58:46Z

Mka: /* Durchführung */

== Grundlagen ==

'''a''': Was ist BLAST?

*'''B'''asic '''l'''ocal '''a'''lignment '''s'''earch '''t'''ool
* Schnelle Suche einer Sequenz in einer Sequenzdatenbank
* Sequenz wird zur Suche in Teilsequenzen zerlegt
* kann zur Strukur- und Funktionsvorhersage dienen

'''b''': Auf welchem Prinzip beruht BLAST? Erkläre die Funktionsweise.

''' Er sucht nach homologen Sequenzen in der Datenbank und berechnet zusätzlich eine statistische Signifikanz'''

Die Idee des Algorithmus basiert auf der Wahrscheinlichkeit, dass Alignment mit vielen Treffern auch viele zufällig ausgewählte Stücke von großerer Identität (im Sinne von identisch) besitzen. Diese gefunden Teilstücke werden dann während der Suche nach besseren und längeren Alignments weiter vergrößert. Indem diese Segmente kurz gehalten werden, ist es möglich, die Abfragesequenz vor einer Suche zu bearbeiten. Dadurch kann eine Tabelle mit möglichen Teilstücken mit ihrem Ursprung in der Orginalsequenz vorgehalten werden.

Dabei stellt der Algorithmus eine Liste aller benachbarten Worte fester Länge auf, die einen Treffer auf der Abfragesequenz mit einem höheren Scoring als ein zu wählender Parameter erzeugen würden. Anschließend wird die Zieldatenbank nach Wörtern in dieser Liste abgefragt und die gefundenen Treffer erweitert, um mögliche maximal zusammenhängende Treffer -in beide Richtungen- zu finden.

Der Ablauf dafür ist:

*1. Die 'query' Sequenz wird in Worte der Länge 'l' zerlegt (l = 3 für Proteine; l = 11 für DNA)
*2. Für jedes Wort wird eine Liste ähnlicher Wörter (w-mers) mit Score S>Threshold erzeugt (Threshold=13 bei Aminosäuresequenzen; basierend auf der BLOSUM62 Matrix)
*3. Alle w-mers der Liste werden in der Datenbank gesucht und die Position bestimmt
*4. Die Treffer werden erweitert, bis der Score kleiner wird
*5. Ist der Score größer als der cutoff, handelt es sich um ein 'high-scoring-pair' ('''HSP''')
*6. HSPs werden durch lokales Alignment erweiter (Smith Waterman), der echte Alignment Score wird berechnet. Gaps können nun berücksichtig werden.

[[File:BLOSUM62 MATRIX.png|700px|center|thumb]] 

'''c''': Um was für einen Algorithmus handelt es sich bei BLAST? Nenne einen Vor- und einen Nachteil.

*heuristischer Algorithmus

Vorteil: schnell
Nachteil: nichts zwangsläufig das beste Alignment wird gefunden, abhängig von den Eingangsparametern; kann Fusionproteine nicht finden

'''d''': Bestimme manuell für die Sequenz 'PRAKTIKA' sämtliche w-mers der Länge 3, die bei Verwendung der BLOSUM62 Matrix einen Score T>13 besitzen.

[[File:BLAST1.jpeg|400px|center|thumb]] 

== Durchführung ==

Du erhälst folgende Sequenz:

MQIELSTCFFLCLLRFCFSATRRYYLGAVELSWDYMQSDLGELPVDARFPPRVPKSFPFNTSVVYKKTLFVE FTDHLFNIAKPRPPWMGLLGPTIQAEVYDTVVITLKNMASHPVSLHAVGVSYWKASEGAEYDDQTSQREK EDDKVFPGGSHTYVWQVLKENGPMASDPLCLTYSYLSHVDLVKDLNSGLIGALLVCREGSLAKEKTQTLH KFILLFAVFDEGKSWHSETKNSLMQDRDAASARAWPKMHTVNGYVNRSLPGLIGCHRKSVYWHVIGMGT TPEVHSIFLEGHTFLVRNHRQASLEISPITFLTAQTLLMDLGQFLLFCHISSHQHDGMEAYVKVDSCPEEPQ LRMKNNEEAEDYDDDLTDSEMDVVRFDDDNSPSFIQIRSVAKKHPKTWVHYIAAEEEDWDYAPLVLAPDD RSYKSQYLNNGPQRIGRKYKKVRFMAYTDETFKTREAIQHESGILGPLLYGEVGDTL

Starte nun den BLAST-Server des NCBI. Achte darauf, als Algorithmus unter Program Selection 'blastp (protein-protein BLAST)' auszuwählen.

'''a''': Gib die Sequenz ein und starte die Suche. Um welches Protein handelt es sich? Welche Domänen enthält es?

Coagulation faktor VIII (Homo sapiens)
Domäne: Cupredoxin 1,2,3 und Multicopper Oxi- dase

Suche nun in einer geeigneten Datenbank nach dem Protein. (Uniprot)

'''b''': Welche molekulare Funktion hat das Protein und an welchen biologischen Prozessen ist es beteiligt? An welcher Krankheit ist es beteiligt?

Molekulare Funktion: Kupferion- bindend und besitzt eine Oxidoreduktase Aktivität.
'''Biologische Prozesse:'''
Akute-Phase-Antwort: eine akute entzündliche Reaktion, die nicht Antikörperproteine beinhaltet. Deren Konzentration steigt aufgrund einer Verletzung oder Infektion an
Blutgerinnung
Aktivierung der Blutplättchen ( bei Blutgerinnung)
Vesikel Ummantelung
Transport: Endoplasmatisches Retikulum zum Golgi

'''Krankheit:'''
Hämophilie A (häufige, rezessive X-chromosomale Koagulationsstörung)

9.Biomarker

2021-01-31T18:51:59Z

Mka: /* Aufgabe 1: Definitionen */

== Aufgabe 1: Definitionen ==

'''ROC''': Abkürzung für '''R'''eceiver '''O'''perating '''C'''haracteristic. Dies ist eine Methode mit der man Analysemethoden wie z.B. Diagnosealgorithmen optimieren und bewerten kann. Dafür bestimmt man die falschpositiven und falschnegativen Ergebnisse der Analysemethode und bestimmt damit die Sensitivität und Spezifität der Methode. Anschließend wägt man diese gegeneinander ab. Dies geschieht mittels der Grenzwertoptimierungskurve (ROC- Kurve).

'''AUC''': Abkürzung für '''A'''rea '''u'''nder '''C'''urve. Beschreibt die Fläche unter der Kurve die man erhält wenn man Sensitivität gegen 1-Spezifität aufträgt. Der AUC-Wert liegt dabei zwischen 1 und 0. Ein Wert nahe 1 bedeutet dabei dass die Analysemethode wenig falschpositive und falschnegative Werte generiert. Ein Wert nahe 0 bedeutet dass die Analysemethode fast ausschließlich falschpositive und falschnegative Werte generiert. Dies bedeutet, dass der Algothitmus trotzdem funktioniert, man ihn jedoch "umdrehen" muss. Werte um 0,5 herum sind daher die schlechtesten Werte, da diese bedeuten dass die Methode qualitativ so gut sind wie per Zufall zu diagnositizieren.

'''Spezifität''': <math> \frac{True Negatives}{(False Positives+True Negatives)}</math>

Rate, mit denen die Analysemethode Negativproben korrekt erkennt werden. Idealerweise geht der Werte gegen 1.

'''Sensitivität''': <math> \frac{True Positives}{(False Negatives+True Positives)}</math>

Rate, mit denen die Analysemethode Positivproben korrekt erkennt werden. Idealerweise geht der Werte gegen 1.

'''logit-Funktion''': eine logistische Funktion, die Analysemethoden verwenden, um mit
Expressionsleveln von Biomarkern einen Wert zwischen 0 und 1 zu berechnen. Dieser kann dann verwendet werden, um abzuschätzen, ob ein positives oder ein negatives Ergebnis vorliegt.

<math>logit(P) = log \frac{P_{X}}{1-P_{X}} = \beta_{1} * TPM_{GenX} + \beta_{0} </math>

(Zähler=Wahrscheinlichkeit; Nenner=Gegenwahrscheinlichkeit)

'''Threshold''': Cutoff-Wert in der logit-Funktion. Dort trennt der Analysealgrithmus die logit-Funktion.

Alles auf einer Seite wird als positiv bewertet und alles auf der anderen Seite als
negativ. Ob positiv krank bedeutet, hängt davon ab, ob bei kranken Menschen dieser Biomarker hoch- oder runtereguliert ist.

Anderer Erklärungsansatz:
*Ein Grenzwert zwischen 2 Konditionen
*Wird anhand Trainingsdaten justiert
*Beispiel: krank=1; gesund=0; Threshold=0.5; Alle Werte unter 0.5 sind gesund

== Aufgabe 2: Biomarker ==

'''a''': Was ist ein Biomarker und wofür kann er verwendet werden?

Biomarker sind messbare biologische Parameter die eine gewisse Aussagekraft für Diagnose und Prognose haben. Mit der Analyse von Biomarkern kann man bei der Diagnose von Krankheiten bei Menschen helfen. Das Protein Troponin T ist beispielweise der Indikator in der Herzinfarkdiagnostik. Da dieses Protein in Herzmuskeln besonders exprimirt wird und als Konsequenz eines sterbenden Herzmuskels in die Blutbahn gelangt, wird dieser Wert bei Brustbeschwerden als joch signifikant für die weitere Diagnostik oder Therapie angesehen.
Ein moderner Ansatz in der Bioinformatik wäre bspw. die Genexpression als Biomarker zu verwenden. Möglicherweise könnten so Tumorzellen sicher im Blut detektiert werden, da sich ihre Genexpression von physiologische Zellen deutlich unterscheidet. Eine standardisierte, klinische Anwendung ist bisher jedoch nicht möglich.

'''b''': Beschreiben Sie, wie Biomarker bestimmt werden können.

Einfache Biomarker wie Körpertemperatur und Blutdruck kann man mit einfachen diagnostischen Methoden bestimmen (Fieberthermometer bzw Oberarm-Manometer).

Um Genexpression als Biomarker zu nutzen, kann mit einer RNA-Sequenzierung eine 'verdächtige' Probe mit einer Referenzprobe vergleichen. Die Werte kann man anschließend mit Analysemethoden aufbereiten, und am Besten mit mehreren Biomarkern eine zuverlässigere Vorraussage treffen.

Grundsätzlich liefert die Bioinformatik hier viele Möglichkeiten neue Biomarker in der medizinischen Diagnostik langfristig zu etablieren:
*Klare Unterschiede zwischen zu untersuchenden Zuständen erkennbar (Bspw: Metabolitlevel - Expressionslevel)
*Auswertung großer Datensätze mit bioinformatischen Methoden wie 'machine learning'
*Auf den Patienten hochgradig zugeschnittene Behandlungskonzepte im Sinne von 'individualized medicine'

'''c''': Warum ist ein einzelner Biomarker meistens nicht genug und was ist der Vorteil einer
Biomarker-Signatur?

Ein Biomarker reicht oft nicht, da die Werte mehr oder weniger um einen Mittelwert streuen. Ein Wert kann also durchaus mal aus Ausreißer jenseits des Thresholdes liegen und ein 'falsch positives' oder 'falsch negatives' Ergebnis erzeugen. Die Signifikanz eines Testes kann durch die Verwendung mehrerer mit der Krankheit assoziierter Biomarker (gennant '''Biomarker-Signatur''') deutlich erhöht werden. Dies erhöht also sowohl die Spezifität als auch die Sensivität.

== Aufgabe 3 ==

Aus den ermittelten Metabolitleveln einer imaginären Studie wurde ein logistisches
Regressionsmodell entworfen. Dieses Modell soll in der Lage sein, an Hand von diesen
Metabolitleveln eine Vorhersage über den Gesundheitszustand von Patienten zu machen. Bei
dem Aufstellen des Modells wurde eine 0 als krank und eine 1 als gesund definiert. Folgende
Ausgaben aus diesem Modell wurden enthalten:

[[File:Biomarker_log_reg.jpeg|700px|center|thumb]] 

Bitte bearbeiten Sie nun folgende Fragestellungen:

'''a''': Was sind FPR, TPR, TNR und FNR? Erklären Sie kurz!

*'''FPR''': '''F'''alse '''P'''ositive '''R'''ate: Rate an Patienten, die gesund sind, aber vom Modell als krank erachtet werden.
*'''TPR''': '''T'''rue '''P'''ositive '''R'''ate: Rate an Patienten, die krank sind, und vom Modell als krank erachtet werden.
*'''TNR''': '''T'''rue '''N'''egative '''R'''ate: Rate an Patienten, die gesund sind, und vom Modell als gesund erachtet werden.
*'''FNR''': '''F'''alse '''N'''egative '''R'''ate: Rate an Patienten, die krank sind, aber vom Modell als gesund erachtet werden.

'''TPR = Sensivität'''

'''TNR = Spezifität'''

b) Berechnen Sie für die 6 Thresholds 0; 0,2; 0,4; 0,6; 0,8; 1 die Spezifität und die
Sensitivität des Modells.

[[File:Biomarker_sen_spe.jpeg|700px|center|thumb]] 

c) Welcher dieser Thresholds ist für dieses Modell der Beste? Begründen Sie!

Grundsätzlich sollte ein Threshold gewählt werden, bei dem Sensivität und Spezifität möglichst gegen 1 gehen. Hier besitzt bspw der Threshold von 0.6 den höchsten Wert für die Summe aus Spezifität und Sensivität.

Bei vielen Modellen muss jedoch entschieden werden, ob der Test eher sensibel oder spezifisch sein soll.
Die passende Threshold hängt also davon ab, welche Krankheit man detektieren möchte. Je schwerwiegender diese ist oder je einfacher die Diagnose nach einem Treffer mit dem Modell, desto eher kann auch eine geringe Spezifität für eine möglichst hohe Sensitivität in Kauf nehmen.

7.Hypothesentests

2021-01-31T18:46:10Z

Mka: /* Aufgabe 2 */

== Aufgabe 1 ==

'''a''': Was misst ein t-Test und wie wird dieser berechnet? Was bedeutet der p-Wert?

Der t-Test ist eine Methode der statistischen Analyse, bei der man testet ob ein Mittelwert einer Stichprobe von dem Erwartungswert der Grundgesamtheit abhängt. Mit Varianten des t-Tests kann man außerdem Nullhypothesen(H0) überprüfen, ob zwei oder mehr Stichproben derselben Gesamtheit entspringen oder sich dafür zu signifikant unterscheiden. Der p-Wert ist eine Wahrscheinlichkeit und gibt hierbei das minimale Signifikanzniveau an, bei dem H0 nicht mehr gilt. Der p-Wert ist außerdem die Wahrscheinlichkeit mit der Stichproben zufällig die H0-Hypothese ablehnen.

Für einen t-Test müssen zunächst Mittelwert, Standardabweichung und Freiheitsgrade für alle Stichproben berechnet werden.

Mittelwert: <math>\bar{x}_{\mathrm{arithm}} = \frac{1}{n} \sum_{i=1}^n{x_i} = \frac{x_1 + x_2 + \dotsb + x_n}{n}</math>

Standardabweichung: <math>\tilde s := +\sqrt{\frac{1}{n} \sum \limits_{i=1}^n\left(x_i-\overline x\right)^2} </math>

Freiheitsgrade: df = n-1

In den Formeln ist <math>\bar{x} </math> der Mittelwert, <math> x_1 </math> etc. die einzelnen Werte der Stichprobe und n die Anzahl der Werte einer Stichprobe.

Nachdem man diese Werte bestimmt hat, kann man mit verschiedenen Formeln (da es viele veschiedene t-Tests gibt) den t-Wert berechnen. Hier wird beispielsweise die Formel für den gepoolten Welch-t-test gezeigt:
:<math>
t \quad = \quad {\; \overline{x}_1 - \overline{x}_2 \; \over \sqrt{ \; {s_1^2 \over N_1} \; + \; {s_2^2 \over N_2} \quad }}\,</math>

Der berechnete Wert, wird dann in einer T-Tabelle nachgeschlagen und verglichen. Bevor man einen Wert heraussuchen kann muss ein Signifikanzniveau festgelegt werden, über dem H0 abgelehnt wird, z.B. 0,05. Dann kann man in der Tabelle den Referenz-t-Wert finden und wenn der berechnete t-Wert über dem Referenzwert ist, dann unterscheiden sich die Stichproben signifikant und können nicht als zwei Stichproben aus der gleichen Grundgesamtheit angesehen werden.

'''b''': Wie unterscheiden sich Student‘s t-Test und Welch‘s t-Test?

Students t-Test sollte nur angewendet werden, wenn die Grundgesamtheiten die gleiche Varianz
aufweisen. Wenn dies der Fall ist, sollte der Welch-Test verwendet werden.

Student´s t- test - Gleiche Varianz der Stichproben
Welch´s t- test - Ungleiche Varianz der Stichproben

== Aufgabe 2 ==

'''a''': Welches statistische Problem tritt auf, wenn man eine statistische Signifikanz zwischen zweiBedingungen für viele Gene testet?

*Je mehr Gene getestet werden, desto größer ist die Chance einen falsch- positiven zu detektieren
* Der p-Wert muss angeglichen werden um aussagekräftige Ergebnisse zu bekommen (Bsp. BonferroniKorrektur oder Benjamini-Hochberg Prozedur)
* Beispiel: Bei einem Signifikanzniveau von 5% und 1000 Proben, gibt es rein statistisch die Wahrscheinlichkeit, das 50 Proben fälschlicherweise als signifikant gelten.

'''b''': Was sind die Unterschiede zwischen der Prozedur nach Benjamini-Hochberg und der
Bonferroni-Korrektur?

Bonferroni
* Statistisch sehr sicher, aber sehr streng
* Einfach zu berechnen/ programmieren
* Produziert viele falsch-negative Werte (FN-false negative)
Benjamini-Hochberg
* Weniger streng, höhere Chance auf verwertbare Ergebnisse
* Komplizierter zu programmieren
* Je kleiner FDR (false discovery rate) gewählt wird, desto näher kommt das Ergebnis an die korrigierten P-Werte von Bonferroni heran

'''c''': Wie funktioniert die Bonferroni-Korrektur?

Zuerst berechnet man den korrigierten p-Wert mit folgender Formel:

<math> p_\text{i*}=p_\text{i}*n</math>

wobei <math> p_\text{i*}</math> der korrigierte Wert ist,

<math>p_\text{i}</math>der p-Wert für Merkmal i und n die Anzahl der Merkmale.

Danach vergleicht man die korrigierten Werte mit dem Signifikanzniveau. Wenn der Wert kleiner ist als das Niveau, dann ist der Wert signifikant.

'''d''': Wie funktioniert die Benjamini-Hochberg Prozedur?

Die Prozedur folgt den folgenden Schritten:

- Sortiere die Merkmale nach den zugehörigen p-Werten aufsteigend.

- Gib jedem p-Wert einen Rang zu (i)

- Berechne für jeden p-Wert den BH kritischen Wert mit folgender Formel:

BH = <math>\frac{i}{n}</math> * Q wobei i der Rang ist, n die Anzahl der Merkmale (Stichprobenanzahl) und Q die False Discovery Rate

- Vergleiche jeden p-Wert mit seinem kritischen BH-Wert.

- der größte p-Wert der kleiner als der kritische BH Wert ist, ist der Wert ab dem alle p-Werte aufwärts H0 ablehnen, somit signifikant sind.

'''e''': Bei der Analyse von Metaboliten im Blut von Patienten mit Niereninsuffizienz ist folgende
Tabelle entstanden. Zeige, welche der nachfolgenden p-Werte der Metabolite nach
Benjamini-Hochberg als Signifikant angesehen werden können (α = 0,05). Zeige, welche
Metabolite nach Bonferroni als signifikant angesehen werden können. Beschreibe die
Unterschiede!

'''Bonferroni-Methode''':

{| class="wikitable sortable"
! Metabolit !! P !! P*
|-
! C-mannosyltryptophan
| 1.10E-03 || 0.0297
|-
! pseudouridine
| 3.70E-03 || 0.0999
|-
! O-sulfo-L-tyrosine
| 1.40E-02 || 0.378
|-
! margarate (17:0)
| 2.80E-01 || 7.56
|-
! erythronate*
| 2.80E-02 || 0.756
|-
! N-acetylalanine
| 4.00E-02 || 1.08
|-
! 4-androsten-3beta,17beta-diol disulfate 2*
| 5.30E-03 || 0.1431
|-
! 10-nonadecenoate (19:1n9)
| 8.90E-01 || 24.03
|-
! 4-acetamidobutanoate
| 5.30E-02 || 1.431
|-
! N-acetylthreonine
| 2.70E-01 || 7.29
|-
! eicosenoate (20:1n9 or 11)
| 4.80E-01 || 12.96
|-
! 15-methylpalmitate (isobar with 2- methylpalmitate)
| 4.70E-01 || 12.69
|-
! N1-methyladenosine
| 5.50E-02 || 1.485
|-
! X - 12092
| 1.90E-01 || 5.13
|-
! X - 12216
| 1.50E-02 || 0.405
|-
! N-acetylornithine
| 4.50E-03 || 0.1215
|-
! N-acetylornithine
| 1.30E-01 || 3.51
|-
! dihomo-linoleate (20:2n6)
| 8.60E-01 || 23.22
|-
! 1-docosahexaenoylglycerophosphocholine*
| 3.90E-02 || 1.053
|-
! kynurenine
| 4.60E-02 || 1.242
|-
! 5alpha-pregnan-3beta,20alpha-diol disulfate
| 1.30E-02 || 0.351
|-
! erythritol
| 1.20E-01 || 3.24
|-
! homocitrulline
| 2.50E-01 || 6.75
|-
! bradykinin, des-arg(9)
| 3.20E-01 || 8.64
|-
! X - 04494
| 9.40E-02 || 2.538
|-
! linoleate (18:2n6)
| 8.20E-01 || 22.14
|-
! mannose
| 2.00E-01 || 5.4
|}

mit den p-Werten hat man die p*-Werte berechnet und dann mit dem Signifikanzniveau 0.05 verglichen. Der einzig signifikante Wert ist C-mannoysltryptophan.

'''Benjamini-Hochberg Prozedur:'''

{| class="wikitable sortable"
! Metabolit !! P !! Rang !! BHKW !! Differenz
|-
! C-mannosyltryptophan
| 1.10E-03 || 1 || 0.0019 || -0.0008
|-
! pseudouridine
| 3.70E-03 || 2 || 0.0037 || 0
|-
! N-acetylornithine
| 4.50E-03 || 3 || 0.0056 || -0.0011
|-
! 4-androsten-3beta,17beta-diol disulfate 2*
| 5.30E-03 || 4 || 0.0074 || -0.0021
|-
! 5alpha-pregnan-3beta,20alpha-diol disulfate
| 1.30E-02 || 5 || 0.0093 || 0.0037
|-
! O-sulfo-L-tyrosine
| 1.40E-02 || 6 || 0.0111 || 0.0029
|-
! X - 12216
| 1.50E-02 || 7 || 0.013 || 0.002
|-
! erythronate*
| 2.80E-02 || 8 || 0.0148 || 0.0132
|-
! 1-docosahexaenoylglycerophosphocholine*
| 3.90E-02 || 9 || 0.0167 || 0.0223
|-
! N-acetylalanine
| 4.00E-02 || 10 || 0.0185 || 0.0215
|-
! kynurenine
| 4.60E-02 || 11 || 0.0204 || 0.0256
|-
! 4-acetamidobutanoate
| 5.30E-02 || 12 || 0.0222 || 0.0308
|-
! N1-methyladenosine
| 5.50E-02 || 13 || 0.0241 || 0.0309
|-
! X - 04494
| 9.40E-02 || 14 || 0.0259 || 0.0681
|-
! erythritol
| 1.20E-01 || 15 || 0.0278 || 0.0922
|-
! N-acetylornithine
| 1.30E-01 || 16 || 0.0296 || 0.1004
|-
! X - 12092
| 1.90E-01 || 17 || 0.0315 || 0.1585
|-
! mannose
| 2.00E-01 || 18 || 0.0333 || 0.1667
|-
! homocitrulline
| 2.50E-01 || 19 || 0.0352 || 0.2148
|-
! N-acetylthreonine
| 2.70E-01 || 20 || 0.037 || 0.233
|-
! margarate (17:0)
| 2.80E-01 || 21 || 0.0389 || 0.2411
|-
! bradykinin, des-arg(9)
| 3.20E-01 || 22 || 0.0407 || 0.2793
|-
! 15-methylpalmitate (isobar with 2- methylpalmitate)
| 4.70E-01 || 23 || 0.0426 || 0.4274
|-
! eicosenoate (20:1n9 or 11)
| 4.80E-01 || 24 || 0.0444 || 0.4356
|-
! linoleate (18:2n6)
| 8.20E-01 || 25 || 0.0463 || 0.7737
|-
! dihomo-linoleate (20:2n6)
| 8.60E-01 || 26 || 0.0481 || 0.8119
|-
! 10-nonadecenoate (19:1n9)
| 8.90E-01 || 27 || 0.05 || 0.84
|}

Hier ist der Cutoff bei Rang 4. Dieser Wert und alle darüber sind somit signifikant.

Unterschiede: Durch BH werden deutlich mehr Metabolite als signifikant eingestuft, der Aufwand ist jedoch größer. Bonferroni liefert eindeutige Ergebnisse (signifikante Metabolite von Bonferroni sind immer in den signifikanten Metaboliten von BH enthalten).

6.Normalisierungen

2021-01-31T18:36:25Z

Mka: /* b: Wieso wird die Normalisierung bei RNASeq-Proben angewendet? */

==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} </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} = 0,0397 </math>
{| class="wikitable center"
|-
! Gen !! RPKM Replikat 1 !! RPKM Replikat 2
|-
| A || 0,0397 || 0,0381
|-
| B || 0,0463 || 0,05
|-
| C || 0,2222 || 0,2667
|-
| D || 0,0022 || 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 kbp 
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 = Set 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

6.Normalisierungen

2021-01-31T18:34:35Z

Mka: /* c: Anwendungsbereich */

==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} </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} = 0,0397 </math>
{| class="wikitable center"
|-
! Gen !! RPKM Replikat 1 !! RPKM Replikat 2
|-
| A || 0,0397 || 0,0381
|-
| B || 0,0463 || 0,05
|-
| C || 0,2222 || 0,2667
|-
| D || 0,0022 || 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 kbp 
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?==
TMM wird für die Normalisierung von RNASeq-Daten angewendet, um die Expression eines Gens unter verschiedenen Bedingungen zu vergleichen (Bspw, ob es in Krebszellen stärker oder schwächer exprimiert wird als in gesunden Zellen)

==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 = Set 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

6.Normalisierungen

2021-01-31T18:33:58Z

Mka: /* b: Normalisierung mit TPM */

==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} </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} = 0,0397 </math>
{| class="wikitable center"
|-
! Gen !! RPKM Replikat 1 !! RPKM Replikat 2
|-
| A || 0,0397 || 0,0381
|-
| B || 0,0463 || 0,05
|-
| C || 0,2222 || 0,2667
|-
| D || 0,0022 || 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 kbp 
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 eines Experiments.

==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?==
TMM wird für die Normalisierung von RNASeq-Daten angewendet, um die Expression eines Gens unter verschiedenen Bedingungen zu vergleichen (Bspw, ob es in Krebszellen stärker oder schwächer exprimiert wird als in gesunden Zellen)

==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 = Set 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