Dog with inheritance

src/analysis/__main__.py

@@ -1,13 +0,0 @@
-from analysis.io import load_sales
-from analysis.metrics import revenue_per_day
-from analysis.plotting import plot_daily_revenue
-
-
-def main() -> None:
-    df = load_sales("resources/sales.csv")
-    daily = revenue_per_day(df)
-    plot_daily_revenue(daily)
-
-
-if __name__ == "__main__":
-    main()

src/analysis/io.py

@@ -1,5 +0,0 @@
-import pandas as pd
-
-
-def load_sales(path: str) -> pd.DataFrame:
-    return pd.read_csv(path, sep=",", encoding="utf-8")

src/analysis/metrics.py

@@ -1,6 +0,0 @@
-import pandas as pd
-
-
-def revenue_per_day(df: pd.DataFrame) -> pd.Series:
-    revenue = df["quantity"] * df["unit_price"]
-    return revenue.groupby(df["day"]).sum()

src/analysis/plotting.py

@@ -1,9 +0,0 @@
-import matplotlib.pyplot as plt
-import pandas as pd
-
-
-def plot_daily_revenue(daily: pd.Series) -> None:
-    daily.plot(kind="bar")
-    plt.title("Daily Revenue")
-    plt.tight_layout()
-    plt.show()

src/codewars/MenuDisplay.py

@@ -1,37 +0,0 @@
-class Menu:
-    def __init__(self, selects: list):
-        self.selects = selects
-        self.cursor = 0
-
-    def to_the_right(self):
-        self.cursor = (self.cursor + 1) % len(self.selects)
-
-    def to_the_left(self):
-        self.cursor = (self.cursor - 1) % len(self.selects)
-
-    def display(self):
-        return (
-            "["
-            + ", ".join(
-                [
-                    f"'{s}'" if i != self.cursor else f"['{s}']"
-                    for i, s in enumerate(self.selects)
-                ]
-            )
-            + "]"
-        )
-
-
-if __name__ == "__main__":
-    menu = Menu(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])
-
-    print(menu.display())
-    menu.to_the_right()
-    print(menu.display())
-    menu.to_the_left()
-    menu.to_the_left()
-    menu.to_the_left()
-    print(menu.display())
-    menu.to_the_left()
-    menu.to_the_left()
-    print(menu.display())

src/codewars/__main__.py

@@ -1,4 +0,0 @@
-from codewars.lastDigitOfHugeNumber import last_digit
-
-if __name__ == "__main__":
-    print(last_digit([1, 2, 3, 4, 5]))

src/dog.py

@@ -1,15 +1,16 @@
-from abc import ABC, abstractmethod
-
-
-class Dog(ABC):
+class Dog:
     amount_of_dogs = 0
     name: str
+    race: str
     age: int
     weight: float
     bark_sound: str
 
-    def __init__(self, name: str, age: int, weight: float, bark_sound: str) -> None:
+    def __init__(
+        self, name: str, race: str, age: int, weight: float, bark_sound: str
+    ) -> None:
         self.name = name
+        self.race = race
         self.age = age
         self.weight = weight
         self.bark_sound = bark_sound
@@ -17,11 +18,10 @@ class Dog(ABC):
         Dog.amount_of_dogs += 1
 
     def __str__(self):
-        return f"{self.name} is a {self.age} year old {self.__class__.__name__}"
+        return f"{self.name} is a {self.age} year old {self.race}"
 
-    @abstractmethod
     def bark(self, times: int = 1) -> str:
-        pass
+        return f"{self.name} says:" + (f" {self.bark_sound}" * times)
 
     def birthday(self) -> str:
         self.age += 1
@@ -30,35 +30,21 @@ class Dog(ABC):
     def is_puppy(self) -> bool:
         return self.age < 2
 
-    def __eq__(self, other):
-        return self.name == other.name
-
 
 class Shepperd(Dog):
+    race: str = "shepperd"
     bark_sound: str = "Woo!"
 
     def __init__(self, name: str, age: int, weight: float) -> None:
