Du liest:
Arrays in Python: Die große Übersicht

Arrays in Python: Die große Übersicht

von Patrick
24.04.2020
Jetzt Python programmieren lernen

Meistens werden für Anwendungsfälle, in denen andere Programmiersprachen Arrays anbieten, Listen in Python verwendet, jedoch existieren Arrays in der Standardbibliothek als Klasse. Diese Arrays sind jedoch nur ein Wrapper um Arrays der Programmiersprache C und werden hauptsächlich gebraucht, um mit Erweiterungen oder Systembefehlen zu kommunizieren, wie auf StackOverflow auch recht gut erläutert:
Stackoverflow: Python List vs. Arrays – When to use?.

Wie man diese Arrays nun in Python verwenden kann, erläutere ich im Folgenden.

1. Arrays initialisieren

Das Array benötigt als Argumente zur Initialisierung 2 Parameter, den Typencode und Werte.

array(Typencode, Werte)
    Typencode (erforderlich) Der Code, der angibt, welche Art Werte
                             das Array verwaltet
    Werte (optional)         Die eigentlichen Werte, mit denen das
                             Array initialisiert wird

Der Typencode gibt an, welche Werte (short, int, float, etc.) akzeptiert werden. Der optionale Werte-Parameter ist eine Liste aus Anfangswerten, mit denen das Array erstellt wird.
Für das folgende Beispiel initialisieren wir ein Array mit dem Typencode ‘b’, welches für signed char steht. Das bedeutet, dass die Klasse nur ganzzahlige Werte von 127 bis -127 akzeptiert.

a = array('b', [127, -127])
print(a)

Output:

> array('b', [127, -127])

Wenn versucht wird, einen höheren Wert als 127 oder einen niedrigeren als -127 hinzuzufügen, resultiert das in einem OverflowError.

a.append(128)

Output:

Traceback (most recent call last):
  File ".\array.py", line 11, in <module>
    a.append(128)
OverflowError: signed char is greater than maximum

Für das nächste Beispiel verwenden wir den Typencode ‘B’, welcher für unsigned char steht. Das bedeutet so viel wie, dass dieses nur Werte ohne Vorzeichen, also ausschließlich positive, von 0 bis 255 akzeptiert.
Liegt der Wert höher als 255, wird ebenfalls ein OverflowError ausgegeben.

a = array('B', [255, 0])
print(a)
a.append(256)

Output:

array('B', [255, 0])
Traceback (most recent call last):
  File ".\array.py", line 20, in <module>
    a.append(256)
OverflowError: unsigned byte integer is greater than maximum

Den OverflowError erhalten wir übrigens nicht nur bei zu hohen, sondern auch bei zu niedrigen Werten.

a.append(-1)

Output:

Traceback (most recent call last):
  File ".\array.py", line 21, in <module>
    a.append(-1)
OverflowError: unsigned byte integer is less than minimum

1.1 Typencodes

Das Modul array enthält einen String mit dem Namen typecodes, welcher uns alle verfügbaren Typencodes anzeigt.

from array import typecodes
print(typecodes)

Output:

bBuhHiIlLqQfd

Dieser String enthält auch den code ‘u’ für Unicode Zeichen. Dieser ist allerdings seit Python Version 3.3 veraltet und sollte soweit möglich vermieden werden. Daher wird er hier auch nicht weiter behandelt.
Für alle anderen Codes findest du hier eine Tabelle mit vollem Namen, Maximal- und Minimalwert. Für eine vollständige Liste der verfügbaren Codes kannst du dir gerne die Python Dokumentation ansehen (Python3 Docs: Array), für C-Datentypen lohnt ein Blick in Wikipedia (Wikipedia: C Datentypen).

typecode MaximalwertMinimalwert
bsigned char127-127
Bunsigned char2550
hsigned short32.767−32.767
Hunsigned short65.5350
isigned int32.767-32.767
Iunsigned int65.5350
lsigned long2.147.483.647-2.147.483.647
Lunsigned long4.294.967.2950
qsigned long long9.223.372.036.854.775.807-9.223.372.036.854.775.807
Qunsigned long long18.446.744.073.709.551.6150
ffloat3.4E+381.2E-38
ddouble1.7E+3082.3E-308
typecodes und deren Wertebereiche

