Python-Arrays: Vollständiger Guide zu Listen, Tupeln und NumPy

1. Einführung

Python ist eine Programmiersprache mit einfacher und intuitiver Syntax, die in vielen Bereichen genutzt wird. Darunter spielt das „Array“ eine wichtige Rolle bei der Verwaltung und Manipulation von Daten.

Allerdings existiert in Python kein Array-Typ wie in der C-Sprache, stattdessen werden Listen (List) · Tupel (Tuple) · NumPy-Arrays (ndarray) und andere Datenstrukturen verwendet. Jede dieser Datenstrukturen hat unterschiedliche Eigenschaften und Anwendungen, weshalb die richtige Auswahl wichtig ist.

Was sind Arrays in Python?

• Listen (List): Veränderbar (modifizierbar) und mit hoher Flexibilität
• Tupel (Tuple): Unveränderlich (nicht modifizierbar) mit hoher Verarbeitungsgeschwindigkeit
• NumPy-Array (ndarray): Speziell für numerische Berechnungen und Datenanalyse optimiertes Array

In diesem Artikel bieten wir einen vollständigen Leitfaden zu Arrays in Python von den Grundlagen bis zur Anwendung. Um es für Anfänger verständlich zu machen, erklären wir es unter Einbeziehung konkreter Code-Beispiele.

2. Was ist ein Array in Python? (Liste, Tupel, NumPy)

Python bietet standardmäßig keinen Datentyp namens „Array“. Daher werden im Allgemeinen Listen (List) verwendet, um Daten wie Arrays zu behandeln.

Zusätzlich werden für unveränderbare Daten Tupel (Tuple) und für effiziente numerische Berechnungen NumPy ndarray eingesetzt.

Datenstrukturen, die als Arrays in Python verwendet werden

Grundlegende Verwendung von Listen, Tupeln und NumPy-Arrays

Python ermöglicht die Erstellung von Listen, Tupeln und NumPy-Arrays wie folgt.

import numpy as np

# Erstellung einer Liste
my_list = [1, 2, 3, 4, 5]

# Erstellung eines Tupels
my_tuple = (1, 2, 3, 4, 5)

# Erstellung eines NumPy-Arrays
my_array = np.array([1, 2, 3, 4, 5])

print(my_list)   # [1, 2, 3, 4, 5]
print(my_tuple)  # (1, 2, 3, 4, 5)
print(my_array)  # [1 2 3 4 5]

Unterschiede zwischen Listen, Tupeln und NumPy-Arrays

3. Listen (List) in Python verstehen

Die Listen (Lists) in Python sind eine Datenstruktur, die einem variablen (veränderbaren) Array ähnelt. Mit Listen können verschiedene Datentypen wie Zahlen oder Strings in einer einzigen Datenstruktur zusammengefasst und gespeichert werden. Listen sind eine der grundlegendsten und am häufigsten verwendeten Datenstrukturen in Python.

Grundlagen der Listen

Listen erstellen

In Python werden Listen mit eckigen Klammern [] erstellt.

# Eine leere Liste erstellen
empty_list = []

# Liste mit Zahlen
numbers = [1, 2, 3, 4, 5]

# Liste mit Strings
fruits = ["apple", "banana", "cherry"]

# Verschiedene Datentypen mischen ist möglich
mixed_list = [1, "hello", 3.14, True]

print(numbers)      # [1, 2, 3, 4, 5]
print(fruits)       # ['apple', 'banana', 'cherry']
print(mixed_list)   # [1, 'hello', 3.14, True]

Zugriff auf Listenelemente

Zu jedem Element einer Liste kann über den Index (Subskript) zugegriffen werden. Python-Indizes beginnen bei 0, und mit negativen Indizes kann auch von hinten zugegriffen werden.

fruits = ["apple", "banana", "cherry"]

# Element über Index abrufen
print(fruits[0])   # apple
print(fruits[1])   # banana

# Negativen Index verwenden (von hinten zugreifen)
print(fruits[-1])  # cherry
print(fruits[-2])  # banana

Listen-Slicing (Teilauswahl)

Mit Slicing (Slice) kann ein Teil einer Liste abgerufen werden.

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

# Die ersten 5 Elemente abrufen
print(numbers[:5])  # [0, 1, 2, 3, 4]