-        Dog.__init__(self, name, age, weight, Shepperd.bark_sound)
-
-    def bark(self, times: int = 1) -> str:
-        return f"{self.name} says:" + (f" {self.bark_sound}" * times)
+        Dog.__init__(self, name, Shepperd.race, age, weight, Shepperd.bark_sound)
 
 
 class Poodle(Dog):
+    race: str = "poodle"
     bark_sound: str = "Wow!"
 
     def __init__(self, name: str, age: int, weight: float) -> None:
-        Dog.__init__(self, name, age, weight, Poodle.bark_sound)
-
-    def bark(self, times: int = 1) -> str:
-        return f"{self.name} says:" + (f" {self.bark_sound}" * times)
-
-
-class Bulldog(Dog):
-    bark_sound: str = "WUUUU!"
-
-    def __init__(self, name: str, age: int, weight: float) -> None:
-        Dog.__init__(self, name, age, weight, Bulldog.bark_sound)
+        Dog.__init__(self, name, Poodle.race, age, weight, Poodle.bark_sound)
 
 
 dog1 = Shepperd("Bello", 5, 22.5)
@@ -67,8 +53,7 @@ print(dog1.bark())
 print(dog1.birthday())
 print(Dog.amount_of_dogs)
 
-dog2 = Poodle("Bello", 10, 20)
+dog2 = Poodle("Barky", 10, 20)
 print(dog2.bark(3))
 print(dog2.is_puppy())
 print(Dog.amount_of_dogs)
-print(dog2 == dog1)

src/exercises/ex1/main.py

@@ -1,31 +0,0 @@
-# Ziel dieses Skripts:
-#
-#   1. Das Produkt von 6 * 7 berechnen          → Erwartet: 42.0
-#   2. Die Kreisfläche für Radius 5 berechnen   → Erwartet: ~78.54
-#   3. Den genauen Wert von PI ausgeben         → Erwartet: 3.141592653589793
-#
-# ----------------------------------------------------------------------
-# AUFGABE: Das Skript liefert falsche Ergebnisse. Finde den Fehler und
-#          korrigiere die Import-Anweisungen – ohne den restlichen Code
-#          zu verändern!
-# ----------------------------------------------------------------------
-
-import src.mathematik as math  # (1) Import aus mathematik
-import src.geometrie as geo  # (2) Import aus geometrie
-
-
-def main():
-    # --- Aufgabe 1: Produkt berechnen (nutzt mathematik.berechne) ---
-    produkt = math.berechne(6, 7)  # Erwartet: 42.0 — bekommt aber einen Fehler!
-    print(f"6 × 7 = {produkt}")
-
-    # --- Aufgabe 2: Kreisfläche (nutzt geometrie.berechne) ---
-    flaeche = geo.berechne(5)  # Erwartet: ~78.54
-    print(f"Kreisfläche (r=5): {flaeche:.4f}")
-
-    # --- Aufgabe 3: PI-Wert ---
-    print(f"PI = {math.PI}")  # Erwartet: 3.141592653589793
-
-
-if __name__ == "__main__":
-    main()

src/exercises/ex1/src/geometrie.py

@@ -1,14 +0,0 @@
-# geometrie.py
-# Modul für geometrische Berechnungen (Kreisflächen, Umfang usw.)
-
-PI = 3.14  # Vereinfachter Wert (nur 2 Nachkommastellen!)
-
-
-def berechne(radius: float) -> float:
-    """Berechnet die Fläche eines Kreises: A = PI * r²"""
-    return PI * radius**2
-
-
-def umfang(radius: float) -> float:
-    """Berechnet den Umfang eines Kreises: U = 2 * PI * r"""
-    return 2 * PI * radius

src/exercises/ex1/src/mathematik.py

@@ -1,14 +0,0 @@
-# mathematik.py
-# Modul für allgemeine mathematische Berechnungen
-
-PI = 3.141592653589793  # Hochpräziser Wert
-
-
-def berechne(a: float, b: float) -> float:
-    """Berechnet das Produkt zweier Zahlen."""
-    return a * b
-
-
-def potenz(basis: float, exponent: int) -> float:
-    """Berechnet basis hoch exponent."""
-    return basis**exponent

