Kurs
Einführung in Python
4 Std.
7M
"Python und große Zahlen." Bild der Autorin mit DALL·E
Jede Programmiersprache hat ihre eigene Art, Variablen zu speichern, und Python ist da keine Ausnahme. Tatsächlich war Python selbst nicht immer ganz konsistent, was einen besonderen Aspekt der Sprache angeht – die maximalen Integer-Werte.
In diesem Tutorial schauen wir uns die maximalen Integer-Werte in Python an und vergleichen Python 2 und Python 3. Du lernst, warum die Kenntnis des maximalen Integer-Werts wichtig ist und wie du typische Fallstricke beim Arbeiten mit großen Zahlen vermeidest. Am Ende weißt du, wie du in Python effektiv mit großen Zahlen arbeitest – und wirst dadurch zu einer besseren Python-Programmiererin bzw. einem besseren Python-Programmierer.
Was ist Pythons maximale Integer-Größe?
Um Pythons maximale Integer-Größe zu verstehen, müssen wir zuerst die verwendete Python-Version betrachten, denn zwischen Python 2 und Python 3 fällt die Antwort unterschiedlich aus.
Für Python 2 hing der Maximalwert des Integer-Typs außerdem davon ab, ob wir auf einem 32-Bit- oder 64-Bit-System arbeiteten.
- Auf einem 32-Bit-System lag der maximale Integer-Wert bei (231 - 1), also 2.147.483.647.
- Auf einem 64-Bit-System lag der maximale Integer-Wert bei (263 - 1), also 9.223.372.036.854.775.807.
Auf beiden Systemen wurde der Datentyp int automatisch in long umgewandelt, wenn eine Zahl außerhalb dieser Grenzen lag. Der Datentyp long hatte keine Obergrenze – außer der durch den verfügbaren Arbeitsspeicher des Systems vorgegebenen.
In Python 3 hingegen unterstützt der Datentyp int beliebige Genauigkeit. Python muss den int-Typ also nicht mehr in long umwandeln, wenn es mit großen Zahlen arbeitet. Ähnlich wie der long-Typ in Python 2 ist int in Python 3 nur durch den verfügbaren Speicher begrenzt. Weil es effektiv keine feste Obergrenze für Integer-Größen in Python 3 gibt, existiert der Datentyp long dort nicht mehr.
| Python-Version | Datentyp | Systemarchitektur | Maximalwert |
|---|---|---|---|
| Python 2 | int | 32-Bit | (2^31 - 1) bzw. 2.147.483.647 |
| Python 2 | int | 64-Bit | (2^63 - 1) bzw. 9.223.372.036.854.775.807 |
| Python 2 | long | 32-Bit | Nur durch verfügbaren Speicher begrenzt |
| Python 2 | long | 64-Bit | Nur durch verfügbaren Speicher begrenzt |
| Python 3 | int | 32-Bit | Nur durch verfügbaren Speicher begrenzt |
| Python 3 | int | 64-Bit | Nur durch verfügbaren Speicher begrenzt |
Maximalwerte in Python 2 vs. Python 3
Die Entwicklung der Datentypen int und long in Python
Python 2 erschien im Jahr 2000, Python 3 im Jahr 2008. Python 3 ist im Grunde der Nachfolger von Python 2 und wurde entwickelt, um verschiedene Schwächen von Python 2 zu beheben – darunter auch den Umgang mit großen Ganzzahlen.
Warum wurden in Python 2 ganze Zahlen entweder als int oder long dargestellt, wobei int feste Größen abdeckte und long beliebig große Integers aufnehmen konnte? Dafür gab es Gründe: Dieses zweigleisige System entstand aus Performance-Überlegungen und zur Kompatibilität mit zugrunde liegenden C-Implementierungen.
Python 3 vereinfacht das, indem es int und long zu einem einzigen Typ int zusammenführt. Dieser neue int-Typ kann große Ganzzahlen ohne vordefinierte Grenze darstellen. Das erhöht die Flexibilität und beseitigt Probleme wie Überläufe, Datenkürzungen und Wrap-around-Effekte.
Python 3 erreicht das mittels Arithmetik mit beliebiger Genauigkeit, auch bignum- oder unbounded-integer-Arithmetik genannt. Arbitrary-precision arithmetic verwendet Arrays variabler Länge zur Darstellung von Ziffern und erlaubt so eine Genauigkeit, die nur durch den verfügbaren Speicher des Systems begrenzt ist – nicht durch eine feste Bitzahl. Dadurch können Integers so groß werden, wie es der Speicher zulässt, weil Python 3 dynamisch mehr Speicher reserviert, sobald die Zahl die Kapazität einer Standard-Festgröße übersteigt – unabhängig davon, ob die Systemarchitektur 32- oder 64-Bit ist.
Sieh dir Data Types for Data Science in Python an, um andere Datentypen umfassend kennenzulernen – inklusive der Verwendung von float für Dezimalzahlen.
Warum die maximale Integer-Größe in Python wichtig ist
Zu wissen, welche maximale Integer-Größe deine Python-Version unterstützt, ist entscheidend, um Speicherbedarf und Performance einzuschätzen. Der Einsatz von Integers außerhalb der Grenzen kann zu Überläufen, abgeschnittenen Daten oder unerwarteten Ergebnissen wie Wrap-around führen. Unentdeckt in einem Programmkontext kann das zu unterschiedlichen Problemen führen:
- Bugs: Überläufe bei Integers können Fehler einschleusen und Programme unerwartet reagieren lassen.
- Geringe Effizienz: Operationen jenseits der Integer-Grenzen verursachen unnötige Verzögerungen und Ineffizienzen.
- Unzuverlässigkeit: Systeme, die häufig an Integer-Grenzen stoßen, werden unzuverlässig – besonders in Umgebungen mit hohen Stabilitätsanforderungen.
- Präzisionsverlust: Wird die maximale Integer-Größe überschritten, kann Rechengenauigkeit verloren gehen und zu falschen Resultaten führen.
Arbeiten mit großen Zahlen in Python
In diesem Abschnitt schauen wir uns an, wie wir die maximale Integer-Größe in unserer Python-Umgebung ermitteln.
Die maximalen Integer-Werte in unserer Python-Umgebung finden
Um in Python 2 den maximalen int-Wert zu ermitteln, können wir folgende Codezeile verwenden:
sys.maxintDas liefert den größten Integer-Wert, den der Interpreter verarbeiten kann. Angenommen, wir verwenden ein 32-Bit-System. Dann sähe die Ausgabe so aus:
2147483647In Python 3 ist der maximale int-Wert unbegrenzt. Mit der folgenden Codezeile sehen wir die größte Integer-Zahl, die auf unserem System als Index genutzt werden kann. Sie wird in der Regel als (2**(Bitbreite deines Rechners))-1 berechnet.
sys.maxsizeHäufige Fallstricke und wie du sie vermeidest
Beim Arbeiten mit sehr großen oder sehr kleinen Integers können in Python 2 und anderen Sprachen Überläufe auftreten. Dank des dynamischen Typsystems in Python 3 gehören diese Probleme der Vergangenheit an.
Das heißt aber nicht, dass extrem große Zahlen folgenlos sind. Außergewöhnlich große Zahlen benötigen mehr Speicher und verlangsamen dein Programm. Kenne daher die Speicherkapazität deines Geräts – auch wenn es keine festen Integer-Grenzen gibt.
Tipps und Best Practices für große Integers
Datenwissenschaftlerinnen und -wissenschaftler arbeiten oft mit großen numerischen Datensätzen – da ist die Wahl der Darstellung entscheidend. Hier sind einige bewährte Vorgehensweisen für die Arbeit mit großen Zahlen.
Kenne den Wertebereich deiner Daten: Das ist wichtig, um Speicherbedarf und Rechenaufwand zu optimieren.
Wähle passende Datentypen: Wenn du in Python 2 arbeitest, entscheide zwischen
intundlonganhand von Größen- und Genauigkeitsanforderungen.Optimiere den Speicherbedarf an anderer Stelle: Große Integers verbrauchen viel Speicher. Reduziere an anderer Stelle, z. B. durch Vermeiden unnötiger Datenkopien.
Vermeide unnötige Konvertierungen: So bleibt die Darstellung konsistent.
Achte auf mögliche Überläufe: Prüfe bei arithmetischen Operationen mit großen Integers auf Überläufe und implementiere Sicherheitschecks – besonders in Python 2.
Profiliere deinen Code, um Engpässe zu finden, und optimiere kritische Abschnitte. Das steigert die Gesamtperformance.
Wenn du wichtige Techniken der funktionalen Programmierung lernen willst, sieh dir unseren Kurs Writing Efficient Python Code an.
Fazit
Der Umgang mit Integers in Python 3 eröffnet vielfältige Möglichkeiten für numerische Berechnungen und Datenanalysen. Wenn du die maximale Integer-Größe deines Systems kennst und Best Practices für große Zahlen anwendest, holst du das Maximum aus deinem Code heraus.
Mehr darüber, wie Python Datentypen speichert, findest du im Kurs DataCamp’s Introduction to Python for Data Science. Die Grundlagen von Python lernst du hier. Außerdem empfehle ich dir das DataCamp-Tutorial zu Datenstrukturen für weitere Informationen.
Themen