lehrkraefte:ks:informatik-glf4-20 [https://fginfo.ksbg.ch Fachgruppe Informatik der KSBG]

This is an old revision of the document!

Ziele

Du kannst elementare Programme schreiben und ausführen.
Du kannst elementare Kontroll- und Schleifenstrukturen benennen und einsetzen.
Du weisst was Funktionen sind und kannst eigene Funktionen definieren und ausführen.

Ziel dieser Lektion(en) wird sein, dass wir das Sieb des Eratosthenes implementieren. Vereinfacht gesagt, handelt es sich beim Sieb des Eratosthenes um eine (langsame) Methode, alle Primzahlen kleiner einer Zahl $n$ zu bestimmen.

Aufträge

Wiederhole resp. lies die folgenden Konzepte nach
1. ''for''-Schleifen. Schreibe ein Programm, welches die folgenden Ausgaben hat
  1. alle geraden Zahlen bis 200
  2. alle ungeraden Zahlen bis 200
  3. alle Vielfachen von 7 bis 300
  4. alle Quadratzahlen bis 10000. Um Zahlen zu exponentieren, verwendet man * *. Um also $3^2$ zu berechnen, gibt man 3 2 ein.
2. Kontroll-Strukturen. Schreibe ein Programm, welches die Ausgaben, des Fizz Buzz-Spiel ausgibt. Um die Teilbarkeit einer Zahl zu überprüfen, kannst du den Modulo-Operator verwenden: 7%3 z.B. ergibt den Rest der bei der Division von 7 durch 3 entsteht.
3. Listen.
  1. Schreibe ein Prorgamm, welches aus der Liste [1,3,2,1,7,-1,7,2.1]
    1. den dritten Wert ausgibt
    2. den Durchschnitt des zweiten und dritten Wert ausgibt
    3. den Durchschnitt aller Werte ausgibt
    4. den höchsten Wert (ohne 7 fix zu nennen) mit 12 überschreibt.
    5. die Werte an der ersten und dritten Stelle tauscht.
  2. Ergänze das Programm unten so, dass dir die höchste Zahl (das Maximum) der Zufallsliste ausgegeben wird. Verwende dabei den Befehl max nicht sondern ausschliesslich die Vergleichsoperatoren < und > sowie if o.ä.
    findemaximum.py
    
    from random import randint #Funkion zum Erzeugen von zufälligen Listen def zufallszahlen(n): zufallsliste = [randint(0, 1000) for i in range(n)] return zufallsliste liste = zufallszahlen(100) print(liste) print(len(liste)) print(range(len(liste))) for i in range(len(liste)): #ergänze den Code.
4. Funktionen.
  1. Verwende deinen Code von oben, um eine Funktion zu schreiben, welche als Argument eine beliebige Liste hat und als Rückgabewert, den grössten Wert dieser Liste hat. Erweitere die Funktion mit einem zweiten Argument, so dass man spezifieren kann, ob man den grössten oder den kleinsten Wert zurückerhalten möchte. Verwende dazu die beiden Code-Skelette unten:
    function_skeleton.py
    
    def maximumliste(liste): #Hier kommt dein Code return(maximalerwert)
  2. Schreibe eine Funktion, welche für ein Argument $i$ alle Werte bis (ohne) zu diesem Wert ausdruckt. Verwende dafür eine for-Schlaufe. Nenne deine Funktion innereFunktion. Der Output deiner Funktion sollte z.B. sein
```
 innereFunktion(4)
0
1
2
3
```
5. Geschachtelte Schleifen. Schreibe eine Funktion, welche untenstehenden Output hat. Verwende dabei die Funktion innereFunktion von oben. Die horizontalen Abtrennungen kann man mit print(“======”) erreichen.
```
0
======
0
1
======
0
1
2
======
0
1
2
3
======
0
1
2
3
4
======
```
6. Löse die obere Aufgabe ohne den Aufruf deiner Funktion innereFunktion.
Lies dir den Artikel oben zum Sieb des Eratosthenes nochmals durch, falls noch unklar ist, wie es funktioniert. Besprich Fragen mit der Lehrperson.
1. Starte mit einer Liste der Länge $n$, welche für jede Zahl von $1$ bis $n$ besagt, ob sie eine Primzahl ist oder nicht. Zuerst sind alle Elemente dieser Liste (alle Zahlen) True: Du kannst z.B. isprime = [True for i in range(n+1)] verwenden¹⁾. An der $i$-ten Stelle der Liste, steht also die natürliche Zahl $i$. Die ersten beiden $i=0$ und $i=1$ «übergehen» wir in der Schlaufe einfach.
2. Nachher kannst du die entsprechenden Positionen in dieser Liste zu False ändern, wenn es keine Primzahl ist. Der range-Befehl, lässt beliebige Inkremente²⁾ zu: print(range(min,max,delta)) listet alle Zahlen zwischen min und max mit Abstand delta auf. Kopiere diesen Code, ersetze die Variablen durch Werte, und stelle sicher, dass du den Befehl verstehst.
3. Kombiniere die beiden Punkte oben zu eine Programm, welches alle Primzahlen bis zur Zahl $n$ ausgibt.
4. Weiterführend: Schreibe ein Programm, um die 100ste Primzahl ($n$-te) Primzahl zu bestimmen.
5. Weiterführend: Stelle die Laufzeits deines Proramms ($y$-Achse) in Abhängigkeit der Zahl $n$ ($x$-Achse) dar. Die Laufzeit kann z.B. mit folgender Idee gemessen werden:
  runtime.py
  import time start_time = time.time() # some code stop_time = time.time() print(stop_time-start_time)
  Die Darstellung als Streudiagramm (Scatterplot) kann z.B. hier abgeschaut werden.

Lösungen

Erster Teil

Schlaufen:

loesungen_1.py

 from math import floor
## I
for i in range(100):
    print(2*i)
# oder
for i in range(2,200,2):
    print(i)
## II
for i in range(100):
    print(2*i+1)
#oder
for i in range(1,200,2):
    print(i)
 
## III
for i in range(7,300,7):
    print(i)
# oder manuell floor runden ab.
for i in range(int(floor((300-7)/7))+1):
    print(7+i*7)
 
## IV; exponentieren erfolt mit **
for i in range(100+1):
    print(i**2)

FizzBuzz:

fizzbuzz.py

 for i in range(1, 100):
    if i % 3 == 0 and i % 5 == 0:
        print ("FizzBuzz")
    elif i % 3 == 0:
        print "Fizz"
    elif i % 5 == 0:
        print "Buzz"
    else:
        print i

Listenspielerein

listenspielerei.py

li = [1,3,2,1,7,-1,7,2.1]
# A
print(li[2])
 
# B 
av = li[1]+li[2]
print(av)
 
# C
lenli = len(li)  
sumvar = 0
 
for i in range(lenli):
    sumvar = sumvar+li[i]
 
print(sumvar/lenli)
 
# D: Funktioniert das immer? Macht das, was gewollt ist?
for i in range(lenli):
    if(li[i]==max(li)): 
        li[i]=12
 
print(li)
 
# E
li = [1,3,2,1,7,-1,7,2.1]
 
a = li[2]
li[2] = li[0]
li[0] = a
print(li)

Max

findemaximum_loesung.py

#I 
from random import randint
# Funkion zum Erzeugen von zufälligen Listen
def zufallszahlen(n):
    zufallsliste = [randint(0, 10000) for i in range(n)]
    return zufallsliste
 
 
liste = zufallszahlen(100)
print(liste)
print(len(liste))
print(range(len(liste)))
maxno = 0
for i in range(len(liste)):
    if liste[i] >= maxno:
        maxno = liste[i]
 
print(maxno)
 
 
def findMax(liste):
    maxno = 0
    for i in range(len(liste)):
        if liste[i] >= maxno:
            maxno = liste[i]
    return maxno
 
 
print(findMax(zufallszahlen(30000)))
#II
def innereFunktion(j):
  for i in range(j):
    print(i)
 
innereFunktion(4)
#III
for j in range(10):
  innereFunktion(j)
###
for j in range(10):
  for i in range(j):
     print(i)
  print("=======")

Sieb

sieb.py

from math import ceil
n=50
#Idee: Liste mit True/False ob die Zahlen 0,1,2,3,... Primzahlen sind
isPrime = [True for i in range(n+1)]
 
#Alle Zahlen ab 2 durchgehen, welche noch nicht durchgestrichen worden sind.
for i in range(2,n+1):
    #ist noch nicht rausgesrichen
    if isPrime[i] == True:
        #alle Vielflachen rausstreichen
        for j in range(2*i,n+1,i):
            isPrime[j] = False 
#alle nicht rausgesrichenen ausgeben
for p in range(2,n + 1): 
        if isPrime[p]: 
            print(p)
 
def Sieb(n):
    isPrime = [True for i in range(n+1)]
 
    for i in range(2,n+1):
        if isPrime[i] == True:
            for j in range(2*i,n+1,i):
                isPrime[j] = False 
    primes = []
    #alle nicht rausgesrichenen zur Liste hinzufügen
    for p in range(2,n + 1): 
            if isPrime[p]: 
                primes.append(p)
    return(primes)
 
print(Sieb(30))
 
#Eigentlich müsste nur bis Wurzel von n überprüft werden:
def SiebSchneller(n):
    isPrime = [True for i in range(n+1)]
 
    for i in range(2,int(ceil(sqrt(n)))):
        if isPrime[i] == True:
            for j in range(2*i,n+1,i):
                isPrime[j] = False 
    primes = []
    #alle nicht rausgesrichenen zur Liste hinzufügen
    for p in range(2,n + 1): 
            if isPrime[p]: 
                primes.append(p)
    return(primes)
print(SiebSchneller(30))

Bearbeite das Skript |Simulationen. Lade die gelösten Aufgaben in den Sharepoint-Abgabe-Ordner hoch. Benenne dabei die Dateien als simulation_afg_x_name_vorname.py wobei x die Aufgabennummer ist.

Lösungen

zufallszahl.py

from random import randint
zufallszahl = randint(1,100)
print(zufallszahl)

¹⁾ Achtung: An der ersten Stelle isprime[0] steht die 0, an der zweiten isprime[1] die 1, etc. Daher bis $n+1$

²⁾ Inkremente sind Vergrösserungen oder Schrittweite. Normalerweise ist das Inkrement bei range $1$, es kann aber auch manuell spezifiziert werden

Grundlagen und Wiederholung Programmierung

L1-4: Wiederholung Grundkonzepte Python

Ziele

Aufträge

Simulationen

L1-6: Erarbeitung Skript

Big Data: Slicing und Dicing data with Python

Datenanalyse und Datenschutz

Ressourcen

https://fginfo.ksbg.ch Fachgruppe Informatik der KSBG