src/exercises/ex2/main.py

@@ -1,52 +0,0 @@
-# Ziel dieses Skripts:
-#
-#   Testergebnisse einer Klasse auswerten und formatiert ausgeben.
-#
-#   Gegeben: Punkte von 5 Studierenden (von max. 100 Punkten)
-#   Erwartet:
-#     Mittelwert    →  73.5  (kaufm. gerundet → 74  → "Gut")
-#     Max. Punkte   →  100   (aus statistik.MAX_WERT)
-#
-# ----------------------------------------------------------------------
-# AUFGABE: Das Skript gibt falsche Werte aus. Es gibt keine Fehlermeldung
-#          vom Interpreter. Finde heraus, warum die Ergebnisse falsch sind
-#          und korrigiere die Import-Anweisungen!
-# ----------------------------------------------------------------------
-
-import src.statistik as stat  # importiert: runde, mittelwert, bewerte, MAX_WERT, MIN_WERT
-import src.formatierung as formatting  # importiert: runde, als_prozent, trennlinie, MAX_WERT, MIN_WERT
-
-PUNKTE = [92, 85, 61, 48, 82]
-
-
-def auswertung():
-    print(formatting.trennlinie("="))
-    print("  TESTERGEBNISSE")
-    print(formatting.trennlinie("="))
-
-    # --- Mittelwert berechnen und benoten ---
-    mw = stat.mittelwert(PUNKTE)
-    mw_gerundet = stat.runde(mw)  # Soll kaufm. auf int runden → Erwartet: 74
-    note = stat.bewerte(mw)
-
-    print(f"  Mittelwert     : {mw}")
-    print(f"  Gerundet       : {mw_gerundet}   ← Erwartet: 74  (int)")
-    print(f"  Durchschnittsnote: {note}")
-
-    print(formatting.trennlinie())
-
-    # --- Maximale Punktzahl aus dem Modul ---
-    print(f"  Max. Punkte    : {stat.MAX_WERT}   ← Erwartet: 100")
-
-    print(formatting.trennlinie())
-
-    # --- Einzelne Ergebnisse ---
-    print("  Einzelergebnisse:")
-    for p in PUNKTE:
-        print(f"    {p:>3} Punkte  → {stat.bewerte(p)}")
-
-    print(formatting.trennlinie("="))
-
-
-if __name__ == "__main__":
-    auswertung()

src/exercises/ex2/src/formatierung.py

@@ -1,21 +0,0 @@
-# formatierung.py
-# Modul für Ausgabe-Formatierung und Darstellung
-
-MAX_WERT = 255  # Maximaler RGB-Farbwert (0–255)
-MIN_WERT = 0  # Minimaler RGB-Farbwert
-
-
-def runde(wert: float, stellen: int = 2) -> float:
-    """Rundet auf 'stellen' Nachkommastellen (für Anzeige-Formatierung)."""
-    faktor = 10**stellen
-    return int(wert * faktor + 0.5) / faktor
-
-
-def als_prozent(wert: float, gesamt: float) -> str:
-    """Gibt einen Wert als formatierten Prozentstring zurück."""
-    return f"{runde(wert / gesamt * 100)} %"
-
-
-def trennlinie(zeichen: str = "-", laenge: int = 40) -> str:
-    """Erzeugt eine Trennlinie für die Konsolenausgabe."""
-    return zeichen * laenge

src/exercises/ex2/src/statistik.py

