Python und Rust erweitert

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