Listen¶

(Fortgeschrittene)

Nachdem wir die Grundlagen von Listen schon kennen gelernt haben, wollen wir uns hier mit Details beschäftigen. Als erstes sollen verschiedene Möglichkeiten der Listenerstellung bzw. deren Initialisierung gezeigt werden. Danach werden verschieden Themen angesprochen. Das Theme Indexierung und Slicing werden wir ausführlich besprechen, weil es besonders wichtig ist. Zum Schluss soll das Anwenden von BuiltIn Funktionen und Klassenmethoden gezeigt werden.

Fortgeschrittene Techniken¶

Listen anlegen¶

Durch das Kombinieren verschiedener Sprachelemente, Operatoren und Built-In Funktionen, können Listen in Python erzeugt werden.

Wir können eine Liste von Strings erzeugen in dem wir den * Operator verwenden. Die Liste ist also mit einem Defaultelement initialisiert.

list_ = ['a']*5
list_

['a', 'a', 'a', 'a', 'a']

Als Variablenamen haben wir list_ verwendet, da list selbst ein Schlüsselwort ist. In Python ist es dann üblich eine Variable mit Unterstrich zu verwenden.

Dasselbe Vorgehen ist mit Zahlen möglich.

list_ = [0]*10
list_

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Wollen wir einen Bereich von Zahlen definieren können wir dazu list() und range() verwenden.

list_ = list(range(0,10))
list_

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list_ = list(range(9,-1,-1))
list_

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Dasselbe Ergebnis können wir mit einer einfachen for-Schleife errreichen.

list1 = [i for i in range(0,10)]
list1

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Dieses Muster ist geeignet um eine Liste mit einer flexiblen Initialisierung zu erreichen.

list1 = [i*i for i in range(0,10)]
list1

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

list1 = [i%2 for i in range(0,10)]
list1