@@ -1,30 +0,0 @@
-# statistik.py
-# Modul für statistische Berechnungen
-
-MAX_WERT = 100  # Maximale Punktzahl in einem Test (0–100)
-MIN_WERT = 0  # Minimale Punktzahl
-
-
-def runde(wert: float) -> int:
-    """Rundet kaufmännisch auf ganze Zahlen (für Testergebnisse)."""
-    return int(wert + 0.5)
-
-
-def mittelwert(werte: list[float]) -> float:
-    """Berechnet den arithmetischen Mittelwert einer Liste."""
-    return sum(werte) / len(werte)
-
-
-def bewerte(punkte: float) -> str:
-    """Gibt eine Note zurück basierend auf Punktzahl (0–100)."""
-    p = runde(punkte)
-    if p >= 90:
-        return "Sehr gut"
-    elif p >= 75:
-        return "Gut"
-    elif p >= 60:
-        return "Befriedigend"
-    elif p >= 45:
-        return "Ausreichend"
-    else:
-        return "Ungenügend"

src/exercises/ex3/main.py

@@ -1,51 +0,0 @@
-# Lotterie-Simulation: Zieht 6 aus 45 Zahlen, dazu eine Zusatzzahl.
-#
-# Wiederholt die Ziehung 5× und gibt die Ergebnisse aus.
-# Anschließend wird die Gewinnerliste zufällig gemischt.
-#
-# Erwartetes Verhalten:
-#   • Jede Ziehung liefert 6 VERSCHIEDENE, ZUFÄLLIGE Zahlen aus 1–45
-#   • Wiederholte Aufrufe liefern UNTERSCHIEDLICHE Ergebnisse
-#   • Die Teilnehmerliste ist nach dem Mischen in ZUFÄLLIGER Reihenfolge
-#
-# ----------------------------------------------------------------------
-# AUFGABE: Das Programm läuft ohne Fehlermeldung, aber die Ergebnisse
-#          sind offensichtlich nicht zufällig. Finde die Ursache und
-#          behebe den Fehler – ohne ziehung.py oder statistik.py zu ändern!
-#
-# REMARK:  Möglicherweise ist das Problem sogar abhängig von der verwendeten
-#          IDE... Lasst das main.py mal aus eurer IDE laufen sowie aus dem
-#          Terminal. Sind die Resultate gleich?
-# ----------------------------------------------------------------------
-
-from ziehung import ziehe_zahlen, ziehe_zusatzzahl
-from statistik import simuliere_ziehungen, mische_teilnehmer
-
-TEILNEHMER = ["Alice", "Bob", "Carol", "Dave", "Eve"]
-
-
-def main():
-    print("=" * 45)
-    print("       LOTTO-SIMULATION  (6 aus 45)")
-    print("=" * 45)
-
-    print("\n--- 5 unabhängige Ziehungen ---")
-    for i, ziehung in enumerate(simuliere_ziehungen(5), 1):
-        print(f"  Ziehung {i}: {ziehung}")
-
-    print("\n--- Einzelziehung mit Zusatzzahl ---")
-    haupt = ziehe_zahlen()
-    zusatz = ziehe_zusatzzahl(haupt)
-    print(f"  Hauptzahlen : {haupt}")
-    print(f"  Zusatzzahl  : {zusatz}")
-
-    print("\n--- Gewinnerliste (zufällig gemischt) ---")
-    gemischt = mische_teilnehmer(TEILNEHMER)
-    for rang, name in enumerate(gemischt, 1):
-        print(f"  Rang {rang}: {name}")
-
-    print("=" * 45)
-
-
-if __name__ == "__main__":
-    main()

src/exercises/ex3/random_stub.py

@@ -1,27 +0,0 @@
-# random.py
-#
-# Dieses Modul wurde angelegt, um eigene Hilfsfunktionen für
-# "Zufallsentscheidungen" in der Lotterie-Logik bereitzustellen.
-#
-# Es definiert einige der gleichen Funktionen wie das Standardmodul –
-# aber mit vereinfachter (fehlerhafter) Implementierung.
-
-
-def randint(a: int, b: int) -> int:
-    """Gibt eine 'zufällige' Ganzzahl zwischen a und b zurück."""
-    return a  # ← gibt IMMER den kleinsten Wert zurück!
-
-
-def shuffle(lst: list) -> None:
-    """Mischt eine Liste in-place."""
-    pass  # ← tut gar nichts!
-
-
-def sample(population: list, k: int) -> list:
-    """Gibt k zufällige Elemente aus population zurück."""
-    return list(population)[:k]  # ← gibt IMMER die ersten k Elemente zurück!
-
-
-def seed(a=None):
-    """Setzt den Zufallsgenerator-Seed."""
-    pass  # ← keine Wirkung

