Programmieren Teil 4 – Funktionen (Unterprogramme)

NA1

from gturtle import *
flori = Turtle()
 
def blume():
    flori.setPenColor("crimson")
    i = 0
    while i < 6:
        flori.rightArc(20, 60)
        flori.dot(30)
        i = i + 1
 
blume()
flori.setPos(60,60)
blume()
flori.setPos(100,-20)
blume()

NA2

from gturtle import *
flori = Turtle()
 
def blume(color):
    flori.setPenColor(color)
    i = 0
    while i < 6:
        flori.rightArc(20, 60)
        flori.dot(30)
        i = i + 1
 
blume("blue")
flori.setPos(60,60)
blume("violet")
flori.setPos(80,-20)
blume("orange")
flori.setPos(140, 30)
blume("purple")

NA3 – Schritt 1

from gturtle import *
flori = Turtle()
 
def blume(color, xpos, ypos):
    flori.setPenColor(color)
    flori.setPos(xpos, ypos)
    i = 0
    while i < 6:
        flori.rightArc(20, 60)
        flori.dot(30)
        i = i + 1
x = 0
while x < 600:
    blume("red", x, 0)
    x = x + 100

NA3 – Schritt 2

from gturtle import *
flori = Turtle()
 
def blume(color, xpos, ypos):
    flori.setPenColor(color)
    flori.setPos(xpos, ypos)
    i = 0
    while i < 6:
        flori.rightArc(20, 60)
        flori.dot(30)
        i = i + 1
 
colors = ["orange", "purple", "blue", "crimson", "pink", "violet", "yellow"]
xpositions = [0,55,105,145,200,225]
ypositions = [0,25,-10,25,50,10]
 
i = 0
while i < 6:
    blume(colors[i], xpositions[i], ypositions[i])
    i = i + 1

NA4

from gturtle import *
flori = Turtle()
flori.hideTurtle()
flori.clear("seagreen")
 
def blume(color, xpos, ypos):
    flori.setPenColor(color)
    flori.setPos(xpos, ypos)
    i = 0
    while i < 6:
        flori.rightArc(20, 60)
        flori.dot(30)
        i = i + 1
 
colors = ["orange", "purple", "pink", "crimson", "indigo", "violet", "magenta", "deeppink", "gold", "lightcoral"]
 
i = 0
while i < 20:
    col_pos = random.randint(0,9)
    blume(colors[col_pos], random.randint(-250,250), random.randint(-100,100))
    i = i + 1

NB1

def chf_in_nok(chf):
    return chf * 12.57
 
print(chf_in_nok(3))

NB2

def max_von_zwei(a, b):
    if a > b:
        return a
    else:
        return b
 
print(max_von_zwei(2,3))
print(max_von_zwei(3,4))

NB3

def zutaten_pfannkuchen(n):
    return n * 50, n * 0.125, n, n
 
n = input("Wie viele Personen?")
mehl, salz, milch, ei = zutaten_pfannkuchen(n)
print(f"Du brauchst:\n{mehl} g Mehl\n{salz} TL Salz\n{milch} dl Milch\n{ei} Eier")

NB4

def min_von_drei(a, b, c):
    if a < b and a < c:
        return a
    elif b < a and b < c:
        return b
    else:
        return c
 
print(min_von_drei(1,2,3))
print(min_von_drei(5,6,4))
print(min_von_drei(9,7,8))

NB5

list1 = [11, 16, 5, 12, 3, 13] 
list2 = [13, 2, 5, 10, 1, 17, 5, 25]
list3 = [-25, -13, -3, -33]
 
def max_in_liste(liste):
    max_wert = liste[0]
    i = 1
    while i < len(liste):
        if liste[i] > max_wert:
            max_wert = liste[i]
        i = i + 1
    return max_wert
 
print(max_in_liste(list1))
print(max_in_liste(list2))
print(max_in_liste(list3))

NB6

def ist_gerade(n):
    if n % 2 == 0:
        return True
    return False
 
print(ist_gerade(4))
print(ist_gerade(5))

NB7

def pizza_lieferung(personen):
    if personen * 12 >= 50:
        return personen * 12
    else:
        return personen * 12 + 20
 
print(pizza_lieferung(4))
print(pizza_lieferung(5))

NB8

NC1

from gturtle import*
karl = Turtle()
 
def hexagon(): 
    side_count = 0
    while side_count < 6:
        karl.forward(50)
        karl.right(60)
        side_count = side_count + 1
 
hex_count = 0 
while hex_count < 6:
    hexagon()
    karl.forward(50)
    karl.left(60)
    hex_count = hex_count + 1