[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

Listen sind geordnet¶

Listen sind geordnete Objekte. Das können wir mit dem Oeprator == überprüfen.

list1 = ['a', 'b', 'c']
list2 = ['a', 'b', 'c']

list1 == list2

True

Wir sehen also, dass Python beide Listen als gleich ansieht. Wenn wir dageben die Element in list2 anders anordnen, so werden diese Listen als verschieden angegesehen.

list1 = ['a', 'b', 'c']
list2 = ['c', 'b', 'a']

list1 == list2

False

Erzeugen wir mit list2[::-1] eine Umkehrung der Elemente, so werden die beiden Liste wieder als diesselben angesehen.

list1 == list2[::-1]

True

Listen mit willkürlichen Objekten¶

Oft beinhalten Listen Objekte des gleichen Datentyps, z.B. nur Zahlen.

list1 = [1, 2, 3, 4]
list1

[1, 2, 3, 4]

Eine Liste kann aber verschiedene Datentype gleichzeitig beinhalten.

list1 = ['int', 1, 'float', 2.0, 'complex', 1+2j, 'boolean', True, None]
list1

['int', 1, 'float', 2.0, 'complex', (1+2j), 'boolean', True, None]

Indexierung und Schneiden¶

Die Indexierung und das Schneiden (engl. Indexing and Slicing) sollte in jedem Fall genau studiert werden.

Definieren wir eine Liste mit Zahlen von 0 bis 4.

l = [0, 1, 2, 3, 4]
print(l)
print(len(l))

[0, 1, 2, 3, 4]
5

Die Liste hat also 5 Elemente mit den Einträgen von 0 bis 4.

Auf das erste Element können wir mit dem Index 0 zugreifen.

l[0]

Wollen wir das 2, 3 und 4 Element gemeinsam selektieren, so können wir das mit der Synthax 1:4 erreichen. Die Zählung beginnt in Python mit Null.

l[1:4]

[1, 2, 3]

Oft sind wir nur an dem vordernen oder dem hinteren Teil einer Liste interessiert.

l[1:]

[1, 2, 3, 4]

l[:4]

[0, 1, 2, 3]

Mit der Synthax [:] ist es auch möglich alle Elemente gemeinsam selektieren.

l[:]

[0, 1, 2, 3, 4]

Diese Synthax erscheint auf den ersten Blick sinnlos, da wir wieder die ursprüngliche Liste erhalten. Ein Überprüfung der Adresse zeigt uns jedoch den Unterschied. Mit [:] wurde eine neue Liste erzeugt.

print(l)
print(l[:])
print(id(l))
print(id(l[:]))

[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
139820714777152
139820453997568

l[::2]

[0, 2, 4]

l[0:4:2]

Um auf des letzte bzw. auf das vorletze Element zuzugreifen, könnten wir versucht sein, das mit len(l)-1 zu erreichen.

l[len(l)-1]

l[len(l)-2]

Dieses Vorgehen ist gültig und liefert das geschwünscht Ergebnis, jedoch gibt es einen eleganteren Weg. Python erlaubt das Verwenden eines negativen Indexes. Somit können wir mit -1 und -2 das letzte und das vorletze Element selektieren.

l[-1]

l[-2]

Die Umkehrung der Liste ist uns schon bekannt.

l[::-1]

[4, 3, 2, 1, 0]

Mit der Syntax des doppelten Doppelpunktes kann auch wieder die Schrittweite gesteuert werden.

l[-1:-4:-2]

[4, 2]

Entpacken von Listen¶

Listen lassen sich auf Vielfältige Weise entpacken. Zum Beipiel können wir für jedes Element eine eigene Variable definieren.

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

'a'

Mit dem * Operator können wir gezielt Listen in Teile zerlegen. Also jene Elemente welche eine eigene Variable bekommen und dem Rest.

list1 = ['a','b','c','d']
*head, tail = list1
print(head)
print(tail)

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

list1 = ['a','b','c','d']
head, *tail = list1
print(head)
print(tail)

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

Sind wir an dem Rest nicht interessiert, so können wir wie üblich den Unterstrich _ als Platzhalter verwenden.

list1 = ['a','b','c','d']
head, *_, tail = list1
print(head)
print(tail)

a
d

_, _, _, d = list1
d

'd'

Listen (in und not in)¶

Die Operatoren in und not in erlauben das Überprüfen einer Liste auf das Vorhanden sein von Elementen.

'a' in list1

True

'x' in list1

False

'a' not in list1

False

'x' not in list1

True

Liste von Listen¶

Eine Liste von Listen ist eine sehr praktische Strukture um Daten zu speichern.

list1 = [1]*5
list2 = [2]*3
list3 = [3]*7

list_all = [list1, list2, list3]
list_all

[[1, 1, 1, 1, 1], [2, 2, 2], [3, 3, 3, 3, 3, 3, 3]]

Verschachtelte Listen¶

Auch verschachtelte Listen lassen sich erzeugen. Bei dieser Datenstruktur ist jedoch Vorsicht geboten. Wir können schnell den Überblick verlieren:

list1 = ['a', ['aa', ['aaa', 'bbb'], 'bb'], 'b']
list1

['a', ['aa', ['aaa', 'bbb'], 'bb'], 'b']

print(list1[0])
print(list1[1])
print(list1[2])

a
['aa', ['aaa', 'bbb'], 'bb']
b

print(list1[1][0])
print(list1[1][1])
print(list1[1][2])

aa
['aaa', 'bbb']
bb

'a' in list1

True

'aa' in list1

False

'aa' in list1[1]

True

Listen Elemente verändern¶

Die Elemente einer Liste können verändert werden.

list1 = ['a','b','c','d']
list1[0] = 'x'

Listen Methoden¶

Die Built-in Funktionen len(), min(), max() und list() werden oft mit Listen benutzt. Listen besitzen auch eine Vielzahl von Klassen Methoden. Wir können wieder dir() nutzen, um alle Methoden der List-Klasse zu bekommen.

def get_all_class_methods(class_):
    """ get all class methods, using dir"""
    list_methods = [name for name in dir(class_) if name.islower() and name[0] !='_']
    return list_methods


list_methods = get_all_class_methods(list)

print(len(list_methods))
print(list_methods)

11
['append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Name	Typ	Operation	Beschreibung
len()	Built-In		Länge der Liste
min()	Built-In		Element welches dem Minimum entspricht
max()	Built-In		Element welches dem Maximum entspricht
list()	Built-In	Erzeugt	Erzeugt eine Liste
append()	Methode	Hinzufügen	Hinzufügen von Element
extend()	Methode	Hinzufügen	Hinzufügen von Element
insert()	Methode	Hinzufügen	Hinzufügen von Element
pop()	Methode	Entfernen	Entfernt Elemente
remove()	Methode	Entfernen	Entfernt Elemente
clear()	Methode	Entfernen	Leert die Liste
del	Schlüsselwort	Entfernen	Entfernt Elemente
copy()	Methode	Kopieren	Ezeugt eine flache Kopie
reverse()	Methode	Sonstiges	Erzeugt eine Umkehrung
sort()	Methode	Sonstiges	Sortiert die Liste
count()	Methode	Sonstiges	Zählen eines Elements
index()	Methode	Sonstiges	Sucht die Position eines Elementes

len()¶

Bemerkung

len() liefert die Länge der Liste. Wenn die Liste wieder Listen enthält dann wird die Unterliste als ein Element aufgefasst.

len(list)

list1 = [1, 2, 3, -2, -1]
print(len(list1))
list2 = [1, 2, 3, [-2, -1]]
print(len(list2))

5
4

min()¶

Bemerkung

min() liefert das Element welches dem Minimum entspricht. Die Elemente müssen vergleichbar sein, dass heißt vom selben Typ.

min(list)

list1 = [1, 2, 3, -2, -1]
print(min(list1))

-2

list1 = ['b', 'c', 'a', 'e', 'd']
print(min(list1))

max()¶

Bemerkung

min() liefert das Element welches dem Maximum entspricht. Die Elemente müssen vergleichbar sein, dass heißt vom selben Typ.

max(list)

list1 = [1, 2, 3, -2, -1]
print(max(list1))

list1 = ['b', 'c', 'a', 'e', 'd']
print(min(list1))

list()¶

Bemerkung

Die Built-In Funktion list() kann benutzt werden um ein List Objekt zu erzeugen. Wir können Listen zum Beispiel aus Tuple oder Strings erzeugen. Auch eine leere Liste kann erzeugt werden.

list(seq)

aTuple = ('Mechanik','Elektonik','Informatik')
list1 = list(aTuple)
list1

['Mechanik', 'Elektonik', 'Informatik']

str = "Hallo Welt!"
list(str)

['H', 'a', 'l', 'l', 'o', ' ', 'W', 'e', 'l', 't', '!']

empty = list()
empty

[]

append()¶

Bemerkung

Die append() Methode erlaubt das Anhängen von Objekten. Äquivalent zu l[len(l):] = [x].

list.append(x)

list1 = ['Mechanik','Elektonik']
print(list1)
list1.append('Informatik')
print(list1)

['Mechanik', 'Elektonik']
['Mechanik', 'Elektonik', 'Informatik']

list1 = ['Mechanik','Elektonik']
print(list1)
list1[len(list1):] = ['Informatik','Software']
print(list1)

['Mechanik', 'Elektonik']
['Mechanik', 'Elektonik', 'Informatik', 'Software']

list2 = ['a','b']
list2.append([1, 2, 3])
list2

['a', 'b', [1, 2, 3]]

list3 = ['a','b']
list3 = list3 + [[1, 2, 3]]
list3

['a', 'b', [1, 2, 3]]

list2 = ['a','b']
list2.append((1, 2, 3))
list2

['a', 'b', (1, 2, 3)]

list3 = ['a','b']
list3 = list3 + [(1, 2, 3)]
list3

['a', 'b', (1, 2, 3)]

list1 = [1]*5
list2 = [2]*5
list3 = [3]*5

list_all2 = []
list_all2.append(list1)
list_all2.append(list2)
list_all2.append(list3)
list_all2

[[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3]]

extend()¶

Bemerkung

Die extend() Methode verlängert eine vorhanden Liste.

list.extend(obj)

list1 = ['Mechanik','Elektonik','Informatik']
print(list1)
list2 = ['Kybernetik','Robotik']
list1.extend(list2)
print(list1)

['Mechanik', 'Elektonik', 'Informatik']
['Mechanik', 'Elektonik', 'Informatik', 'Kybernetik', 'Robotik']

list2 = ['a','b']
list2.extend([1, 2, 3])
list2

['a', 'b', 1, 2, 3]

list3 = ['a','b']
list3 += [1, 2, 3]
list3

['a', 'b', 1, 2, 3]

insert()¶

Bemerkung

Mit der insert() Methode können Elemente mit Hilfe eines Index eingefügt werden.

list.insert(i, x)

list1 = ['b','d']
list1.insert(0,'a')
list1.insert(2,'c')
list1

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

pop()¶

Bemerkung

pop() entfernt das letzte Element einer Liste. Wenn zusätzlich ein Index angegeben ist, wird stattdessen das zum Index gehörige Element entfernt.

list.pop([i])

list1 = ['Mechanik','Elektonik','Informatik']
list1.pop()
list1

['Mechanik', 'Elektonik']

list1 = ['Mechanik','Elektonik','Informatik']
list1.pop(1)
list1

['Mechanik', 'Informatik']

remove()¶

Bemerkung

remove() entfernt das erste Element aus der Liste, dessen Wert gleich x ist.

list.remove(x)

list1 = ['Mechanik','Elektonik','Informatik']
list1.remove('Elektonik')
list1

['Mechanik', 'Informatik']

list1 = ['Mechanik','Elektonik','Informatik','Elektonik']
list1.remove('Elektonik')
print(list1)
list1.remove('Elektonik')
print(list1)

['Mechanik', 'Informatik', 'Elektonik']
['Mechanik', 'Informatik']

clear()¶

Bemerkung

clear() entfernt alle Elemente aus der Liste. Mit del l[:] kann dasselbe erreicht werden.

list.clear()

list1 = ['Mechanik','Elektonik','Informatik']
print(list1)
list1.clear()
print(list1)

['Mechanik', 'Elektonik', 'Informatik']
[]

del¶

Bemerkung

del ist ein Schlüsselwort das mit Listen funktioniert. del l[[a]:[b]] entfernt alle Element welche sich im angegebenen Bereich befinden.

del l[[a]:[b]]

list1 = ['Mechanik','Elektonik','Informatik']
del list1[:]
list1

[]

list1 = ['Mechanik','Elektonik','Informatik']
del list1[1:]
list1

['Mechanik']

list1 = ['Mechanik','Elektonik','Informatik']
del list1[0]
list1

['Elektonik', 'Informatik']

copy()¶

Bemerkung

Die copy() Methode erzeugt eine flache Kopie der Liste. Äquivalent zu l[:].

list.reverse()

list1 = ['Mechanik','Elektonik','Informatik']
list2 = list1.copy()
print(list2)
print(id(list1))
print(id(list2))

['Mechanik', 'Elektonik', 'Informatik']
139967215677632
139967215677568

list1 = ['Mechanik','Elektonik','Informatik', [0, 1]]
list2 = list1.copy()
list1[0] = 'Robotik'
list1[3][0] = 'a'
print(list1)
print(list2)

['Robotik', 'Elektonik', 'Informatik', ['a', 1]]
['Mechanik', 'Elektonik', 'Informatik', ['a', 1]]

reverse()¶

Bemerkung

Die reverse() Methode erzeugt eine Umkehrung der Liste. Es sei darauf hingewiesen das die reverse() Methode None zurückgibt und die Liste selbst verändert. Man sagt auch diese Methode wirkt in-place.

list.reverse()

list1 = ['Mechanik','Elektonik','Informatik']
list1.reverse()
list1

['Informatik', 'Elektonik', 'Mechanik']

sort()¶

Bemerkung

Die sort() Methode sortiert die Liste. Es sei darauf hingewiesen das die sort() Methode None zurückgibt und die Liste selbst verändert. Man sagt auch diese Methode wirkt in-place.

list.sort([reverse=True])

list1 = ['Mechanik','Elektonik','Informatik']
list1.sort()
list1

['Elektonik', 'Informatik', 'Mechanik']

list1 = ['Mechanik','Elektonik','Informatik']
list1.sort(reverse=True)
list1

['Mechanik', 'Informatik', 'Elektonik']

count()¶

Bemerkung

Wir können die Methode count() verwenden um das Vorhanden sein eines Elements zu zählen.

list.count(obj)

list1 = ['Mechanik','Mechanik','Mechanik','Elektonik','Elektonik','Informatik']
print(list1.count('Mechanik'))
print(list1.count('Elektonik'))
print(list1.count('Informatik'))

3
2
1

index()¶

Bemerkung

Die index() Methode ist sinnvoll um die erste Instanz eines Elements zu finden.

list.index(obj)

list1 = ['Mechanik','Elektonik','Informatik','Mechanik','Elektonik','Informatik']
print(list1.index('Informatik'))

Python für die Kybernetik

Listen

Inhalt

Listen¶

Fortgeschrittene Techniken¶

Listen anlegen¶

Listen sind geordnet¶

Listen mit willkürlichen Objekten¶

Indexierung und Schneiden¶

Entpacken von Listen¶

Listen (in und not in)¶

Liste von Listen¶

Verschachtelte Listen¶

Listen Elemente verändern¶

Listen Methoden¶

len()¶

min()¶

max()¶

list()¶

append()¶

extend()¶

insert()¶

pop()¶

remove()¶

clear()¶

del¶

copy()¶

reverse()¶

sort()¶

count()¶

index()¶