src/exercises/ex3/statistik.py

@@ -1,20 +0,0 @@
-# Wertet mehrere Lottoziehungen statistisch aus
-
-import random
-from ziehung import ziehe_zahlen
-
-
-def simuliere_ziehungen(anzahl: int = 10) -> list[list[int]]:
-    """Führt 'anzahl' unabhängige Lottoziehungen durch."""
-    ergebnisse = []
-    for _ in range(anzahl):
-        zahlen = ziehe_zahlen()
-        ergebnisse.append(zahlen)
-    return ergebnisse
-
-
-def mische_teilnehmer(teilnehmer: list[str]) -> list[str]:
-    """Mischt die Teilnehmerliste zufällig (z. B. für Gewinner-Reihenfolge)."""
-    kopie = teilnehmer[:]
-    random.shuffle(kopie)
-    return kopie

src/exercises/ex3/ziehung.py

@@ -1,19 +0,0 @@
-# lotterie/ziehung.py
-# Modul für die eigentliche Lottoziehung
-
-import random
-
-ZAHLEN_POOL = list(range(1, 46))  # Zahlen 1–45
-
-
-def ziehe_zahlen(anzahl: int = 6) -> list[int]:
-    """Zieht 'anzahl' verschiedene Lottozahlen aus dem Pool."""
-    gezogen = random.sample(ZAHLEN_POOL, anzahl)
-    gezogen.sort()
-    return gezogen
-
-
-def ziehe_zusatzzahl(ausgeschlossen: list[int]) -> int:
-    """Zieht eine Zusatzzahl, die nicht in der Hauptziehung vorkommt."""
-    pool = [z for z in ZAHLEN_POOL if z not in ausgeschlossen]
-    return random.randint(1, len(pool) - 1)  # ← Index in pool, dann Lookup

src/exercises/ex4/main.py

@@ -1,53 +0,0 @@
-# Schulverwaltungs-Simulation:
-#   • Drei Schüler werden angelegt (mit Noten in zwei Kursen)
-#   • Zwei Kurse werden erstellt, Schüler werden eingeschrieben
-#   • Notenspiegel je Schüler und Kursbericht je Kurs wird ausgegeben
-#
-# ----------------------------------------------------------------------
-# AUFGABE:  Das Programm lässt sich gar nicht erst starten – es gibt
-#           sofort einen ImportError.
-#
-#           1. Lies die Fehlermeldung sorgfältig und zeichne den
-#              Importgraphen auf:  Welches Modul importiert welches?
-#
-#           2. Versuche durch eine geeignete Gegenmassnahme den Fehler zu
-#              beheben.
-# ----------------------------------------------------------------------
-
-from src.kurs import Kurs
-from src.schueler import Schueler
-
-
-def main():
-    # --- Schüler anlegen ---
-    anna = Schueler("Anna Meier", {"Mathematik": 2.5, "Deutsch": 3.0})
-    ben = Schueler("Ben Keller", {"Mathematik": 5.0, "Deutsch": 2.0})
-    clara = Schueler("Clara Huber", {"Mathematik": 3.5, "Deutsch": 4.5})
-
-    # --- Kurse anlegen und Schüler einschreiben ---
-    mathe = Kurs("Mathematik")
-    deutsch = Kurs("Deutsch")
-
-    for s in [anna, ben, clara]:
-        mathe.einschreiben(s)
-        deutsch.einschreiben(s)
-
-    # --- Ausgabe Notenspiegel ---
-    print("=" * 45)
-    print("  NOTENSPIEGEL")
-    print("=" * 45)
-    for s in [anna, ben, clara]:
-        print(s.notenspiegel())
-        print()
-
-    # --- Ausgabe Kursberichte ---
-    print("=" * 45)
-    print("  KURSBERICHTE")
-    print("=" * 45)
-    print(mathe.kursbericht())
-    print(deutsch.kursbericht())
-    print("=" * 45)
-
-
-if __name__ == "__main__":
-    main()

