Lesedauer 5 Minuten

Du möchtest mit Arrays in Python 3 arbeiten, weißt aber nicht, welche Funktionen dir zur Verfügung stehen? Dann bist du hier richtig! In diesem Artikel zeige ich dir alle wichtigen Array-Funktionen und -Methoden, die dir Python 3 bietet.

Was sind Arrays in Python?
Listen-Methoden und -Funktionen
- 1. list.append() – Element hinzufügen
Python: Built-in Funktionen für Listen/Arrays
Das Python array-Modul für typisierte Arrays
NumPy Arrays – Die Performance-Alternative
List Comprehension – Arrays elegant erstellen
Slicing – Teile von Arrays extrahieren
Best Practices beim Arbeiten mit Arrays
Fazit

Was sind Arrays in Python?

Arrays sind Datenstrukturen, die mehrere Werte des gleichen Typs speichern. Python unterscheidet dabei zwischen verschiedenen Array-Typen: Listen, dem array-Modul und NumPy-Arrays. In diesem Guide fokussieren wir uns auf alle Varianten.

# Liste (meist verwendete Variante)
meine_liste = [1, 2, 3, 4, 5]

# Array-Modul
import array
mein_array = array.array('i', [1, 2, 3, 4, 5])

# NumPy Array
import numpy as np
numpy_array = np.array([1, 2, 3, 4, 5])

# Liste (meist verwendete Variante)

meine_liste = [1, 2, 3, 4, 5]

# Array-Modul

import array

mein_array = array.array('i', [1, 2, 3, 4, 5])

# NumPy Array

import numpy as np

numpy_array = np.array([1, 2, 3, 4, 5])

Listen-Methoden und -Funktionen

Listen sind die wichtigsten Array-ähnlichen Strukturen in Python. Lass mich dir alle Methoden zeigen.

1. list.append() – Element hinzufügen

Mit append() fügst du ein Element am Ende der Liste hinzu:

meine_liste = [1, 2, 3]
meine_liste.append(4)
print(meine_liste)  # [1, 2, 3, 4]

meine_liste = [1, 2, 3]

meine_liste.append(4)

print(meine_liste) # [1, 2, 3, 4]

Das ist die häufigste Methode, um Elemente zu einer Liste hinzuzufügen.

2. list.extend() – Mehrere Elemente hinzufügen

extend()

fügt alle Elemente einer anderen Sequenz hinzu:

meine_liste = [1, 2, 3]
meine_liste.extend([4, 5, 6])
print(meine_liste)  # [1, 2, 3, 4, 5, 6]

meine_liste = [1, 2, 3]

meine_liste.extend([4, 5, 6])

print(meine_liste) # [1, 2, 3, 4, 5, 6]

Das ist effizienter als mehrfach append() zu nutzen!

3. list.insert() – Element an Position einfügen

Mit insert() fügst du ein Element an einer bestimmten Position ein:

meine_liste = [1, 2, 4, 5]
meine_liste.insert(2, 3)
print(meine_liste)  # [1, 2, 3, 4, 5]

meine_liste = [1, 2, 4, 5]

meine_liste.insert(2, 3)

print(meine_liste) # [1, 2, 3, 4, 5]

Beachte, dass die Index ab 0 zählt.

4. list.remove() – Element nach Wert entfernen

remove()

löscht das erste Vorkommen eines Wertes:

meine_liste = [1, 2, 3, 2, 4]
meine_liste.remove(2)
print(meine_liste)  # [1, 3, 2, 4]

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

meine_liste.remove(2)

print(meine_liste) # [1, 3, 2, 4]

Wenn das Element nicht existiert, wirft Python eine ValueError-Exception.

5. list.pop() – Element nach Index entfernen

Mit pop() entfernst du ein Element an einem bestimmten Index:

meine_liste = [1, 2, 3, 4, 5]
entferntes = meine_liste.pop(2)
print(entferntes)   # 3
print(meine_liste)  # [1, 2, 4, 5]