# Elemente vom 3. bis zum 7. abrufen
print(numbers[2:7])  # [2, 3, 4, 5, 6]

# Die letzten 3 Elemente abrufen
print(numbers[-3:])  # [7, 8, 9]

# Elemente mit Schrittweite 2 abrufen
print(numbers[::2])  # [0, 2, 4, 6, 8]

Ändern von Listenelementen

Da Listen mutable (veränderbar) sind, können Elemente geändert werden.

fruits = ["apple", "banana", "cherry"]

# Das 2. Element ändern
fruits[1] = "orange"
print(fruits)  # ['apple', 'orange', 'cherry']

Elemente zu Listen hinzufügen und entfernen

Elemente hinzufügen

In Python-Listen können Elemente mit append() oder insert() hinzugefügt werden.

fruits = ["apple", "banana"]

# Element ans Ende der Liste hinzufügen
fruits.append("cherry")
print(fruits)  # ['apple', 'banana', 'cherry']

# Element an bestimmter Position hinzufügen
fruits.insert(1, "orange")
print(fruits)  # ['apple', 'orange', 'banana', 'cherry']

Elemente entfernen

Um Elemente aus einer Liste zu entfernen, werden remove() oder pop() verwendet.

fruits = ["apple", "banana", "cherry"]

# Element mit bestimmtem Wert entfernen
fruits.remove("banana")
print(fruits)  # ['apple', 'cherry']

# Element mit bestimmtem Index entfernen
fruits.pop(1)
print(fruits)  # ['apple']

Listen verketten und kopieren

Listen verketten

Listen können mit dem +-Operator verkettet werden.

list1 = [1, 2, 3]
list2 = [4, 5, 6]

combined_list = list1 + list2
print(combined_list)  # [1, 2, 3, 4, 5, 6]

Listen kopieren

Beim Kopieren einer Liste ist es sicher, Slicing [:] zu verwenden.

original_list = [1, 2, 3]
copied_list = original_list[:]

print(copied_list)  # [1, 2, 3]

Zusammenfassung

• Listen sind variable Datenstrukturen, in denen Elemente hinzugefügt, entfernt und geändert werden können
• Zugriff auf Elemente über Indizes oder Slicing
• Effiziente Methoden für Listenoperationen (Hinzufügen, Entfernen, Verkettung, Sortieren usw.) gelernt

4. Das Tuple in Python verstehen

Das Tuple (Tuple) in Python ist eine Datenstruktur, die wie eine Liste mehrere Werte speichern kann, hat aber die Eigenschaft unveränderlich (immutable) zu sein.
Das bedeutet, dass die Elemente eines einmal erstellten Tuples nicht geändert, hinzugefügt oder gelöscht werden können.

Diese Eigenschaft macht Tuples nützlich in Situationen, in denen die Unveränderlichkeit der Daten gewährleistet werden muss. Zudem bieten sie Vorteile wie bessere Speichereffizienz und schnellere Verarbeitungsgeschwindigkeit im Vergleich zu Listen.

Grundlagen des Tuples

Erstellung eines Tuples

Tuples werden mit Rundklammern () erstellt.

# Erstellung eines Tuples
fruits = ("apple", "banana", "cherry")
numbers = (1, 2, 3, 4, 5)

print(fruits)   # ('apple', 'banana', 'cherry')
print(numbers)  # (1, 2, 3, 4, 5)

Erstellung eines Tuples mit einem Element

Beim Erstellen eines Tuples mit nur einem Element ist Vorsicht geboten. Ohne das Komma , wird es als einfacher Wert wie eine Zahl oder ein String behandelt.

single_value = (42)      # Kein Tuple, sondern eine Ganzzahl
correct_tuple = (42,)    # Dies ist ein Tuple

print(type(single_value))  # <class 'int'>
print(type(correct_tuple))  # <class 'tuple'>

Zugriff auf Tuple-Elemente

Zu den einzelnen Elementen eines Tuples kann man über den Index (Subskript) zugreifen. Wie bei Listen beginnen die Indizes in Python bei 0.

colors = ("red", "green", "blue")

# Zugriff über Index
print(colors[0])  # red
print(colors[1])  # green

# Verwendung negativer Indizes
print(colors[-1])  # blue
print(colors[-2])  # green

Slicing von Tuples (Teilauswahl)

Tuples können wie Listen geslicet (Teilauswahl) werden.

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