src/exercises/ex4/src/helper.py

@@ -1,16 +0,0 @@
-# ---------------------------------------------------------------
-# Gemeinsam genutzte Hilfsfunktion – wird auch in schueler.py
-# über den Import von oben verwendet.
-# ---------------------------------------------------------------
-
-
-def ist_bestanden(note: float) -> bool:
-    """Gibt True zurück, wenn die Note ≤ 4.0 (bestanden) ist."""
-    return note <= 4.0
-
-
-def berechne_klassendurchschnitt(noten: list[float]) -> float:
-    """Berechnet den Notendurchschnitt einer Gruppe."""
-    if not noten:
-        return 0.0
-    return round(sum(noten) / len(noten), 2)

src/exercises/ex4/src/kurs.py

@@ -1,35 +0,0 @@
-# schulverwaltung/kurs.py
-#
-# Verwaltet Kurse und eingeschriebene Schüler.
-# Benötigt die Schueler-Klasse aus schueler.py für die Einschreibung
-# und Notenauswertung.
-
-from .helper import ist_bestanden, berechne_klassendurchschnitt
-from .schueler import Schueler
-
-
-class Kurs:
-    def __init__(self, name: str):
-        self.name = name
-        self.schueler: list[Schueler] = []
-
-    def einschreiben(self, schueler: Schueler) -> None:
-        """Schreibt einen Schüler in diesen Kurs ein."""
-        self.schueler.append(schueler)
-
-    def kursbericht(self) -> str:
-        """Gibt eine Übersicht über alle Schüler und den Kursdurchschnitt aus."""
-        zeilen = [f"\n  Kurs: {self.name}  ({len(self.schueler)} Schüler)"]
-        noten_im_kurs = []
-
-        for s in self.schueler:
-            note = s.noten.get(self.name)
-            if note is not None:
-                status = "✓" if ist_bestanden(note) else "✗"
-                zeilen.append(f"    {status}  {s.name:<20} {note:.1f}")
-                noten_im_kurs.append(note)
-
-        if noten_im_kurs:
-            schnitt = berechne_klassendurchschnitt(noten_im_kurs)
-            zeilen.append(f"  → Klassendurchschnitt: {schnitt:.2f}")
-        return "\n".join(zeilen)

src/exercises/ex4/src/schueler.py

@@ -1,28 +0,0 @@
-# Verwaltet Schüler-Daten und prüft den Abschlussstatus.
-# Benötigt ist_bestanden() aus kurs.py, um festzustellen ob
-# ein Schüler alle Kurse bestanden hat.
-
-from .helper import ist_bestanden
-
-
-class Schueler:
-    def __init__(self, name: str, noten: dict[str, float]):
-        """
-        name   : Vollständiger Name des Schülers
-        noten  : {Kursname: Note}  z. B. {'Mathematik': 4.5, 'Deutsch': 3.0}
-        """
-        self.name = name
-        self.noten = noten
-
-    def kann_abschliessen(self) -> bool:
-        """Gibt True zurück, wenn alle Kursnoten bestanden sind (Note ≤ 4.0)."""
-        return all(ist_bestanden(note) for note in self.noten.values())
-
-    def notenspiegel(self) -> str:
-        """Gibt eine formatierte Übersicht aller Noten zurück."""
-        zeilen = [f"  Schüler: {self.name}"]
-        for kurs, note in self.noten.items():
-            status = "✓" if ist_bestanden(note) else "✗"
-            zeilen.append(f"    {status}  {kurs:<18} Note: {note:.1f}")
-        zeilen.append(f"  → Abschluss möglich: {self.kann_abschliessen()}")
-        return "\n".join(zeilen)

src/exercises/inheritance.py