Die Notationen für float und double sind unter Umständen nicht für jeden einfach zu verstehen, daher möchte ich sie hier kurz erklären.
Der Maximalwert von float 3.4E+38, entspricht 3,4 x 10^38, anders gesagt 340000000000000000000000000000000000000 (das sind 37 Nullen), in Python so ausgedrückt:

print(3.4 * 10 ** 38)
# 3.4e+38

Genauso verhält es sich bei dem Minimalwert.  Aus 1.2E-38 wird 1,2 x 10^-38 bzw. 0.000000000000000000000000000000000000012, in Python ausgedrückt 1.2 * 10 ** -38.
Allerdings ist folgendes zu beachten, wenn wir noch mehr Nullen angeben:

a = array('f', [0.00000000000000000000000000000000000000000012])
print(a)
# array('f', [1.2051166793193427e-43])

Das Ergebnis hier zeigt deutlich, dass der Wert für einen float wohl doch niedriger sein kann. Das liegt daran, dass die -38 nur angeben, wieviele Nullen noch zusätzlich zu anderen Ziffernstellen angegeben werden können; die sogenannte Mantisse, die  in der Informatik auch Signifikand genannt wird (siehe auch Wikipedia: Mantisse).
Dies wird im folgenden Beispiel noch deutlicher:

a = array('f', [0.30000000000000000000000000000000000000034579])
print(a)
# array('f', [0.30000001192092896])

Hier sieht man, dass der Wert an einer bestimmten Stelle abgeschnitten wird. Die 1192092896 am Ende der Zahl entstehen durch die Implementierung von float in modernen Computersystemen, denn wenn wir stattdessen double als Typ verwenden, erhalten wir ein klareres Ergebnis.

a = array('d', [0.30000000000000000000000000000000000000034579])
print(a)
# array('d', [0.3])

Der Grund dafür, dass die Zahlen abgeschnitten werden, hat damit zu tun wie diese in Bits repräsentiert werden. Eine relativ einfach verständliche Erklärung dazu kannst du hier finden Rheinwerk-Verlag: C Basisdatentypen float – double.
Weiterhin sei bemerkt, dass wir, wenn wir zu hohe Werte angeben, als Rückgabewert inf (für infinite/unendlich) erhalten.

a = array('f', [345790000000000000000000000000000000000000000])
print(a)
# array('f', [inf])

Dies ist ebenfalls für negative Werte der Fall, wo wir -inf, also die negative Entsprechung von unendlich erhalten.

a = array('f', [-345790000000000000000000000000000000000000000])
print(a)
# array('f', [-inf])

Wenn der Wert, den wir angeben jedoch eine Kommazahl mit zu vielen vorstehenden Nullen ist, ist der Rückgabewert 0.0.

a = array('f', [0.000000000000000000000000000000000000000000000034])
print(a)
# array('f', [0.0])

Hierfür gibt es ebenfalls eine negative Entsprechung, nämlich -0.0.

a = array('f', [-0.00000000000000000000000000000000000000000000034])
print(a)
# array('f', [-0.0])

2. Arrays in Python erweitern

Die einfachste Methode, ein Array zu erweitern ist ein Element mit append hinzuzufügen.

a = array('b', [0, 1, 2])
a.append(3)
print(a)
# array('b', [0, 1, 2, 3])

Um ein Element an einer bestimmten Position hinzuzufügen, steht uns die Methode insert zur Verfügung.
Der erste Parameter bezeichnet die die Index-Position, an der der neue Wert hinzugefügt werden soll und der zweite den Wert selbst.

a.insert(0, -1)
print(a)
# array('b', [-1, 0, 1, 2, 3])

Ein Array kann auch um ein anderes Array mit der Methode extend erweitert werden.

a2 = array('b', [4, 5])
a.extend(a2)
print(a)
# array('b', [-1, 0, 1, 2, 3, 4, 5])

Den gleichen Effekt kannst du auch mit dem + Operator erzielen.

a3 = a + a2
print(a3)
# array('b', [-1, 0, 1, 2, 3, 4, 5])
a += a2
print(a)
# array('b', [-1, 0, 1, 2, 3, 4, 5])