# Erste 5 Elemente abrufen
print(numbers[:5])  # (0, 1, 2, 3, 4)

Umwandlung zwischen Tuple und Liste

Tuples und Listen können mit tuple() oder list() in einander umgewandelt werden.

# Liste → Tuple
numbers_list = [1, 2, 3]
numbers_tuple = tuple(numbers_list)
print(numbers_tuple)  # (1, 2, 3)

# Tuple → Liste
fruits_tuple = ("apple", "banana", "cherry")
fruits_list = list(fruits_tuple)
print(fruits_list)  # ['apple', 'banana', 'cherry']

Zusammenfassung

• Tuples sind unveränderlich (immutable) und können nach der Erstellung nicht geändert werden
• Sie sind speichereffizienter und schneller als Listen
• Sie eignen sich für Fälle, in denen die Unveränderlichkeit der Daten gewährleistet werden muss (z. B. Konstanten, Schlüssel in Dictionaries, Rückgabewerte von Funktionen)
• Umwandlung zwischen Liste und Tuple ist möglich, aber bei Änderungsbedarf sollte eine Liste verwendet werden

5. [Vergleichstabelle] Liste vs Tupel – Welches sollte man verwenden?

In Python können sowohl Liste (List) als auch Tupel (Tuple) wie Arrays verwendet werden. Allerdings gibt es wichtige Unterschiede zwischen ihnen, es ist wichtig, sie angemessen zu unterscheiden.

Unterschiede zwischen Liste und Tupel

Zuerst fassen wir die Hauptunterschiede zwischen Liste und Tupel in einer Vergleichstabelle zusammen。

Die Unterscheidung zwischen Liste und Tupel

✅ Fälle, in denen eine Liste verwendet werden sollte

1. Wenn eine Änderung der Daten erforderlich ist

users = ["Alice", "Bob", "Charlie"]
users.append("David")  # Neuen Benutzer hinzufügen
print(users)  # ['Alice', 'Bob', 'Charlie', 'David']

2. Beim Umgang mit Daten variabler Länge

user_input = []
while True:
    data = input("Geben Sie Daten ein (Beenden: exit): ")
    if data == "exit":
        break
    user_input.append(data)
print(user_input)

✅ Fälle, in denen ein Tupel verwendet werden sollte

1. Daten, die nicht geändert werden dürfen

weekdays = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")

2. Beim Verwenden als Schlüssel in einem Dictionary

location_data = {
    (35.6895, 139.6917): "Tokyo",
    (40.7128, -74.0060): "New York"
}
print(location_data[(35.6895, 139.6917)])  # Tokyo

Zusammenfassung

• Die Liste ist variabel und eine Datenstruktur, die das Hinzufügen, Löschen und Ändern von Daten ermöglicht.
• Das Tupel ist unveränderlich und wird für Daten verwendet, die nicht geändert werden müssen, oder als Schlüssel in einem Dictionary.
• Beim Umgang mit dynamischen Daten ist die Liste geeigneter.

6. Anwendungen der Array-Operationen

Python-Listen (Lists) und Tupel (Tuples) geschickt zu nutzen, ermöglicht fortgeschrittene Datenverarbeitungen. In diesem Abschnitt werden erweiterte Techniken für Array-Operationen vorgestellt und für den Einsatz in praktischen Programmen nutzbar gemacht.

List Comprehension (Effizientes Erstellen von Listen)