@@ -1,114 +0,0 @@
-from abc import ABC, abstractmethod
-
-
-class Speaker(ABC):
-    @abstractmethod
-    def speak(self):
-        pass
-
-
-class Sleeper(ABC):
-    @abstractmethod
-    def sleep(self):
-        pass
-
-
-class Dog(Speaker, Sleeper):
-    def speak(self):
-        print("Wau")
-
-    def sleep(self):
-        print("Zzzzz")
-
-
-dog = Dog()
-dog.speak()
-dog.sleep()
-
-
-class Storage(ABC):
-    @abstractmethod
-    def save(self, key: str, value: str) -> None:
-        pass
-
-    @abstractmethod
-    def load(self, key: str) -> str:
-        pass
-
-
-class MemoryStorage(Storage):
-    def __init__(self):
-        self.storage = {}
-
-    def save(self, key: str, value: str) -> None:
-        self.storage.update({key: value})
-
-    def load(self, key: str) -> str:
-        return self.storage.get(key)
-
-
-storage: Storage = MemoryStorage()
-storage.save("key", "value")
-print(storage.load("key"))
-
-
-class Person:
-    def __init__(self, name: str):
-        self.name = name
-
-
-class Student(Person):
-    def __init__(self, name: str, semester: int):
-        super().__init__(name)
-        self.semester = semester
-
-
-s = Student("Mein Name", 3)
-print(s.name)
-print(s.semester)
-
-
-class A:
-    def ping(self) -> None:
-        print(" A ")
-
-
-class B(A):
-    def ping(self) -> None:
-        print(" B ")
-        super().ping()
-
-
-class C(A):
-    def ping(self) -> None:
-        print(" C ")
-        super().ping()
-
-
-class D(B, C):
-    pass
-
-
-D().ping()
-
-
-class Animal(ABC):
-    @abstractmethod
-    def speak(self):
-        return "..."
-
-    def chorus(self, n: int):
-        if n <= 0:
-            raise ValueError(" n muss positiv sein ")
-        return " ".join(self.speak() for _ in range(n))
-
-
-class Cat(Animal):
-    def speak(self):
-        return super().speak()
-
-    def chorus(self, n: int):
-        return super().chorus(n)
-
-
-print(Cat().chorus(3))

src/exercises/my_logger.py

@@ -1,17 +0,0 @@
-import logging
-from pathlib import Path
-
-Path("data/logs").mkdir(parents=True, exist_ok=True)
-Path("data/logs/app.log").open("a")
-logging.basicConfig(
-    level=logging.ERROR,
-    filename="data/logs/app.log",
-    filemode="a",
-    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
-)
-
-logging.debug("Application started")
-logging.info("Application started")
-logging.warning("Application started")
-logging.error("Application started")
-logging.critical("Application started")

src/exercises/pathlib_test.py

@@ -1,22 +0,0 @@
-import json
-from pathlib import Path
-
-
-def create_orders():
-    path = Path("data/processed")
-    path.mkdir(parents=True, exist_ok=True)
-
-    orders_path = path / "orders.csv"
-    orders_path.open("w", encoding="utf-8")
-
-
-def create_settings():
-    settings = {"mode": "debug", "retries": 3}
-
-    with Path("data/processed/settings.json").open("w", encoding="utf-8") as f:
-        json.dump(settings, f, indent=2, ensure_ascii=False)
-
-
-if __name__ == "__main__":
-    # create_orders()
-    (create_settings())

src/resources/sales.csv

@@ -1,11 +0,0 @@
-day,product,quantity,unit_price,region
-Mon,Notebook,3,899.0,West
-Mon,Mouse,12,25.0,West
-Tue,Notebook,2,899.0,Ost
-Tue,Keyboard,5,70.0,Ost
-Wed,Monitor,4,220.0,West
-Wed,Mouse,10,25.0,Nord
-Thu,Keyboard,6,70.0,Sued
-Thu,Monitor,3,220.0,Ost
-Fri,Notebook,1,899.0,Nord
-Fri,Mouse,15,25.0,Sued