meine_liste = [1, 2, 3, 4, 5]

entferntes = meine_liste.pop(2)

print(entferntes) # 3

print(meine_liste) # [1, 2, 4, 5]

Ohne Index entfernt es das letzte Element:

meine_liste = [1, 2, 3, 4, 5]
letztes = meine_liste.pop()
print(letztes)      # 5
print(meine_liste)  # [1, 2, 3, 4]

meine_liste = [1, 2, 3, 4, 5]

letztes = meine_liste.pop()

print(letztes) # 5

print(meine_liste) # [1, 2, 3, 4]

6. list.clear() – Liste leeren

clear()

entfernt alle Elemente aus der Liste:

meine_liste = [1, 2, 3, 4, 5]
meine_liste.clear()
print(meine_liste)  # []

meine_liste = [1, 2, 3, 4, 5]

meine_liste.clear()

print(meine_liste) # []

7. list.index() – Index eines Elements finden

Mit index() findest du den Index eines Elements:

meine_liste = [10, 20, 30, 40, 50]
index = meine_liste.index(30)
print(index)  # 2

meine_liste = [10, 20, 30, 40, 50]

index = meine_liste.index(30)

print(index) # 2

Du kannst auch Start- und Endbereiche angeben:

meine_liste = [1, 2, 3, 2, 4]
index = meine_liste.index(2, 2)  # Suche ab Index 2
print(index)  # 3

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

index = meine_liste.index(2, 2) # Suche ab Index 2

print(index) # 3

8. list.count() – Element-Häufigkeit zählen

count()

zählt, wie oft ein Element in der Liste vorkommt:

meine_liste = [1, 2, 2, 3, 2, 4]
anzahl = meine_liste.count(2)
print(anzahl)  # 3

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

anzahl = meine_liste.count(2)

print(anzahl) # 3

9. list.sort() – Liste sortieren

Mit sort() sortierst du die Liste in-place:

meine_liste = [3, 1, 4, 1, 5, 9]
meine_liste.sort()
print(meine_liste)  # [1, 1, 3, 4, 5, 9]

meine_liste = [3, 1, 4, 1, 5, 9]

meine_liste.sort()

print(meine_liste) # [1, 1, 3, 4, 5, 9]

Rückwärts sortieren mit reverse=True:

meine_liste = [3, 1, 4, 1, 5, 9]
meine_liste.sort(reverse=True)
print(meine_liste)  # [9, 5, 4, 3, 1, 1]

meine_liste = [3, 1, 4, 1, 5, 9]

meine_liste.sort(reverse=True)

print(meine_liste) # [9, 5, 4, 3, 1, 1]

10. list.reverse() – Liste umkehren

reverse()

dreht die Reihenfolge um:

meine_liste = [1, 2, 3, 4, 5]
meine_liste.reverse()
print(meine_liste)  # [5, 4, 3, 2, 1]

meine_liste = [1, 2, 3, 4, 5]

meine_liste.reverse()

print(meine_liste) # [5, 4, 3, 2, 1]

11. list.copy() – Flache Kopie erstellen

Mit copy() erstellst du eine unabhängige Kopie:

original = [1, 2, 3, 4, 5]
kopie = original.copy()
kopie[0] = 99
print(original)  # [1, 2, 3, 4, 5]
print(kopie)     # [99, 2, 3, 4, 5]

original = [1, 2, 3, 4, 5]

kopie = original.copy()

kopie[0] = 99

print(original) # [1, 2, 3, 4, 5]

print(kopie) # [99, 2, 3, 4, 5]

Python: Built-in Funktionen für Listen/Arrays

len() – Länge bestimmen

Finde die Anzahl der Elemente:

meine_liste = [1, 2, 3, 4, 5]
print(len(meine_liste))  # 5

meine_liste = [1, 2, 3, 4, 5]

print(len(meine_liste)) # 5

min() und max() – Kleinste und größte Werte