NC2

import random
from gturtle import * 
flori = Turtle()
 
def punkte(min, max, colors):
    i = 0
    anz = random.randint(min, max)
    while i < anz:
        xpos = random.randint(-250,250)
        ypos = random.randint(-100,100)
        flori.setPenColor(colors[random.randint(0,len(colors)-1)])
        flori.setPos(xpos, ypos)
        flori.dot(20)
        i = i + 1
    return i
 
farben = ["red", "blue", "green", "orange"]
 
anz_punkte = punkte(5, 40, farben)
print(f"Es wurden {anz_punkte} Punkte gezeichnet.")

NC3

import random
from gturtle import *
tommy = Turtle()
tommy.hideTurtle()
tommy.clear("goldenrod")
 
def herzblatt(seite, farbe):
    tommy.setFillColor(farbe)
    tommy.startPath()
    tommy.forward(seite)
    tommy.rightArc(seite/2,180)
    tommy.left(90)
    tommy.rightArc(seite/2,180)
    tommy.forward(seite)
    tommy.fillPath()
    tommy.right(90)
 
def kleeblatt3(radius):
    i = 0
    while i < 3:
        herzblatt(radius, "green")
        tommy.right(120)
        i = i + 1
 
def kleeblatt4(radius):
    i = 0
    while i < 4:
        herzblatt(radius, "darkgreen")
        tommy.right(90)
        i = i + 1
 
i = 1 
while i < 30:
    xpos = random.randint(-250,250)
    ypos = random.randint(-100, 100)
    size = random.randint(20,30)
    tommy.setPos(xpos, ypos)
 
    if i % 7 == 0: 
        kleeblatt4(size)
    elif i % 3 == 0:
        kleeblatt3(size)
    else:
        tommy.setPenColor("crimson")
        tommy.dot(size)
 
    i = i + 1

NC3 Zusatzaufgabe

import random
import math
from gturtle import *
tommy = Turtle()
tommy.hideTurtle()
tommy.clear("lightpink")
 
def herzblatt2(seite, farbe1, farbe2):
    tommy.setFillColor(farbe1)
    tommy.startPath()
    tommy.forward(seite)
    tommy.rightArc(seite/2,180)
    tommy.right(45)
    tommy.forward(seite*math.sqrt(2))
    tommy.fillPath()
    tommy.setFillColor(farbe2)
    tommy.startPath()
    tommy.left(135)
    tommy.forward(seite)
    tommy.leftArc(seite/2,180)
    tommy.left(45)
    tommy.forward(seite*math.sqrt(2))
    tommy.fillPath()
 
def kleeblatt3(radius):
    i = 0
    while i < 3:
        herzblatt2(radius, "forestgreen", "green")
        tommy.right(15)
        i = i + 1  
 
def kleeblatt4(radius):
    i = 0
    while i < 4:
        herzblatt2(radius, "darkgreen", "007200")
        tommy.right(45)
        i = i + 1
 
i = 1 
while i < 30:
    xpos = random.randint(-250,250)
    ypos = random.randint(-100, 100)
    size = random.randint(20,30)
    tommy.setPos(xpos, ypos)
 
    if i % 7 == 0: 
        kleeblatt4(size)
    elif i % 3 == 0:
        kleeblatt3(size)
    else:
        tommy.setPenColor("crimson")
        tommy.dot(size)
 
    i = i + 1

NC4

def text_reverse(text):
    new_text = ""
    i = len(text)-1
    while i >= 0:
        new_text = new_text + text[i]
        i = i-1
    return new_text
 
print(text_reverse("Roti Rösli im Garte"))

def text_reverse(text):
    return text[::-1]
 
print(text_reverse("Roti Rösli im Garte"))

NC5

def replace_spaces(text, char):
    i = 0
    new_text = ""
    while i < len(text):
        if text[i] == ' ':
            new_text = new_text + char
        else:
            new_text = new_text + text[i]
        i = i + 1
    return new_text
 
print(replace_spaces("Roti Rösli im Garte", '-'))

NC6

def word_list(text):
    words = []
    word = ""
    i = 0
    while i < len(text):
        if text[i] == ' ': # Leerzeichen
            words.append(word)
            word = ""
        else:
            word = word + text[i]
        i = i + 1
    words.append(word)
    return words
 
def words_reverse(text): 
    words = word_list(text)
    new_text = ""
    i = len(words) - 1
    while i >= 0:
        new_text = new_text + words[i] + " "
        i = i - 1
    return new_text
 