# Normale Listen-Erstellung
squares = []
for x in range(10):
    squares.append(x**2)
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# List Comprehension
squares = [x**2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Umgang mit mehrdimensionalen Listen

# Erstellen einer 3x3-Matrix
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(matrix[0])  # [1, 2, 3]
print(matrix[1][2])  # 6

Umwandlung zwischen Listen und Dictionaries

# Umwandlung zweier Listen in ein Dictionary
keys = ["name", "age", "city"]
values = ["Alice", 25, "Tokyo"]
person_dict = dict(zip(keys, values))
print(person_dict)  # {'name': 'Alice', 'age': 25, 'city': 'Tokyo'}

Sortieren und Zufallsoperationen für Listen

import random

numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print(numbers)  # Beispiel: [3, 1, 5, 2, 4]

random_choice = random.choice(numbers)
print(random_choice)  # Beispiel: 2

Zusammenfassung

• Mithilfe von List Comprehensions können Listen effizient erstellt werden.
• Mit mehrdimensionalen Listen können Matrix- oder Tabellendaten gehandhabt werden.
• Durch die Umwandlung zwischen Listen und Dictionaries können Daten flexibel verwaltet werden.
• Durch die Nutzung von Sortierungen und Zufallsoperationen für Listen werden anwendungsbezogene Datenverarbeitungen möglich.

7. Häufig gestellte Fragen (FAQ)

Python-Listen und -Tupel sind sehr nützliche Datenstrukturen, aber es gibt vielleicht viele Punkte, bei denen Sie Fragen zur Verwendung haben.
Dieser Abschnitt erklärt häufige Fragen zu Python-Listen und -Tupeln im Q&A-Format.

Q1: Was ist der Unterschied zwischen Listen und Tupeln?

A:Listen sind veränderbar (mutable), Tupel sind unveränderbar (immutable) – das ist der größte Unterschied.

# Liste (veränderbar)
my_list = [1, 2, 3]
my_list[0] = 100  # veränderbar
print(my_list)  # [100, 2, 3]

# Tupel (unveränderbar)
my_tuple = (1, 2, 3)
my_tuple[0] = 100  # TypeError: 'tuple' object does not support item assignment

Q2: Wie kopiert man eine Liste richtig?

A:copy() oder den Slice [:] zu verwenden ist sicher.

# Slice verwenden
list_a = [1, 2, 3]
list_b = list_a[:]
list_b[0] = 100
print(list_a)  # [1, 2, 3] ← Die ursprüngliche Liste bleibt unverändert!

Q3: Was ist eine List Comprehension?

# Normale Listen-Erzeugung
squares = []
for x in range(10):
    squares.append(x**2)

# ✅ Mit List Comprehension kann man es knapper schreiben
squares = [x**2 for x in range(10)]

Q4: Wie konvertiert man in Python eine Liste in JSON-Format?

import json

data = [1, 2, 3, 4, 5]
json_data = json.dumps(data)
print(json_data)  # "[1, 2, 3, 4, 5]"

Q5: Wie mischt man die Elemente einer Liste zufällig?

import random

numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print(numbers)  # Beispiel: [3, 1, 5, 2, 4]

Q6: Was ist der Unterschied zwischen NumPy-Arrays und Listen?

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
print(arr * 2)  # [2 4 6 8 10]

Zusammenfassung

Dieser FAQ-Abschnitt hat häufige Fragen und deren Lösungen zu Python-Listen und -Tupeln erklärt.

• Unterschied zwischen Listen und Tupeln → Unterschied in der Änderbarkeit
• Listen kopieren → copy() oder Slice [:] verwenden
• List Comprehension → Knapper als for-Schleife
• JSON-Konvertierung von Listen → json.dumps() / json.loads() nutzen
• Unterschied zwischen NumPy-Arrays und Listen → NumPy ist schnell und für numerische Operationen geeignet

8. Zusammenfassung

In diesem Artikel haben wir die Grundlagen bis zur Anwendung von Arrays (Listen, Tupel, NumPy-Arrays) in Python detailliert erläutert.

Was in diesem Artikel gelernt wurde

✅ Was sind Arrays in Python?

• In Python gibt es kein „Array-Typ“ wie in C
• Stattdessen werden „Listen (List)“, „Tupel (Tuple)“ und „NumPy-Arrays (ndarray)“ verwendet

✅ Listen in Python

• Veränderbare (mutable) Datenstruktur
• Hinzufügen, Entfernen und Ändern von Elementen ist möglich

✅ Tupel in Python

• Unveränderliche (immutable) Datenstruktur
• Können als Schlüssel in Dictionaries verwendet werden
• Schnellere Verarbeitung und geringerer Speicherverbrauch

✅ Vergleich: Listen vs. Tupel

Referenzlinks zum Weiterlernen

📘Offizielle Python-Dokumentation

• Listen (List)
• Tupel (Tuple)
• Offizielle NumPy-Dokumentation

Zum Schluss

Das Verständnis von Arrays in Python (Listen, Tupel, NumPy) und ihre angemessene Nutzung machen die Datenverwaltung und -verarbeitung einfacher und effizienter.

Bitte schreiben Sie selbst Code und testen Sie es aus!