meine_liste = [3, 1, 4, 1, 5, 9]
print(min(meine_liste))  # 1
print(max(meine_liste))  # 9

meine_liste = [3, 1, 4, 1, 5, 9]

print(min(meine_liste)) # 1

print(max(meine_liste)) # 9

sum() – Summe berechnen

meine_liste = [1, 2, 3, 4, 5]
print(sum(meine_liste))  # 15

meine_liste = [1, 2, 3, 4, 5]

print(sum(meine_liste)) # 15

sorted() – Sortierte Kopie

Anders als sort() erstellt sorted() eine neue Liste:

meine_liste = [3, 1, 4, 1, 5, 9]
sortiert = sorted(meine_liste)
print(meine_liste)  # [3, 1, 4, 1, 5, 9] - unverändert
print(sortiert)     # [1, 1, 3, 4, 5, 9]

meine_liste = [3, 1, 4, 1, 5, 9]

sortiert = sorted(meine_liste)

print(meine_liste) # [3, 1, 4, 1, 5, 9] - unverändert

print(sortiert) # [1, 1, 3, 4, 5, 9]

enumerate() – Mit Indizes iterieren

enumerate()

gibt dir Index und Wert beim Iterieren:

meine_liste = ['a', 'b', 'c']
for index, wert in enumerate(meine_liste):
    print(f"{index}: {wert}")
# 0: a
# 1: b
# 2: c

meine_liste = ['a', 'b', 'c']

for index, wert in enumerate(meine_liste):

print(f"{index}: {wert}")

# 0: a

# 1: b

# 2: c

zip() – Mehrere Listen kombinieren

Mit zip() kombinierst du Listen element-weise:

liste1 = [1, 2, 3]
liste2 = ['a', 'b', 'c']
kombiniert = list(zip(liste1, liste2))
print(kombiniert)  # [(1, 'a'), (2, 'b'), (3, 'c')]

liste1 = [1, 2, 3]

liste2 = ['a', 'b', 'c']

kombiniert = list(zip(liste1, liste2))

print(kombiniert) # [(1, 'a'), (2, 'b'), (3, 'c')]

reversed() – Liste rückwärts iterieren

meine_liste = [1, 2, 3, 4, 5]
for element in reversed(meine_liste):
    print(element)
# 5, 4, 3, 2, 1

meine_liste = [1, 2, 3, 4, 5]

for element in reversed(meine_liste):

print(element)

# 5, 4, 3, 2, 1

Das Python array-Modul für typisierte Arrays

Python bietet auch das array-Modul für typisierte Arrays mit besserer Speichereffizienz:

import array
mein_array = array.array('i', [1, 2, 3, 4, 5])

import array

mein_array = array.array('i', [1, 2, 3, 4, 5])

Die Methoden ähneln Listen-Methoden:

mein_array.append(6)      # Element hinzufügen
mein_array.extend([7, 8]) # Mehrere hinzufügen
mein_array.pop()          # Entfernen
mein_array.count(3)       # Häufigkeit zählen

mein_array.append(6) # Element hinzufügen

mein_array.extend([7, 8]) # Mehrere hinzufügen

mein_array.pop() # Entfernen

mein_array.count(3) # Häufigkeit zählen

Typcode ‘i’ ist für Integer. Andere Typecodes: ‘f’ für Float, ‘d’ für Double, ‘b’ für Byte.

NumPy Arrays – Die Performance-Alternative

Für wissenschaftliche Berechnungen sind NumPy-Arrays ideal:

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

# Grundlegende Operationen
print(arr.shape)      # (5,)
print(arr.size)       # 5
print(arr.dtype)      # int64

# Mathematische Operationen
print(arr * 2)        # [2 4 6 8 10]
print(arr.sum())      # 15
print(arr.mean())     # 3.0
print(arr.std())      # Standardabweichung

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

# Grundlegende Operationen

print(arr.shape) # (5,)

print(arr.size) # 5

print(arr.dtype) # int64

# Mathematische Operationen