print(words_reverse("Roti Rösli im Garte"))

O1

def hotel_preise2(personen, naechte, anreisetag):
    doppelzimmer = personen // 2
    einzelzimmer = personen % 2
    tage = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]    
    starttag = tage.index(anreisetag)
    preis = 0
    nacht = 0
 
    while nacht < naechte:
        aktueller_tag_index = (starttag + nacht) % 7
        aktueller_tag = tage[aktueller_tag_index]
 
        if aktueller_tag in ["Freitag", "Samstag"]:
            preis = preis + doppelzimmer * 200 + einzelzimmer * 150
        else:
            preis = preis + doppelzimmer * 140 + einzelzimmer * 120
 
        nacht = nacht + 1
 
    return preis
 
# Reise 1: 2 Personen, 2 Nächte ab Freitag: Preis = 400
print(hotel_preise2(2, 2, "Freitag"))
# Reise 2: 3 Personen, 4 Nächte ab Mittwoch: Preis = 1220 
print(hotel_preise2(3, 4, "Mittwoch"))
# Reise 3: 1 Person, 10 Nächte ab Donnerstag: Preis = 1320
print(hotel_preise2(1, 10, "Donnerstag"))

O2

from gturtle import *
paula = Turtle()
 
def rgb_dot(red, green, blue):
    hexcodes = ["00", "33", "66", "99", "CC", "FF"]
    colorcode = hexcodes[red] + hexcodes[green] + hexcodes[blue]
    paula.setPenColor(colorcode)
    paula.dot(40)
 
paula.right(90)
xpos = 0
ypos = 0
 
for r in range(6):
 
    for g in range(6):
 
        for b in range(6):
            paula.setPos(xpos, ypos)
            rgb_dot(r,g,b)
            xpos = xpos + 50
 
        xpos = xpos - 300
        ypos = ypos - 50
 
    xpos = xpos + 350
    ypos = 0

O3

from gturtle import * 
leonardo = Turtle()
 
def fibonacci(n):
    fibs = []
    s1 = 0
    s2 = 1
    i = 0
    while i < n:
        fibs.append(s1)
        s = s1 + s2
        s1 = s2
        s2 = s
        i = i + 1
    return fibs
 
def viertelkreis(radius, farbe):
    leonardo.setFillColor(farbe)
    leonardo.startPath()
    leonardo.rightArc(radius, 90)
    leonardo.right(90)
    leonardo.forward(radius)
    leonardo.fillPath()
    leonardo.right(180)
    leonardo.forward(radius)
    leonardo.right(90)
 
def fibo_spirale(n):
    fibos = fibonacci(n)
    i = 0
    while i < len(fibos):
        radius = fibos[i] * 10
        if i % 2 == 0:
            viertelkreis(radius,"red")
        else:
            viertelkreis(radius,"blue")
        i = i + 1
 
def fibo_spirale2(n, colors):
    fibos = fibonacci(n)
    i = 0
    while i < len(fibos):
        radius = fibos[i] * 10
        viertelkreis(radius, colors[i % len(colors)])
        i = i + 1
 
leonardo.right(90)        
farben = ["crimson", "orange", "maroon", "gold"]
fibo_spirale2(9, farben)

O4

import math
from gturtle import * 
 
carl = Turtle()
carl.hideTurtle()
 
def segment(length, color):
    l1 = length * 0.8
    l2 = (length - l1)/2
    side = l2 * math.sqrt(2)
    carl.setFillColor(color)
    carl.startPath()
    carl.right(45)
    repeat 2:
        carl.forward(side)
        carl.left(45)
        carl.forward(l1)
        carl.left(45)
        carl.forward(side)
        carl.left(90)
    carl.fillPath()
    carl.left(45)
 
def seven_seg(number):
    segment_codes = ['1111110', # 0
                     '0110000', 
                     '1101101', 
                     '1111001', 
                     '0110011', 
                     '1011011', 
                     '1011111', 
                     '1110000', 
                     '1111111', 
                     '1111011'] # 9
 
    xpositions = [0, 100, 100, 100, 0, 0, 0]
    ypositions = [0, 0, -100, -200, -200, -100, -100]
    headings = [90, 180, 180, 270, 0, 0, 90]
 
    i = 0
    for s in segment_codes[number]:
        carl.setPos(xpositions[i], ypositions[i])
        carl.setHeading(headings[i])
        if s == '0':
            segment(100, "gainsboro")
        else:
            segment(100, "red")
        i = i + 1
 
i = 0
while i <= 9:
    seven_seg(i)
    i = i + 1
    delay(1000)