Ebenfalls kannst du deine Arrays mit Listen mithilfe der Methode fromlist erweitern.

l = [6, 7]
a.fromlist(l)
print(a)
# array('b', [-1, 0, 1, 2, 3, 4, 5, 6, 7])

3. Elemente aus einem Python Array löschen

Uns stehen auch mehrere Methoden zur Verfügung, um Elemente aus Arrays zu löschen. Eine davon ist remove, welche das erste Vorkommen von links des als Parameter übergebenen Wertes löscht.

a = array('b', [0, 7, 3, 7])
a.remove(7)
print(a)
# array('b', [0, 3, 7])

Zudem steht uns noch die Methode pop zur Verfügung.
Als optionalen Parameter nimmt sie den Index des zu entfernenden Wertes an. Standardmäßig ist dieser-1, also das letzte Element.
Außerdem gibt pop das entfernte Element selbst zurück, du kannst also damit nach dem Entfernen noch weiter arbeiten.

a = array('b', [0, 7, 3, 7])
element = a.pop()
print(element, a)
# 7 array('b', [0, 7, 3])
element = a.pop(0)
print(element, a)
# 0 array('b', [7, 3])

Zu guter Letzt kannst du ein Element auch anhand seiner Index-Position mit dem Schlüsselwort del entfernen.

a = array('b', [7, 127])
del a[0]
print(a)
# array('b', [127])

4. Elemente eines Python Arrays zählen

Mit der eingebauten Funktion len kannst du die komplette Anzahl der Elemente ermitteln und mit der Methode count die Anzahl an Vorkommen eines bestimmten Wertes.

a = array('b', [0, 1, 0, 2, 1, 1])
print(len(a))
# 6
print(a.count(1))
# 3
print(a.count(3))
# 0

5. Höchsten und niedrigsten Wert ermitteln mit max und min

Um den höchsten sowie den niedrigsten Wert einer Liste oder eines Arrays zu ermitteln, stellt Python die eingebauten Funktionen max und min zur Verfügung, welche recht einfach zu bedienen sind:

a = array('b', [42, -127, 30])
print(max(a))
# 42
print(min(a))
# -127

6. Python Arrays umkehren und sortieren

Wie bei Listen kann auch hier die eingebaute Funktion sorted verwendet werden, um die Elemente neu zu sortieren. Standardmäßig sortiert diese vom niedrigsten zum höchsten Wert, allerdings kannst du auch den optionalen Parameter reverse auf True setzen, um vom höchsten zum niedrigsten Wert zu sortieren. Allerdings ist hierbei zu beachten, dass sorted eine Liste als Ergebnis zurückgibt.

s = sorted(a)
print(type(s), s)
# <class 'list'> [-127, 30, 42]
s = sorted(a, reverse=True)
print(type(s), s)
# <class 'list'> [42, 30, -127]

Arrays stellen selbst eine Methode mit Namen reverse zur Verfügung, welche die Reihenfolge der Elemente selbst umkehrt.

a = array('b', [0, 1, 2])
a.reverse()
print(a)
# array('b', [2, 1, 0])

7. Teile des Arrays zurückgeben mit slicing

Genauso wie bei Strings (CodeCitrus: Wie funktioniert Slicing bei Strings) und Listen (CodeCitrus: Slicing von Python Listen) steht uns auch hier die Möglichkeit zur Verfügung, nur einen Teil des Arrays mittels slicing zurückzugeben.

a = array('b', [1, 2, 0, 3, 2])
print(a[1:4])
# array('b', [2, 0, 3])

8. Fazit

Mit Arrays arbeiten in Python mag zwar recht einfach sein, jedoch sind Listen wesentlich flexibler und verfügen über mehr Funktionen. Daher empfehle ich, eher Listen zu benutzen, wenn es nicht unbedingt erforderlich ist, Arrays zu verwenden.

Hat dir dieser Beitrag gefallen? Hast du Fragen, Anmerkungen, Verbesserungsvorschläge? Lass es mich bitte in den Kommentaren wissen.



Bislang gibt es keine Kommentare. Markier dein Revier und sei der Erste!

Schreibe einen Kommentar

Das könnte dich auch interessieren