# Zahlen in Python

> For AI agents: use [llms.txt](https://nakafa.com/llms.txt) for the site index. Markdown versions are available by appending `.md` to content URLs or sending `Accept: text/markdown`.

URL: https://nakafa.com/de/faecher/ki-und-data-science/ki-programmierung/zahlen
Source: https://raw.githubusercontent.com/nakafaai/aksara/16d6b8e869d1a277313c65bbfc4b4a83efe77a46/packages/corpus/material/lesson/ai-ds/ai-programming/numbers/de.mdx

Python-Zahlentypen wie Ganzzahlen, Gleitkommazahlen und komplexe Zahlen, einschließlich Typprüfung, Konstruktoren und wissenschaftlicher Notation.

---

## Einführung in Zahlendatentypen

Python stellt eingebaute Zahlentypen für ganze Zahlen, näherungsweise Berechnungen mit reellen Zahlen und komplexe Zahlen bereit. Die Wahl des Typs ist wichtig, weil jeder Typ Werte anders darstellt und verarbeitet.

Python ist sehr flexibel im Umgang mit Zahlen. Wenn Sie Zahlen in die Python-Shell eingeben, erkennt Python diese sofort und zeigt sie an. Sehen wir uns an, wie Python mit Zahlen funktioniert.

File: basic_numbers.py
```python
>>> 4
4

>>> 4.
4.0

>>> 0.30
0.3

>>> 0.0000999
9.99e-05

>>> 2. + 1j
(2+1j)
```

Python liest jedes Literal anhand seiner Schreibweise. $$4$$ erzeugt eine Ganzzahl. Der Dezimalpunkt in $$4.$$ macht den Ausdruck dagegen zu einem Gleitkommaliteral, das als $$4.0$$ angezeigt wird.

Visible text: Python liest jedes Literal anhand seiner Schreibweise. erzeugt eine Ganzzahl. Der Dezimalpunkt in macht den Ausdruck dagegen zu einem Gleitkommaliteral, das als angezeigt wird.

## Arten von Zahlendaten

Die drei wichtigsten eingebauten Zahlentypen sind `int`, `float` und `complex`.

### Ganzzahl

Eine Ganzzahl ist positiv, negativ oder null und besitzt keine Nachkommastellen. Python-Ganzzahlen haben eine beliebige Genauigkeit. Ihre Größe wird also durch den verfügbaren Speicher und nicht durch einen festen 32-Bit- oder 64-Bit-Bereich begrenzt.

**Gültige Ganzzahlbeispiele**

Component: MathContainer
Children:

```math
-2, -1, 0, 1, 2
```

```math
+1, +2, +3
```

**Besonderheiten von Ganzzahlen in Python**

Zwischen Ziffern dürfen Unterstriche stehen, damit lange Literale leichter lesbar sind. $$123\_456\_789$$ hat denselben Wert wie $$123456789$$. Die Unterstriche verändern nur die Schreibweise im Quellcode.

Visible text: Zwischen Ziffern dürfen Unterstriche stehen, damit lange Literale leichter lesbar sind. hat denselben Wert wie . Die Unterstriche verändern nur die Schreibweise im Quellcode.

### Float

Ein `float` speichert eine binäre Gleitkommanäherung. Float-Literale können einen Dezimalpunkt oder einen Exponenten enthalten. Sie eignen sich für Messwerte und numerische Berechnungen, doch viele Dezimalbrüche lassen sich binär nicht exakt darstellen.

**Allgemeine Float-Beispiele**

Component: MathContainer
Children:

```math
-1.2, 3.85, +7.01
```

```math
-.21, .01, 2., +5.
```

**Wissenschaftliche Notation für sehr kleine oder große Zahlen**

Die Exponentschreibweise mit `e` oder `E` erleichtert sehr kleine oder sehr große Float-Literale. Zum Beispiel:

Component: MathContainer
Children:

```math
-3.2e5 = -3.2 \times 10^5
```

```math
2e-2 = 2 \times 10^{-2}
```

```math
+2.e4 = +2.0 \times 10^4
```

Die Notation $$e$$ oder $$E$$ in Python ist dieselbe wie die wissenschaftliche Notation, die Sie in der Mathematik gelernt haben. Die Zahl $$1E1$$ entspricht $$1 \times 10^1 = 10.0$$ und $$3.1E-7$$ entspricht $$3.1 \times 10^{-7}$$.

Visible text: Die Notation oder in Python ist dieselbe wie die wissenschaftliche Notation, die Sie in der Mathematik gelernt haben. Die Zahl entspricht und entspricht .

### Komplex

Komplexe Zahlen besitzen einen Real- und einen Imaginärteil. In einem Python-Literal kennzeichnet das Suffix $$j$$ den Koeffizienten der imaginären Einheit. Komplexe Arithmetik wird unter anderem in der Signalverarbeitung, Elektrotechnik und wissenschaftlichen Datenverarbeitung eingesetzt.

Visible text: Komplexe Zahlen besitzen einen Real- und einen Imaginärteil. In einem Python-Literal kennzeichnet das Suffix den Koeffizienten der imaginären Einheit. Komplexe Arithmetik wird unter anderem in der Signalverarbeitung, Elektrotechnik und wissenschaftlichen Datenverarbeitung eingesetzt.

**Beispiele für komplexe Zahlen**

Component: MathContainer
Children:

```math
2 + 3j
```

```math
4.5 - 2.1j
```

Stellen Sie sich komplexe Zahlen wie Koordinaten auf einer Karte vor. Der Realteil ist die horizontale Position und der Imaginärteil ist die vertikale Position.

## Die Typfunktion zum Überprüfen von Datentypen

Die Funktion `type()` zeigt die genaue Klasse eines Objekts an. Das ist beim Erkunden von Werten in der Python-Shell oder bei der Fehlersuche hilfreich.

File: check_types.py
```python
>>> type(5)
<class 'int'>

>>> type(.1)
<class 'float'>

>>> type(2j)
<class 'complex'>
```

Für eine strikte Typgleichheit kannst du `type(value)` mit einer Klasse vergleichen. In Anwendungscode ist `isinstance(value, SomeType)` häufig flexibler, weil es auch Unterklassen erkennt.

## Konstruktoren zum Erstellen von Zahlenobjekten

Python bietet Konstruktoren zum Konvertieren oder Erstellen von Zahlenobjekten aus anderen Typen. Dies ist sehr nützlich, wenn Sie Daten von einem Format in ein anderes konvertieren müssen.

### Konstruktor-Float

Der Konstruktor `float()` wandelt andere Zahlen in Dezimalzahlen um.

File: float_constructor.py
```python
>>> float(2)
2.0

>>> float()
0.0
```

Wenn Sie `float(2)` aufrufen, wandelt Python die Ganzzahl $$2$$ in den Gleitkommawert $$2.0$$ um. Wenn Sie `float()` ohne Argumente aufrufen, gibt Python den Standardwert $$0.0$$ aus.

Visible text: Wenn Sie `float(2)` aufrufen, wandelt Python die Ganzzahl in den Gleitkommawert um. Wenn Sie `float()` ohne Argumente aufrufen, gibt Python den Standardwert aus.

### Konstruktor int

Der Konstruktor `int()` wandelt einen endlichen Float in eine Ganzzahl um und schneidet dabei in Richtung null ab.

File: int_constructor.py
```python
>>> int(2.1)
2

>>> int(2.9)
2

>>> int(-2.9)
-2
```

`int()` rundet nicht auf die nächste Ganzzahl. Beide positiven Beispiele ergeben $$2$$. `int(-2.9)` ergibt $$-2$$, weil die Abschneidung in Richtung null erfolgt.

Visible text: `int()` rundet nicht auf die nächste Ganzzahl. Beide positiven Beispiele ergeben . `int(-2.9)` ergibt , weil die Abschneidung in Richtung null erfolgt.

### Konstruktorkomplex

Der Konstruktor `complex()` erzeugt komplexe Zahlen aus reellen Zahlen.

File: complex_constructor.py
```python
>>> complex(2.)
(2+0j)

>>> complex(0., 2.)
2j
```

`complex(2.)` erzeugt eine komplexe Zahl mit Realteil $$2$$ und Imaginärteil $$0$$. Unterdessen erzeugt `complex(0., 2.)` eine rein imaginäre Zahl $$2j$$.

Visible text: `complex(2.)` erzeugt eine komplexe Zahl mit Realteil und Imaginärteil . Unterdessen erzeugt `complex(0., 2.)` eine rein imaginäre Zahl .

## Zusammenfassungstabelle für Zahlendatentypen

| Kategorie | Typ | Beispiele | Beschreibung |
|----------|------|----------|-------------|
| **Ganzzahl** | `int` | $$-2, -1, 0, 1, 2$$ und $$+1, +2, +3$$ | Ganze Zahlen, zur Verdeutlichung kann ein Unterstrich verwendet werden |
| **Gleitkomma** | `float` | $$-1.2, 3.85, +7.01$$ und $$-.21, .01, 2.$$ | Dezimalzahlen, unterstützt die wissenschaftliche Notation mit $$e$$ oder $$E$$ |
| **Komplex** | `complex` | $$2 + 3j$$ und $$4.5 - 2.1j$$ | Komplexe Zahlen mit $$j$$ als imaginärer Einheit |

Visible text: | Kategorie | Typ | Beispiele | Beschreibung |
|----------|------|----------|-------------|
| **Ganzzahl** | `int` | und | Ganze Zahlen, zur Verdeutlichung kann ein Unterstrich verwendet werden |
| **Gleitkomma** | `float` | und | Dezimalzahlen, unterstützt die wissenschaftliche Notation mit oder |
| **Komplex** | `complex` | und | Komplexe Zahlen mit als imaginärer Einheit |