allgemein
Runden:
C#: Math.Round(…, 2)
Py: round(…, 2)
Liste Matrix:
C#: list of list
List<List> matrix = new List<List>()
{ new List { 1, 2, 3 },
new List { 4, 5, 6 },
new List { 7, 8, 9 } };
// Zugriff auf ein Element (Zeile 1, Spalte 2)
Console.WriteLine(matrix[1][2]); // Ausgabe: 6
Py: list of lists oder matrix
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
] // Zugriff auf ein Element (Zeile 1, Spalte 2)
print(matrix[1][2]) // Ausgabe: 6
//Alternativ geht auch list of list:
liste = [None] * 3
liste[0] = [1, 2, 3]
liste[1] = [4, 5, 6]
liste[2] = [7, 8, 9]
GUI-Tkinter
import tkinter as tk // Zuerst, um GUI-Elemente zu importieren
->Beginn von jeder GUI mit Erstellung eines Hauptfenster
root = tk.Tk() // Erstellt das Hauptfenster
root.title("Mein Fenster") // Fenster-Titel setzen
root.geometry(("200 * 400") // Fenster-Größe setzen
root.mainloop() // Startet die GUI--> ganz am Ende plazieren
Label:
label = tk.Label(root, text="Hallo, Tkinter!", font=("Arial", 14))
label.pack() //Label mit Text einfügen
platzieren: label.pack(side="top") // Standard (oben) //oder bottom/left/reight
label.grid(row=0, column=0) // row = zeile, column = spalte
Button:
def klick():// Funktion, die bei Klick ausgeführt wird
print("Button wurde gedrückt!")
button = tk.Button(root, text="Klick mich!", command=klick)
button.pack() // Button erstellen und Funktion zuweisen
Benutzereingabe:
entry = tk.Entry(root, text=“ “) //Erstellen der Benutzereingabefeld
entry.pack() //Eingabe platzieren
oder entry.grid() //für Grid-Layout
def eingabe_auslesen(): //Funktion um entry auszulesen
print(entry.get()) // Holt den Text aus dem Feld
Frame:
frame = tk.Frame(root, bg="lightgray", padx=10, pady=10)
frame.pack() //Farbiger Container für Widget
Instanziierung Py
Instanziierung C#
C#
Variablen
int breite;
int hoehe;
int flaeche;
Console.WriteLine("Bitte geben Sie die breite des Rechtecks ein [m]:");
breite = int.Parse(Console.ReadLine());
Console.WriteLine ("Bitte geben Sie die länge des Rechtecks ein [m]: ");
hoehe = int.Parse(Console.ReadLine());
flaeche = breite * hoehe;
Console.WriteLine($"Die Fläche des Dreicks beträgt{flaeche} m²");
Konvertierung
1.System.Convert - Klasse (mit Convert Methoden)
-> ToBoolean() / ToString() / ToInt32() / ToDouble()
Bsp: string strNumber = "123"; int number = Convert.ToInt32(strNumber);
Console.WriteLine("Zahl: " + number);
2.Parse/TryParse ( Alternative zu Convert Methode)
-> Int32.Parse() / double.Parse() / int.TryParse()/ double.TryParse()
Bsp: string numberString = "123"; int number = int.Parse(numberString);
Console.WriteLine("Zahl: " + number);
Arrays (Größe nicht verändrebar)
Deklaration: Datentyp [] Name;
Zugriff auf Werte eines Arrays: -> Zugriff auf die Werte eines Array über Indizes in []
Bsp. Console.WriteLine(numbers[1]); // Index beginnt bei 0
Bsp. int []numbers = new int [3]; // Standardwerte 3 *{0}
int[] numbers = {10, 20, 30} ;//direkt Werte
int[] numbers = new int[] {10,20,30}; //geht auch!
numbers[0] = 10 // Einzelwert festlegen
[ , ] zweidimensionaler Array ([ , , ] 3D)
int[,] array = new int[3, 4]; // Ein Array mit 3 Zeilen und 4 Spalten
Listen (dynamisch)
List<int> dynamicList = new List<int> { 1, 2, 3 };
dynamicList.Add(4); // Fügt ein weiteres Element hinzu
Kontrollstrukturen
Verzweigung: (if, else if, else)
if (Bedingung 1) {Anweisung1;}
else if (Bedingung 2) {Anweisung 2;}
else {Anweisung n;}
Fallunterscheidung: (switch, case, default)
Switch (Variable)
{case Wert1: Anweisung; break;
case Wert2: Anweisung; break;
default: Anweisung; break; }
Schleifen: (while, do while, for, for each)
for (int i = 1; i <= 5; i++) //Nach for (Initialisierung ; Bedingung ; Inkrementieren)
{Console.WriteLine("Durchlauf: " + i);} //Anweisung
string[] namen = { "Alice", "Bob", "Charlie"};
foreach (string name in namen) //Alle Elemente des Array
{ Console.WriteLine($"Hallo, {name}!"); }//Anweisung
int x = 0; while (x < 3) // Bedingung in Klammern
{ Console.WriteLine("x ist: " + x); x++; } //Anweisung Zusatz Inkrementieren
int y = 0; do { Console.WriteLine("y ist: " + y); y++;}
while (y < 3); //Bedingung in Klammern
Ausnahmebehandlungen:
try { int zahl = int.Parse("abc"); // Fehler: ungültige Zahl }
catch (FormatException e) { Console.WriteLine("Fehler: Ungültige Eingabe!"); }
finally { Console.WriteLine("Dieser Code wird immer ausgeführt."); }
// Fehler manuell auslösen throw new Exception("Ein Fehler ist aufgetreten!");
Funktionen/Methoden
Zugriffsmodifikator RückgabeTyp Bezeichner(Parameter)
{ // Methodenrumpf return Rückgabewert; }
// Zugriqsmodifikato: public, private, protected..
// Rückgabetyp: void=keineRückgabe, ansonsten:int/string/bool..
// Parameter: Eingabewerte, werden der Methode übergeben
Statische Methode: public static int Addieren(int a, int b)
Klassenaufbau
class Auto // Klassenname
{ public string Marke; public int Baujahr;// Klassenattribute
public Auto(string marke, int baujahr) // Konstruktor
{ Marke = marke; Baujahr = baujahr; }
public void Fahren() // Methode
{ Console.WriteLine($"{Marke} fährt los!"); } }
class Program
{ static void Main()
{ Auto meinAuto = new Auto("BMW", 2022); //Instanz der Klasse Auto erstellen Auto
Console.WriteLine($"Marke: {meinAuto.Marke}, Baujahr: {meinAuto.Baujahr}");
meinAuto.Fahren(); } } // Methoden und Eigenschaften nutzen
Getter/Setter mit Properties (Syntax am einfachsten):
public string Marke
{ get { return marke; } // Getter gibt den Wert zurück
set { marke = value; } // Setter weist den Wert zu }
class Auto
{ public string Marke { get; set; } public int Baujahr { get; set; } }
public string Marke
{ get { return marke; } // Getter
set { if (!string.IsNullOrEmpty(value)) // Validierung beispielhaft
{ marke = value; // Setter } } }
Vere rbu ng
class Auto : Fahrzeug // Abgeleitete Klasse (Subklasse)
{ public int Sitzplätze { get; set; } // Konstruktor der abgeleiteten Klasse
public Auto(string marke, int baujahr, int sitzplätze)
: base(marke, baujahr) // Konstruktor der Basisklasse aufrufen mit base
{ Sitzplätze = sitzplätze; }
Python
Variablen
zahl = int
istprimzahl = bool
istprimzahl = True
input_value = input ("Bitte gebe eine Zahl ein:")
x = float(input_value)
Konvertierung
1. Implizierte Typkonvertierung (Python automatisch
a = 5 # int b = 2.5 # float
c = a + b # int wird zu float print(c) # Ausgabe: 7.5
2. Explizite Typkonvertierung
print(int(3.9)) # Ausgabe: 3 print(int("10")) # Ausgabe: 10
Listen
zahlenListe = [10, 20, 30]
zahlenListe = [None]* 3 // Noch ohne Werte
zahlenListe.append(40) // Wert hinzufügen
zahlenListe.remove(40) // Wert entfernen
print (zahlenListe[0]) //Ausgabe der Anzahl der Elemente(die Länge)
Kontrollstrukturen
Verzweigung: (if, else if, else)
Bsp: zahl = 10
if zahl > 10: //Bedingung 1 nach if
print("Die Zahl ist größer als 10") //Anweisung 1
elif zahl == 10: //Bedingung 2 nach elif
print("Die Zahl ist genau 10") //Anweisung 2
else: print("Die Zahl ist kleiner als 10") //Anweisung 3
Fallunterscheidung: (match, case)
tag = "Montag"
match tag: // Variable nach match
case "Montag": //Wert 1 nach case
print("Wochenanfang!") //Anweisung 1
case "Freitag": //Wert 2 nach case
print("Fast Wochenende!") //Anweisung 2
case _: print("Ein normaler Tag.") //Anweisung default
Schleifen: (while, for)
for i in range(5): // in Py for-Schleife mit (in range)
print(f"Durchlauf: {i}"). // Anweisung // while-Schleife (abweisende Schleife)
x = 0
while x < 3: // Bedingung nach while
print(f"x ist: {x}") // Anweisung
x += 1 // Anweisung Zusatz Inkrementieren
(keine do-while aber möglich mit True +break)
y = 0
while True:
print(f"y ist: {y}") // Anweisung
y += 1 // Anweisung Zusatz Inkrementieren
if y >= 3: // Alternativ mit if not Bedingung möglich
break
Ausnahmebehandlungen: (try-except-finally, raise)
try:
zahl = int("abc") # Fehler: Ungültige Zahl
except ValueError:
print("Fehler: Ungültige Eingabe!")
finally:
print("Dieser Code wird immer ausgeführt.") # Fehler manuell auslösen
raise Exception("Ein Fehler ist aufgetreten!")
Funktionen/Methoden
Funktionen (Schlüsselwort def)
def Bezeichner(parameter): // Funktions-/Methodenrumpf
return Rückgabewert
Datenkapselung:
public: name
protected:_name
private:__name
statische Methode:
@static
def addieren(a,b):
Klassenaufbau
class Auto: // Klassenname
fahrzeuge_gesamt = 0 //Klassenattribut
def __init__(self, marke, baujahr): // Konstruktor
self.marke = marke // Instanzvariable
self.baujahr = baujahr
Auto.fahrzeuge_gesamt += 1 //Klassenattribut erhöhen
def fahren(self): // Methode
print(f"{self.marke} fährt los!")
auto1 = Auto("BMW", 2022) // Objekte erstellen
auto2 = Auto("Audi", 2020)
print(f"Anzahl der Autos: {Auto.fahrzeuge_gesamt}") //Ausgabe: Anzahl der Autos: 2
print(f"Anzahl der Autos (über Instanz): {auto1.fahrzeuge_gesamt}") // Ausgabe: 2
Standartkonstruktor:
class Auto:
def __init__(self): # Standardkonstruktor
self.marke = "Unbekannt"
self.baujahr = 2000
Allgemeiner Konstruktor:
class Auto:
def __init__(self, marke="Unbekannt", baujahr=2000): // Allgemeiner Konstruktor
self.marke = marke
self.baujahr = baujahr
Parametrisierter Konstruktor:
class Auto
def __init__(self, marke, baujahr): // Para-Konstruktor
self.marke = marke
self.baujahr = baujahr
Getter/Setter mit Properties (Syntax am einfachsten):
class Auto:
def __init__(self, marke):
self.__marke = marke // Private Instanzvariable
@property // Getter
def marke(self):
return self.__marke
@marke.setter // Setter
def marke(self, neue_marke):
if neue_marke:
self.__marke = neue_marke
Vererbung
class Auto(Fahrzeug): // Abgeleitete Klasse(Subklasse)
def __init__(self, marke, baujahr, sitzplätze):
super().__init__(marke, baujahr) // Konstruktor der Basisklasse aufrufen
self.sitzplätze = sitzplätze
