Python und Rust erweitert

Python.md

@@ -109,4 +109,44 @@ name = None   # Name wurde noch nicht eingegeben
 
 `0` ist ein echter numerischer Wert, zum Beispiel eine Punktzahl von genau null, während `None` bedeutet, dass überhaupt kein Wert vorhanden ist, etwa eine Punktzahl, die noch nicht berechnet wurde. Ein häufiges Missverständnis ist, dass `0` „nichts“ bedeutet, aber in Python steht nur `None` tatsächlich für das Fehlen eines Werts. Ebenso sind `""` (leere Zeichenkette) und `False` weiterhin echte Werte ihrer jeweiligen Typen. Sie sind nicht dasselbe wie `None`.
 
-Die Verwendung von `None` signalisiert, dass die Variable als Platzhalter existiert, aber noch keinen sinnvollen berechneten Wert enthält.
+Die Verwendung von `None` signalisiert, dass die Variable als Platzhalter existiert, aber noch keinen sinnvollen berechneten Wert enthält.
+## Arithmetische Operatoren
+
+**Operatoren** werden verwendet, um Operationen mit Werten durchzuführen. 
+
+Zuerst besprechen wir die grundlegendsten **arithmetischen Operatoren**, die dir vielleicht aus dem Mathematikunterricht bekannt sind.
+
+|Operator|Operation|Beispiel|
+|---|---|---|
+|+|Addition|3 + 2 = 5|
+|-|Subtraktion|3 - 2 = 1|
+|*|Multiplikation|3 * 2 = 6|
+|/|Division|4 / 2 = 2.0|
+
+Sehen wir uns ein Anwendungsbeispiel an.
+
+```python
+a = 3
+b = 5
+c = a + b # c hält 8
+```
+
+Wenn ein Ausdruck mehrere Operatoren enthält, folgt Python der in der Mathematik verwendeten Reihenfolge: Multiplikation und Division werden vor Addition und Subtraktion berechnet, und alles innerhalb von Klammern wird zuerst berechnet.
+
+```python
+z = 7 + 3 * 2   # z hat den Wert 13, weil 3 * 2 zuerst berechnet wird
+z = (7 + 3) * 2 # z hat den Wert 20
+```
+### Challenge
+
+Schreibe einen Code, der zwei Variablen, `a` und `b`, mit den Werten `5.2` bzw. `2.6` initialisiert.
+
+Initialisiere danach eine weitere Variable `c`, die das Ergebnis von `a / b` enthält.
+
+```python
+a = 5.2
+b = 2.6
+c = a / b
+
+print(f"a = {a}, b = {b}, c = {c}");
+```

Rust.md

@@ -372,6 +372,87 @@ println!("Is available: {}", is_available);
 }
 ```
 
+## Typumwandlung
+
+Typumwandlung bezeichnet den Vorgang, einen Wert von einem Datentyp in einen anderen umzuwandeln. In Rust verwenden wir das Schlüsselwort <mark style="background:#40a9ff">`as`</mark> für eine explizite Typumwandlung (auch als Typkonvertierung bezeichnet). 
+
+Die häufigsten Typumwandlungen finden zwischen numerischen Typen statt:
+
+```rust
+// Umwandlung von Integer zu Float
+let number: i32 = 5;
+let decimal: f64 = number as f64;// wird zu 5.0
+```
+
+```rust
+// Umwandlung von Gleitkommazahl in Ganzzahl
+let decimal: f64 = 9.7;
+let number: i32 = decimal as i32;// wird zu 9 (Dezimalteil wird abgeschnitten)
+```
+### Challenge
+Schreiben Sie ein Rust-Programm, das Typumwandlung demonstriert. Führen Sie die folgenden Operationen aus:
+
+1. Deklarieren Sie eine `f64`-Variable namens `price` und initialisieren Sie diese mit dem Wert `99.99`.
+2. Wandeln Sie die Variable `price` in einen `i32` um und speichern Sie das Ergebnis in einer neuen Variable namens `int_price`.
+3. Geben Sie die Werte von `price` und `int_price` auf der Konsole aus.
+
+```rust
+fn main() {
+// Variablen deklarieren und initialisieren
+let price: f64 = 99.99;
+let int_price: i32 = price as i32;
+
+// Die Werte ausgeben
+println!("Price: {}", price);
+println!("Int Price: {}", int_price);
+}
+```
+## Arithmetische Operatoren
+
+**Operatoren** werden verwendet, um Operationen auf Werten auszuführen.
+
+Zuerst werden wir die grundlegendsten **arithmetischen Operatoren** besprechen; sie sind Ihnen vielleicht aus dem Mathematikunterricht bekannt.
+
+| Operator | Operation      | Beispiel  |
+| -------- | -------------- | --------- |
+| +        | Addition       | 3 + 2 = 5 |
+| -        | Subtraktion    | 3 - 2 = 1 |
+| *        | Multiplikation | 3 * 2 = 6 |
+| /        | Division       | 4 / 2 = 2 |
+
+Sehen wir uns ein Verwendungsbeispiel an,
+
+```rust
+let a: i32 = 3;
+let b: i32 = 5;
+let c: i32 = a + b// c enthält 8
+```
+
+Beim Arbeiten mit Dezimalzahlen in Rust verwenden wir den Datentyp f64, der Zahlen mit Nachkommastellen speichern kann. Die gleichen arithmetischen Operatoren (+, -, *, /) funktionieren mit f64 genauso wie mit Ganzzahlen:
+
+```rust
+let x: f64 = 3.3;
+let y: f64 = 4.1;
+let z: f64 = x + y;// z enthält 7.4
+```
+### Challenge
+
+Schreibe einen Code, der zwei Variablen, `a` und `b`, mit den Werten `5.2` und `2.6` (in dieser Reihenfolge) initialisiert.
+
+Initialisiere danach eine weitere Variable `c`, die das Ergebnis von `a / b` enthalten wird.
+
+```rust
+fn main() {
+// Schreibe deinen Code unten
+let a: f64 = 5.2;
+let b: f64 = 2.6;
+let c: f64 = a / b;
+
+// Ändere die folgende Zeile nicht
+println!("a = {}, b = {}, c = {}", a, b, c);
+}
+```
+
 
 https://rust-lernen.de/blog/zeichenketten.html