Listen, Funktionen und Schleifen#

Listen#

Initialisiere eine Liste mit den Werten folgenden Werten: dein Alter, die letzten Ziffern deiner Postleitzahl, dein Geburtsjahr und die ersten zwei Ziffern deiner Matrikelnummer.

# Dein Code
Hide code cell source 
meine_list =  [25, 317, 1997, 37]

Füge der Liste die Werte 64, 17, 45 hinzu.

# Dein Code
Hide code cell source 
# Möglichkeit 1
meine_list.extend([64, 17, 45])

# Möglichkeit 2
meine_list.append(64)
meine_list.append(17)

Erweitere deine Liste mit der Liste ‘abc’

abc = [1,6,1,4]
Hide code cell source 
# Möglichkeit 1
meine_list.extend(abc)

# Möglichkeit 2
meine_list = meine_list + abc

# Möglichkeit 3
meine_list += abc

Ersetze den 10. Wert deiner Liste mit 9.

# Dein Code
Hide code cell source 
meine_list[9] = 9

Gib die letzten 3 Werte deiner Liste aus

# Dein Code
Hide code cell source 
# Hier wird der Doppelpunkt gebraucht um eine Sequenz statt eines einzelnen Werts auszugeben.
print(meine_list[-3:])

# Zusatz: Mit dieser Schreibweise kann auch eine Schrittweite angegeben werden.
# In diesem Fall wird ab der Stelle 4  (inklusive) jeder zweite Wert bis zum Wert 10 (exklusive) der Liste ausgegeben.
print(meine_list[4:10:2])

Lösche den Wert an index 4 und gib diesen zurück

# Dein Code
Hide code cell source 
# Pop löscht den Wert am angegebenen INDEX und gibt diesen auch zürck.
a = meine_list.pop(1)
print(a)

# Zusatz: Remove löscht den ersten vorkommenden WERT, der als Parameter angeben wurde.
meine_list.remove(1)

Gegeben sei die Liste von Listen ‘schachbrett’. In ihr sind die Positionen von Schachfiguren gespeichert.

schachbrett = [['schwarzes Pferd', 'schwarzer Bauer', None, None, None, None, 'weisser Bauer', None],
               [None, None, None, None, None, None, 'schwarzer Bauer', None],
               [None, None, None, None, None, None, 'schwarzer König', None],
               ['schwarzer Bauer', None, None, 'weisser Turm', None, None, None, None],
               [None, None, 'weisser König' , None, 'schwarzer Läufer', 'schwarzer Bauer', None, None],
               [None, None, None, None, None, None, None, None],
               [None, None, 'weisse Dame', None, None, None, None, None],
               ['schwarzer Bauer', None, None, None, None, 'schwarze Dame', None, None]]

Wie groß ist das Schachbrett? Gib die Länge und Breite des Spielfeldees aus

# Dein Code
Hide code cell source 
print(len(schachbrett))
print(len(schachbrett[1]))

Welche Figur steht in der 5. Reihe, auf Position 6?

# Dein Code
Hide code cell source 
print(schachbrett[4][5])

Bewege die schwarze Dame diagonal zwei Felder weit über das Spielfeld und gebe ihre neue Position aus.

# Dein Code
Hide code cell source 
# Dein Code
"""
Mit dieser Lösung können die Felder EINMALIG getauscht werden.
Die Werte sind hier hart codiert und
"""
#schachbrett[5][3] = 'schwarze Dame'
#schachbrett[7][5] = None

tmp = schachbrett[7][5]
schachbrett[7][5] = schachbrett[5][3]
schachbrett[5][3] = tmp

print(schachbrett)

Aufgabe 2: Funktionen#

Schreibe eine Funktion, die prüft ob zwei Wörter gleich sind. Teste die Funktion mit mehreren Wortpaaren.

# Dein Code
Hide code cell source 
# Möglichkeit 1
def similiar(a: str, b: str) -> bool:
    """
    Die Funktion vergleicht zwei Strings auf Gleichheit.
    :param a: Ein Wort, das verglichen werden soll.
    :param b: Ein zweites Wort, das verglichen werden soll.
    :return: True, falls die Worte gleich sind. False, sonst.
    """
    if a == b:
        print(f'{a} ist das gleich Wort wie {b}')
        return True
    else:
        print(f'{a} ist nicht das gleich Wort wie {b}')
        return False

# Möglichkeit 2
def similiar2(a, b):
    """
    Diese Funktion gibt das gleiche Ergebnis, wie die obige, nur kürzer.
    :param a:
    :param b:
    :return:
    """
    return a==b


print(similiar([1,2,3], 'Test'))
a = similiar('Welt', 'Welt')

similiar2('Udo', 'Jürgens')

Schreibe eine Funktion, die als Eingabe eine Liste erhält und das arithmetische Mittel dieser Liste berechnet und zurückgibt. Teste diese Funktion mit deiner erstellten Liste aus Aufgabe 1.

# Dein Code
Hide code cell source 
def arith_mitte(liste:list)-> float:
    """
    Berechnet das arithmetische Mittel, einer gegeben Liste.
    :param liste:
    :return:
    """
    return round(sum(liste)/len(liste), 2)

arith_mitte(meine_list)

Schreibe eine Funktion, die überprüft, ob ein König an der gegebenen Position steht (in unserem Beispiel steht die schwarze Dame auf [7][5]) und falls ein König existiert ihn in die angegebene Richtung bewegt. Die Richtung wird in den Himmelsrichtungen angegeben (d.h. NO = Nord-Ost usw.) und es soll überprüft werden, ob der König auf ein leeres Feld versetzt wird oder ob er sich über den Spielfeldrand hinaus bewegt. Falls sich der König auf ein Feld mit einer gleichfarbigen Figur stellen würde, bewegt sich der König nicht. Falls es eine andersfarbige Figur ist, wird diese geschlagen und der König wechselt das Feld.