print(arr * 2) # [2 4 6 8 10]

print(arr.sum()) # 15

print(arr.mean()) # 3.0

print(arr.std()) # Standardabweichung

List Comprehension – Arrays elegant erstellen

Erstelle Arrays mit Comprehension:

# Quadrate von 0 bis 9
quadrate = [x**2 for x in range(10)]
print(quadrate)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Mit Bedingung
gerade = [x for x in range(10) if x % 2 == 0]
print(gerade)  # [0, 2, 4, 6, 8]

# Quadrate von 0 bis 9

quadrate = [x**2 for x in range(10)]

print(quadrate) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Mit Bedingung

gerade = [x for x in range(10) if x % 2 == 0]

print(gerade) # [0, 2, 4, 6, 8]

Slicing – Teile von Arrays extrahieren

Mit Slicing greifst du auf Teile einer Liste zu:

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

print(meine_liste[2:5])      # [2, 3, 4]  # Slice mit Start 3. und Ende 5. Element
print(meine_liste[:3])       # [0, 1, 2]  # Die ersten 3
print(meine_liste[5:])       # [5, 6, 7, 8, 9]  # Die letzten 5
print(meine_liste[::2])      # [0, 2, 4, 6, 8]  # Jedes 2. Element, Start mit 1. Element.
print(meine_liste[::-1])     # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] # Array umkehren

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

print(meine_liste[2:5]) # [2, 3, 4] # Slice mit Start 3. und Ende 5. Element

print(meine_liste[:3]) # [0, 1, 2] # Die ersten 3

print(meine_liste[5:]) # [5, 6, 7, 8, 9] # Die letzten 5

print(meine_liste[::2]) # [0, 2, 4, 6, 8] # Jedes 2. Element, Start mit 1. Element.

