Menu Display

A
A
1
New Structure + Classy Extensions

src/Codewars/basic_subclasses.py

@@ -0,0 +1,17 @@
+class Human:
+    def __init__(self):
+        pass
+
+
+class Woman(Human):
+    pass
+
+
+class Man(Human):
+    pass
+
+
+def God():
+    adam = Man()
+    eve = Woman()
+    return [adam, eve]

src/Codewars/classy_extensions.py

@@ -0,0 +1,6 @@
+from preloaded import Animal
+
+
+class Cat(Animal):
+    def speak(self):
+        return f"{self.name} meows."

src/Codewars/menu_display.py

@@ -0,0 +1,39 @@
+class Menu:
+    def __init__(self, lst):
+        self.lst = lst
+        self.cursor_pos = 0
+
+    def to_the_right(self):
+        if self.cursor_pos < len(self.lst) - 1:
+            self.cursor_pos += 1
+        else:
+            self.cursor_pos = 0
+
+    def to_the_left(self):
+        if self.cursor_pos > 0:
+            self.cursor_pos -= 1
+        else:
+            self.cursor_pos = len(self.lst) - 1
+
+    def display(self):
+        result = []
+        for i, char in enumerate(self.lst):
+            if i == self.cursor_pos:
+                result.append([f"{char}"])
+            else:
+                result.append(f"{char}")
+        return str(result)
+
+
+menu = Menu([1, 2, 3])
+print(menu.display())
+menu.to_the_right()
+print(menu.display())
+menu.to_the_right()
+print(menu.display())
+menu.to_the_right()
+print(menu.display())
+menu.to_the_left()
+print(menu.display())
+menu.to_the_left()
+print(menu.display())

src/Klassen2/OOP:Interfaces&Vererbung_uebung1.py

@@ -0,0 +1,22 @@
+class Robot:
+    def speak(self, mood="happy") -> str:
+        if mood == "happy":
+            return "Robo"
+
+
+class Dog:
+    def speak(self):
+        return "Wuff"
+
+
+class Cat:
+    def speak(self):
+        return "Miau"
+
+
+def chorus(animals) -> None:
+    for a in animals:
+        print(a.speak())
+
+
+chorus([Dog(), Cat(), Robot()])

src/Klassen2/OOP:Interfaces&Vererbung_uebung2.py

@@ -0,0 +1,22 @@
+from abc import ABC, abstractmethod
+
+
+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[key] = value
+
+    def load(self, key: str) -> str:
+        return self.storage[key]

src/Klassen2/auf_den_Hund_gekommmen.py

@@ -0,0 +1,51 @@
+from abc import ABC, abstractmethod
+
+
+class Hund(ABC):
+
+    anzahl_hunde = 0
+
+    def __init__(self, name: str, alter: int, gewicht: float):
+        self.name = name
+        self.alter = alter
+        self.gewicht = gewicht
+        Hund.anzahl_hunde += 1
+
+    def __repr__(self):
+        return f"Hund=(name='{self.name}', rasse='{self.__class__.__name__}' , alter={self.alter}, gewicht={self.gewicht}kg)"
+
+    def __str__(self):
+        return f"Hund '{self.name}' ist ein '{self.alter}'-jaehriger '{self.__class__.__name__}' und wiegt '{self.gewicht}' kg."
+
+    @abstractmethod
+    def bellen(self, n: int = 1) -> None:
+        pass
+
+    def bday(self):
+        self.alter += 1
+        print(f"Alles Gute '{self.name}'. Du bist jetzt '{self.alter}' Jahre alt.")
+
+    def ist_welpe(self):
+        return self.alter < 2
+
+
+class Pudel(Hund):
+
+    def bellen(self, n=1):
+        print(" ".join(["wau"] * n))
+
+
+class Labrador(Hund):
+
+    def bellen(self, n=1):
+        print(" ".join(["wuff"] * n))
+
+
+hund1 = Labrador("Bello", 2, 15)
+hund1.bday()
+print(hund1.ist_welpe())
+hund2 = Pudel("Pudi", 7, 4)
+hund1.bellen(8)
+hund2.bellen(3)
+print(repr(hund1))
+print(str(hund1))

src/Klassen2/chorus.py

@@ -0,0 +1,31 @@
+from abc import ABC, abstractmethod
+
+
+class Animal(ABC):
+    @abstractmethod
+    def speak(self) -> str:
+        return "..."
+
+    def chorus(self, n: int) -> str:
+        if n <= 0:
+            raise ValueError("n muss positiv sein")
+        return " ".join(self.speak() for _ in range(n))
+
+
+class Dog(Animal):
+    def speak(self) -> str:
+        return "wuff"
+
+
+class Cat(Animal):
+    def speak(self) -> str:
+        return "miau"
+
+
+class Cow(Animal):
+    def speak(self) -> str:
+        return "muh"
+
+
+Berta = Cow()
+print(Berta.chorus(1))

src/Klassen2/mro.py

@@ -0,0 +1,17 @@
+class A:
+    pass
+
+
+class B(A):
+    pass
+
+
+class C(A):
+    pass
+
+
+class D(B, C):
+    pass
+
+
+print(D.mro())

src/Klassen2/ping.py

@@ -0,0 +1,24 @@
+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):
+    def ping(self) -> None:
+        print("D")
+        super().ping()
+
+
+D().ping()

src/is_pangram.py

@@ -1,9 +0,0 @@
-def is_pangram(st):
-    letters_used = []
-    alphabet = set("abcdefghijklmnopqrstuvwxyz")
-    for letter in st.lower():
-        if letter in alphabet:
-            letters_used.append(letter)
-    if set(letters_used) == alphabet:
-        return True
-    return False

src/vigenere_cipher_helper.py

@@ -1,56 +0,0 @@
-class VigenereCipher(object):
-    def __init__(self, key, alphabet):
-        self.key = key
-        self.alphabet = alphabet
-
-    def encode(self, text):
-        len_text = len(text)
-        len_key = len(self.key)
-
-        if len_key < len_text:
-            new_key = (
-                self.key * (len_text // len_key) + self.key[: (len_text % len_key)]
-            )
-        else:
-            new_key = self.key[:len_text]
-
-        new_text = []
-
-        for l_text, l_key in zip(text, new_key):
-            if l_text in self.alphabet:
-                if l_key in self.alphabet:
-                    new_pos = (
-                        self.alphabet.index(l_text) + self.alphabet.index(l_key)
-                    ) % len(self.alphabet)
-                else:
-                    new_pos = self.alphabet.index(l_text)
-                new_text.append(self.alphabet[new_pos])
-            else:
-                new_text.append(l_text)
-        return "".join(new_text)
-
-    def decode(self, text):
-        len_text = len(text)
-        len_key = len(self.key)
-
-        if len_key < len_text:
-            new_key = (
-                self.key * (len_text // len_key) + self.key[: (len_text % len_key)]
-            )
-        else:
-            new_key = self.key[:len_text]
-
-        new_text = []
-
-        for l_text, l_key in zip(text, new_key):
-            if l_text in self.alphabet:
-                if l_key in self.alphabet:
-                    new_pos = (
-                        self.alphabet.index(l_text) - self.alphabet.index(l_key)
-                    ) % len(self.alphabet)
-                else:
-                    new_pos = self.alphabet.index(l_text)
-                new_text.append(self.alphabet[new_pos])
-            else:
-                new_text.append(l_text)
-        return "".join(new_text)