In Python werden eine Reihe von geordneten Werten in Listen aufgelistet:

primären = [2, 3, 5, 7]

#Wir können auch Werte, die nicht Integers sind, in Listen aufzählen:

planeten = ["Merkur", "Venus", "Erde", "Mars", "Jupiter", "Saturn", "Uranus", "Neptun"]
#Lustigerweise können wir auch eine Liste aus Listen machen.

deck = [
["J", "Q", "K"],
["2", "2", "2"],
["6", "A", "K"], #Das Komma nach dem letzten Bestandteil der Liste ist optional
]
#Man könnte es statt pro Zeile auch in einer reihe schreiben, das macht es aber schwerer zu lesen.

das_was_ich_am_meisten_mag = [32, "raindrops on roses", help]

Du kannst die Individuellen werte der Liste innerhalb der eckigen Klammer auswählen.

Welcher Planet hat den wenigsten Abstand zur Sonne? Python nutzt zero-based Indexieren. Also der erste Wert hat den Index 0

planeten[0]
Merkur

Welcher ist gleich daneben?

planeten[1]
Venus

Welcher ist am weitesten von der Sonne entfernt?
Die Werte am ende der Liste können mit negativen Zahlen ausgewählt werden. Es fängt mit -1 an:

planeten[-1]
Neptun

planeten[-2]
Uranus

Was sind die ersten drei Planeten? Diese Frage können wir mit Slicing beantworten:

planeten[0:3]

["Merkur", "Venus", "Erde"]

Mit planeten[0:3] geben wir Python den Befehl, alle Indexes bis zu 3 (aber 3 nicht auflisten), anzuzeigen.
Man kann beide Indexe je nach bedarf ändern, wenn man aber den ersten Index auslässt, dann vermutet es das
der Anfangswert 0 ist, also könnten wir den Befehl so umschreiben:

planeten[:3]

["Merkur", "Venus", "Erde"]

Wenn ich den Letzten Index auslasse, nimmt es an, dass die gesamte Länge der Liste gemeint ist.

planeten[3:]

["Mars", "Jupiter", "Saturn", "Uranus", "Neptun"]

In anderen Worten bedeutet der obere Befehl "gib mir alle Planeten von Index 3".
Wir können auch negative Indexe zum slicen verwenden.

#Alle Planeten außer dem ersten oder dem letzten anzeigen
planeten[1:-1]

["Venus", "Erde", "Mars", "Jupiter", "Saturn", "Uranus"]

#Die letzten 3 Planeten
planeten[-3:]

["Saturn", "Uranus", "Neptun"]

Listen sind veränderlich also können wir sie ändern, ohne deren Platz zu ändern.
Slicen und Indexen Wert geben ist eine Art, Listen zu modifizieren.
Wir könnten zum Beispiel Mars umbenennen:

planeten[3] = "Malacandra"
planeten

[ "Merkur",
"Venus",
"Erde",
"Mars",
"Jupiter",
"Saturn",
"Uranus",
"Neptun"]

Naja, das ist äußerst viel. Kompensieren wir, indem wir die Namen der ersten 3 Planeten verkürzen.

planeten[:3] = ["Mer", "Ven", "Er"]
print(planeten)

#Das ist verwirrend. Geben wir den Planeten ihre alten Namen zurück

planeten[:4] = ["Merkur", "Venus", "Erde", "Mars"]

["Mer", "Ven", "Er", "Malacandra", "Jupiter", "Saturn", "Uranus", "Neptun"]



Python hat viele nützliche Funktionen, die mit Listen funktionieren.

len gibt die Länge der Liste an:

#Wie viele Planeten gibt es?
len(planeten)

8

sorted gibt eine sortierte Version einer Liste:

#Die Planeten werden in Alphabetischer Reihenfolge geordnet
sorted(planeten)

["Erde", "Jupiter", "Mars", "Merkur", "Neptun", "Saturn", "Uranus", "Venus"]

sum gibt dir die Summe der Liste wieder, hast du wahrscheinlich vom Namen schon erkannt:

primären = [2, 3, 5, 7]
sum(primären)

17

Wir haben schon einmal min und max verwendet, um die minimalen und maximalen Werte zu sortieren und dasselbe können wir mit Listen machen.

max(primären)

7



Wir haben schon öfters den Ausdruck Objekt verwendet und du hast vielleicht schon des Öfteren gelesen, dass alles in Python ein Objekt ist,
aber was genau bedeutet das?
Kurzgefasst, Objekte tragen Werte mit sich und du kannst auf sie zugreifen, in dem du Pythons "dot syntax" nutzt.
Wir können zum Beispiel Zahlen nehmen. Diese tragen in Python einen assoziiertes Variabel namens imag, welches den Imaginären Teil einer Zahl repräsentiert.