# Dein Code
Hide code cell source 
def bewege_koenig(reihe:int, feld:int, richtung:str):

    # Hier wird zuerst überprüft, ob das Feld überhaupt auf dem Schachbrett existiert.
    if not (0 <= reihe < len(schachbrett) and 0 <= feld < len(schachbrett)):
        print("Gebe ein Feld an das existiert")
        return
    # Hier wird geprüft, ob ein König auf dem angegebenen Feld steht.
    if schachbrett[reihe][feld] is None:
        print("Auf dem Feld steht keine Figur.")
        return
    if not("König" in schachbrett[reihe][feld]):
        print("Auf dem Feld steht kein König.")
        return

    # Hier wird die Richtung überprüft und das Feld auf das der König gestellt wird berechnet. Anschließend wird die Funktion ziehen aufgerufen um den König auf das neue Feld zu ziehen.
    if richtung == "N":
        neue_reihe = reihe - 1
        neues_feld = feld
        ziehen(reihe, feld, neue_reihe, neues_feld)
    elif richtung == "S":
        neue_reihe = reihe + 1
        neues_feld = feld
        ziehen(reihe, feld, neue_reihe, neues_feld)
    elif richtung == "W":
        neue_reihe = reihe
        neues_feld = feld - 1
        ziehen(reihe, feld, neue_reihe, neues_feld)
    elif richtung == "O":
        neue_reihe = reihe
        neues_feld = feld + 1
        ziehen(reihe, feld, neue_reihe, neues_feld)
    elif richtung == "NW":
        neue_reihe = reihe - 1
        neues_feld = feld - 1
        ziehen(reihe, feld, neue_reihe, neues_feld)
    elif richtung == "NO":
        neue_reihe = reihe - 1
        neues_feld = feld + 1
        ziehen(reihe, feld, neue_reihe, neues_feld)
    elif richtung == "SO":
        neue_reihe = reihe + 1
        neues_feld = feld + 1
        ziehen(reihe, feld, neue_reihe, neues_feld)
    elif richtung == "SW":
        neue_reihe = reihe + 1
        neues_feld = feld - 1
        ziehen(reihe, feld, neue_reihe, neues_feld)


# ziehen ist eine Hilfsfunktion, welche überprüft, ob das neue Feld in der neuen Reihe existiert und ob sich eine Figur der gleichen Farbe auf dem neuen Feld befindet. Falls das neue Feld existiert und sich keine gleichfarbige Figur darauf befindet, zieht die figur vom angegebenen Feld auf das neue Feld.
def ziehen(reihe:int, feld:int, neue_reihe:int, neues_feld:int):
    if not(0 <= neue_reihe < len(schachbrett) and 0 <= neues_feld < len(schachbrett)):
        print("Der König kann sich nur auf dem Schachfeld bewegen.")
        return
    if schachbrett[neue_reihe][neues_feld] is not None:
        if ("schwarz" in schachbrett[reihe][feld] and "schwarz" in schachbrett[neue_reihe][neues_feld]) or ("weiss" in schachbrett[reihe][feld] and "weiss" in schachbrett[neue_reihe][neues_feld]):
            print("Auf dem Feld steht bereits eine gleichfarbige Figur.")
            return
        else:
            schachbrett[neue_reihe][neues_feld] = schachbrett[reihe][feld]
            schachbrett[reihe][feld] = None
    else:
        schachbrett[neue_reihe][neues_feld] = schachbrett[reihe][feld]
        schachbrett[reihe][feld] = None


bewege_koenig(2, 6, "N")
print(schachbrett)

for-Schleifen#

Schreibe eine for-Schleife die Buchstaben in dem Wort Donau-Dampfschifffahrtsgesellschaft zählt

# Dein Code
Hide code cell source 
text = 'Donau-Dampfschifffahrtsgesellschaft'

counter = int()
for zeichen in text:
    if zeichen.isalpha():
        counter += 1


for buchstabe in text:
    print(len(text))

print(counter)

Gib alle durch zwei teilbaren Werte der in Aufgabe 1 definierten Liste aus.

# Dein Code
Hide code cell source 
for nummer in meine_list:
    if nummer%2 == 0:
        print(nummer)

Finde auf dem Schachbrett die Position des weißen Königs

# Dein Code
Hide code cell source 
gesuchte_figur = 'weisser König'
for reihe in schachbrett:
    if gesuchte_figur in reihe:
        print(schachbrett.index(reihe), reihe.index(gesuchte_figur))

Finde heraus wie viele schwarze Bauern es auf dem Spielfeld gibt.

# Dein Code
Hide code cell source 
# Möglichkeit 1
print(sum(sublist.count('schwarzer Bauer') for sublist in schachbrett))

# Möglichkeit 2
counter = 0
for sublist in schachbrett:
    counter += sublist.count('schwarzer Bauer')
print(counter)

Bonusaufgaben#

Modifiziere die Funktion für den König so, dass sich diese modifizierte Funktion auf die Damen anwenden lassen. Hierbei wird zusätzlich zur Position und der Richtung auch noch die anzahl der Felder übergeben die sich die Königin bewegt.

# Dein Code

Recherchiere im Internet nach Sortieralgorithmen und schreibe eine Funktion der einen Sortieralgorithmus deiner Wahl implementiert. Teste die Funktion mit deiner Liste.

# Dein Code