print(meine_liste[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] # Array umkehren

print(meine_liste[::2]) nutzt Slicing mit einem Step-Wert.

Die Syntax für Slicing ist: liste[start:stop:step]

Bei [::2] bedeutet das:

start ist leer → beginne am Anfang (Index 0)
stop ist leer → gehe bis zum Ende
step ist 2 → nimm jeden 2. Index

So wird auch das letzte Beispiel klar. Es wird mit einem negativen Step über das gesamte Array iteriert. Das Ergebnis ist ein umgekehrtes Array.

Best Practices beim Arbeiten mit Arrays

Hier sind die wichtigsten Tipps:

Nutze Listen als Standard-Array – sie sind flexibel und benutzerfreundlich.
Verwende extend() statt wiederholter append()-Aufrufe – das ist effizienter.
Nutze List Comprehension – für lesbareren und schnelleren Code.
Nutze NumPy für große numerische Datenmengen – deutlich bessere Performance.
Verwende enumerate() beim Iterieren mit Indizes– pythonischer als Range-Schleifen.
Beachte flache Kopien – bei verschachtelten Arrays brauchst du copy.deepcopy().

Fazit

Arrays sind fundamental für Python-Programmierung. Mit Listen, dem array-Modul und NumPy hast du alle Tools, die du brauchst. Praktiziere diese Methoden und Funktionen, um effizientere und elegantere Python-Code zu schreiben!

Mehr zu Arrays in der Praxis:

Lese hier, wie Du in Python verschiedene Arten von Warteschlangen (Queues) programmieren kannst

Hat Dir der Beitrag gefallen?

Wenn Du Fragen oder Anmerkungen zu diesem Beitrag hast, dann starte einen Kommentar. DANKE für Dein Feedback!

GRATIS: Hol Dir Pulse², die App zu meinem Blog.

Name	Borlabs Cookie
Anbieter	Eigentümer dieser Website, keine Übermittlung von Daten and Dritte, Impressum
Zweck	Speichert die Einstellungen der Besucher, die in der Cookie Box ausgewählt wurden.
Cookie Name	borlabs-cookie
Cookie Laufzeit	1 Jahr

Name	Wordpress Application Firewall
Anbieter	Eigentümer dieser Website, keine Übermittlung von Daten and Dritte.
Zweck	Essentielles Session-Cookie um die Sicherheit unserer Website zu gewährleisten. Identifiziert den Besucher anhand einer anonymen ID um mehrfache Hackversuche wiederkehrender Besucher zu verhindern.
Cookie Name	icwp-wpsf

Name	Wordpress Login Session
Anbieter	Eigentümer dieser Website, keine Übermittlung von Daten and Dritte.
Zweck	Dieses Session Cookie speichert den Zustand unseres Login-Bereichs, um festzustellen ob ein User eingeloggt ist oder nicht.
Cookie Name	swpm_session

Name	PHP Session ID
Anbieter	Eigentümer dieser Website, keine Übermittlung von Daten and Dritte
Zweck	Dieses Session-Cookie wird benötigt um die einwandfreie Navigation auf unseren Seiten zu gewährleisten. Es identifiziert den Besucher anhand einer anonymen ID.
Cookie Name	PHPSESSID

Name	WooCommerce
Anbieter	Eigentümer dieser Website, keine Übermittlung von Daten and Dritte
Zweck	Dieses Cookie wird zur Funktionalität des WooCommerce Onlineshops benötigt.
Cookie Name	woocommerce_cart_hash, tk_ai

Akzeptieren	Google Analytics
Name	Google Analytics
Anbieter	Google Ireland Limited, Gordon House, Barrow Street, Dublin 4, Ireland
Zweck	Cookie von Google für Website-Analysen. Erzeugt statistische, anonymisierte Daten darüber, wie der Besucher die Website nutzt. Google Analytics hilft uns, unser Angebot auf unsere Besucher besser abstimmen zu können.
Datenschutzerklärung	https://policies.google.com/privacy
Cookie Name	_ga,_gat,_gid
Cookie Laufzeit	1 Jahre

Akzeptieren	Vimeo
Name	Vimeo
Anbieter	Vimeo Inc., 555 West 18th Street, New York, New York 10011, USA
Zweck	Wird verwendet, um Vimeo-Inhalte zu entsperren.
Datenschutzerklärung	https://vimeo.com/privacy
Host(s)	player.vimeo.com
Cookie Name	vuid
Cookie Laufzeit	2 Jahre

Akzeptieren	YouTube
Name	YouTube
Anbieter	Google Ireland Limited, Gordon House, Barrow Street, Dublin 4, Ireland
Zweck	Wird verwendet, um YouTube-Inhalte zu entsperren.
Datenschutzerklärung	https://policies.google.com/privacy
Host(s)	google.com
Cookie Name	NID
Cookie Laufzeit	6 Monate

Python Arrays: Array-Funktionen in Python 3, das ultimative Cheat-Sheet

Was sind Arrays in Python?

Listen-Methoden und -Funktionen

1. list.append() – Element hinzufügen

2. list.extend() – Mehrere Elemente hinzufügen

3. list.insert() – Element an Position einfügen

4. list.remove() – Element nach Wert entfernen

5. list.pop() – Element nach Index entfernen

6. list.clear() – Liste leeren

7. list.index() – Index eines Elements finden

8. list.count() – Element-Häufigkeit zählen

9. list.sort() – Liste sortieren

10. list.reverse() – Liste umkehren

11. list.copy() – Flache Kopie erstellen

Python: Built-in Funktionen für Listen/Arrays

len() – Länge bestimmen

min() und max() – Kleinste und größte Werte

sum() – Summe berechnen

sorted() – Sortierte Kopie

enumerate() – Mit Indizes iterieren

zip() – Mehrere Listen kombinieren

reversed() – Liste rückwärts iterieren

Das Python array-Modul für typisierte Arrays

NumPy Arrays – Die Performance-Alternative

List Comprehension – Arrays elegant erstellen

Slicing – Teile von Arrays extrahieren

Best Practices beim Arbeiten mit Arrays

Fazit

Hat Dir der Beitrag gefallen?