x = 12
#x ist eine Echte zahl, also ist der Imaginäre teil 0
print(x.imag)
#So macht man Komplexe zahlen, falls du dich je gewundert hast:

c = 12 + 3j
print(c.imag)

0
3.0

Objekte können mit Funktionen verbunden werden. Diese werden Methoden genannt (Sachen die keine Funktionen sind und auch verbunden sind heißen attribute).

Zum Beispiel numbers hat eine methode namens bit_length:

x.bit_length
<function int.bit_length()>
Um es wirklich aufzurufen, müssen wir Klammern einfügen:
x.bit_length()

4

Wenn du nicht weißt, was eine Methode macht, kannst du es in help reintuen:

help(x.bit_length)
Help on built-in function bit_length:

bit_length() method of builtins.int instance

Die Anzahl der Bits, die notwendig sind, um die ausgewählte Zahl in binär auszugeben.

Die obigen Beispiele sind sehr unbekannt und werden nicht sehr häufig verwendet.
Aber es stellt sich raus, dass es ein paar Methoden für Listen gibt, die man ständig nutzt.

list.append modifiziert eine Liste, indem es einen weiteren Wert am Ende einträgt:

#Pluto ist ein Planet!
planeten.append("Pluto")

Wieso hat die obere Zeile keinen Output? Lass uns mal help fragen.

WICHTIG:
Append ist eine Methode, die von allen Objekten des Listen Typs verwendet werden kann, jedoch
können wir nicht einfach help(append) ausführen. Python würde sich da nur beschweren und sagen,
dass es eine Variable namens append nicht findet. Das ist leider der Fall, weil append nur innerhalb
von Listen existieren kann und man müsste den help-Befehl so schreiben help(listenname.append)

help(planeten.append)

Help on built-in function append:

append(object, /) method of builtins.list instance

füge ein Objekt an am Ende der Liste ein.
Das -> None teilt uns mit, dass list.append nichts ins return schickt, aber wenn wir die Werte der
Planeten anschauen, sehen wir, dass die Liste modifiziert wurde:

planeten

[ "Merkur",
"Venus",
"Erde",
"Mars",
"Jupiter",
"Saturn",
"Uranus",
"Neptun",
"Pluto"]

list.pop löscht das letzte Element und schickt es ans return:

planeten.pop()

"Pluto"

planeten

["Merkur", "Venus", "Erde", "Mars", "Jupiter", "Saturn", "Uranus", "Neptun"]


Wir können herausfinden, wann die Erde in der Reihenfolge auftaucht. Das geht mithilfe von der list.index methode.

planeten.index("Erde")

2

Es ist an der dritten Stelle (Achtung, 0 ist die erste Stelle)

planeten.index("Pluto")
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
/tmp/ipykernel_20/2263615293.py in <module>
----> 1 planets.index('Pluto')

ValueError: 'Pluto' is not in list

stimmt…

Damit wir sowas vermeiden können, sollten wir es in Operanten verwenden. Dann beschränkt es sich nur auf die Werte in der Liste.

#Ist die Erde ein Planet?

"Erde" in planeten

True


#Ist Calbefraques ein Planet?

"Calbefraques" in planeten

False

Es gibt noch viele weitere bemerkenswerte List Methoden, die wir uns noch nicht angeschaut haben. Wenn du mehr darüber wissen willst,
kannst du es mit help herausfinden, bsp.: help(planeten) wird uns alle List Methoden zeigen. Man sollte eher die Methoden am Ende des
Befehls anschauen, da diese wichtiger sind (append, copy, clear, etc.).

Tuples sind fast identisch wie Listen, jedoch haben sie zwei Unterschiede:

1. Der Syntax zum Erstellen von Tuples nutzt Klammern anstelle von eckigen Klammern

t = (1, 2, 3)
t = 1, 2, 3 #bedeutet dasselbe wie das darüber
t
(1, 2, 3)

2. Man kann Tuples nicht Manipulieren (unveränderlich)

t[0] = 100
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
/tmp/ipykernel_20/816329950.py in <module>
----> 1 t[0] = 100

TypeError: 'tuple' object does not support item assignment

Tuples werden hauptsächlich für Funktionen mit mehreren return werten verwendet.

Die as_integer_ratio() Methode des floats, gibt den Zähler und den Nenner eines float Objekts wieder:

x = 0.125
x.as_integer_ratio()

(1, 8)

Man kann diese mehrfachen return Werte auch individuell einsetzen:

print(Zähler / Nenner)
0.125

Zuletzt zeigen wir dir noch einen klassischen, dummen Trick in Python, die Werte von 2 Variablen zu wechseln!

a = 1
b = 0
a, b = b, a
print(a, b)

0 1