6 Commits

Author SHA1 Message Date
Olli Graf
0982608da1 finale Version. 2023-04-01 12:56:28 +02:00
Olli Graf
b580f7fd5b Verbesserung der Parameterübergabe und Berechnung aus Zahlenliste. 2023-03-29 16:23:52 +02:00
f7a5db9f39 Teile 10 bis 12. 2023-03-28 12:26:50 +02:00
298151634d Dateien hochladen nach „“
Pools
2023-03-24 05:23:40 +00:00
fc8b033215 „Readme.md“ ändern 2023-03-14 13:24:15 +00:00
535087c248 teil11
teil11 Upload
2023-03-14 13:22:29 +00:00
27 changed files with 4659 additions and 0 deletions

View File

@@ -14,4 +14,6 @@ CC-BY-SA Olli Graf
| 7 | Module| | 7 | Module|
| 8 | Exceptions| | 8 | Exceptions|
| 9 | Typkonvertierung| | 9 | Typkonvertierung|
|10 | Dateien|
|11 | Datum und Zeit|

46
multithread.py Normal file
View File

@@ -0,0 +1,46 @@
from timeit import default_timer as timer
import time
import threading
def calc_square(numbers, verbose=False):
for n in range(1,numbers):
q= n*n
if verbose:
print(f'\n{n} ^ 2 = {q}')
time.sleep(0.1)
def calc_cube(numbers,verbose=False):
for n in range(1,numbers):
k = n*n*n
if verbose:
print(f'\n{n} ^ 3 = {k}')
time.sleep(0.1)
start = timer()
thread_square = threading.Thread(target=calc_square, args=(100,True))
thread_cube = threading.Thread(target=calc_cube, args=(100,True))
thread_cube.start()
thread_square.start()
thread_cube.join()
thread_square.join()
ende = timer()
differenz_mit_print = ende - start
print(f'Zeit mit print():{differenz_mit_print}s')
start = timer()
thread_square = threading.Thread(target=calc_square, args=(100,False))
thread_cube = threading.Thread(target=calc_cube, args=(100,False))
thread_cube.start()
thread_square.start()
thread_cube.join()
thread_square.join()
ende = timer()
differenz_ohne_print = ende - start
print(f'Zeit ohne print():{differenz_ohne_print}s')

45
race_condition_async.py Normal file
View File

@@ -0,0 +1,45 @@
import asyncio
import random
import time
gesamtwert = 0
message = ''
async def calculate_sum(lock, thread_nummer):
global gesamtwert
global message
for i in range(100 + thread_nummer):
async with lock:
zwischen = gesamtwert
#Zufällige Wartezeit zwischen 0,1s und 0,5s
wartezeit = random.randint(1,5+thread_nummer)
time.sleep(0.1 * wartezeit)
zwischen += 1
async with lock:
gesamtwert = zwischen
message = f'Thread {thread_nummer} fertig'
print(f'Thread + {thread_nummer} abgearbeitet.')
async def main():
#async Lock erzeugen
lock = asyncio.Lock()
# drei Threads starten, um die Summe der Zahlen zu berechnen
threads = [asyncio.create_task(calculate_sum(lock, _+1)) for _ in range(3)]
#Warten auf alle Threads
await asyncio.gather(*threads)
print(f'gesamtwert={gesamtwert}')
print(f'message={message}')
if __name__ == '__main__':
asyncio.run(main())

Binary file not shown.

5
teil10/namen.csv Normal file
View File

@@ -0,0 +1,5 @@
Skinner,Seymour
Largo,Dewey
Krabappel,Edna
Hoover,Elisabeth
Chalmers,Gary
1 Skinner Seymour
2 Largo Dewey
3 Krabappel Edna
4 Hoover Elisabeth
5 Chalmers Gary

1
teil10/namen.py Normal file
View File

@@ -0,0 +1 @@
namen = ["Homer", "Marge", "Bart"]

3
teil10/namen.txt Normal file
View File

@@ -0,0 +1,3 @@
Homer
Marge
Bart

29
teil10/read_csv.py Normal file
View File

@@ -0,0 +1,29 @@
school = []
class Lehrer():
def __init__(self, vorname, name):
self.vorname = vorname
self.name = name
def __str__(self):
return f'{self.vorname} {self.name}'
try:
with open('namen.csv','r') as f:
for line in f:
splitted = line.strip().split(',')
name = splitted[0]
vorname = splitted[1]
lehrer = Lehrer(vorname,name)
school.append(lehrer)
except IOError as x:
print(f'I/O-Fehler: {x}')
print(school)
print(school[0])
print(school[3])

17
teil10/read_file.py Normal file
View File

@@ -0,0 +1,17 @@
namen = []
try:
f = open('namen.txt','r')
#f = open('namen.txt','r',encoding='utf-8')
for line in f:
namen.append(line)
# namen.append(line.strip())
except IOError as x:
print(f'I/O-Fehler: {x}')
finally:
if f != None:
f.close()
print(namen)

15
teil10/write_file.py Normal file
View File

@@ -0,0 +1,15 @@
from namen import namen
f = open('namen.txt','w')
try:
for name in namen:
f.write(f'{name}\n')
except IOError as err:
print(f'I/O-Fehler {err}')
finally:
if f != None:
f.close()

12
teil10/write_file_with.py Normal file
View File

@@ -0,0 +1,12 @@
from namen import namen
try:
with open('namen.txt','w') as f:
for name in namen:
f.write(f'{name}\n')
except IOError as err:
print(f'I/O-Fehler {err}')

10
teil11/create_datetime.py Normal file
View File

@@ -0,0 +1,10 @@
from datetime import datetime
datum = datetime.strptime('12.12.2002', '%d.%m.%Y')
print(f'Jahr: {datum.year}')
print(f'Monat: {datum.month}')
print(f'Tag: {datum.day}')
print(datum)

9
teil11/currentdate.py Normal file
View File

@@ -0,0 +1,9 @@
from datetime import datetime
heute = datetime.now()
print(type(heute))
print(heute)
print(heute.time())
print(heute.date())

10
teil11/formatted_date.py Normal file
View File

@@ -0,0 +1,10 @@
from datetime import datetime
heute = datetime.now()
print(type(heute))
print(heute.strftime('%c %X'))
print(heute.time().strftime('%X'))
print(heute.date().strftime('%x'))
print(heute.strftime('%d.%m.%y %H:%M'))

34
teil11/zeitmessung.py Normal file
View File

@@ -0,0 +1,34 @@
from timeit import default_timer as timer
import time
def calc_square(numbers, verbose=False):
for n in range(1,numbers):
q= n*n
if verbose:
print(f'\n{n} ^ 2 = {q}')
time.sleep(0.1)
def calc_cube(numbers,verbose=False):
for n in range(1,numbers):
k = n*n*n
if verbose:
print(f'\n{n} ^ 3 = {k}')
time.sleep(0.1)
start = timer()
calc_square(100,True)
calc_cube(100,True)
ende = timer()
differenz = ende - start
print(f'Zeit mit print():{differenz}s')
start = timer()
calc_square(100)
calc_cube(100)
ende = timer()
differenz = ende - start
print(f'Zeit ohne print():{differenz}s')

4004
teil12/multi_write.log Normal file

File diff suppressed because it is too large Load Diff

32
teil12/multi_write.py Normal file
View File

@@ -0,0 +1,32 @@
import threading
import logging
logging.basicConfig(
format='%(asctime)-15s [%(levelname)s] %(funcName)s: %(message)s',
filename='multi_write.log',
level=logging.DEBUG)
datei = open('zahlen.txt','w')
def write_number(zahl):
for i in range(0,1000):
logging.debug(f'Thread {zahl}/schreibe {i}')
datei.write(f'{i}:{zahl}\n')
datei.flush()
thread_1 = threading.Thread(target=write_number,args=(1,))
thread_2 = threading.Thread(target=write_number,args=(2,))
logging.debug('starte Thread 1')
thread_1.start()
logging.debug('starte Thread 2')
thread_2.start()
thread_1.join()
thread_2.join()

46
teil12/multithreading.py Normal file
View File

@@ -0,0 +1,46 @@
from timeit import default_timer as timer
import time
import threading
def calc_square(numbers, verbose=False):
for n in range(1,numbers):
q= n*n
if verbose:
print(f'\n{n} ^ 2 = {q}')
time.sleep(0.1)
def calc_cube(numbers,verbose=False):
for n in range(1,numbers):
k = n*n*n
if verbose:
print(f'\n{n} ^ 3 = {k}')
time.sleep(0.1)
start = timer()
thread_square = threading.Thread(target=calc_square, args=(100,True))
thread_cube = threading.Thread(target=calc_cube, args=(100,True))
thread_cube.start()
thread_square.start()
thread_cube.join()
thread_square.join()
ende = timer()
differenz_mit_print = ende - start
print(f'Zeit mit print():{differenz_mit_print}s')
start = timer()
thread_square = threading.Thread(target=calc_square, args=(100,False))
thread_cube = threading.Thread(target=calc_cube, args=(100,False))
thread_cube.start()
thread_square.start()
thread_cube.join()
thread_square.join()
ende = timer()
differenz_ohne_print = ende - start
print(f'Zeit ohne print():{differenz_ohne_print}s')

52
teil12/pool.py Normal file
View File

@@ -0,0 +1,52 @@
# encoding: UTF-8
from timeit import default_timer as timer
import datetime
import multiprocessing
import time
import random
from multiprocessing import Pool
def func1(*args, **kwargs):
sleep_time = random.randint(3, 6)
print(f'Prozess : {multiprocessing.current_process().name}\tFunktion : func1\tArgs:{args}\tgeschlafen {sleep_time} \tZeit : {datetime.datetime.now()}\n')
print("Keyword Args from func1: %s" % kwargs)
time.sleep(sleep_time)
print(f'{multiprocessing.current_process().name}\t func1 fertig: {datetime.datetime.now()}\n')
return sum(*args)
def func2(*args):
sleep_time = random.randint(7, 10)
print(f'Prozess : {multiprocessing.current_process().name}\tFunktion : func2\tArgs:{args}\tgeschlafen {sleep_time} \tZeit : {datetime.datetime.now()}\n')
time.sleep(sleep_time)
print(f'{multiprocessing.current_process().name}\t func2 fertig: {datetime.datetime.now()}\n')
return sum(*args)
def func3(*args):
sleep_time = random.randint(0, 3)
print(f'Prozess : {multiprocessing.current_process().name}\tFunktion : func3\ttArgs:{args}\tgeschlafen {sleep_time} \tZeit : {datetime.datetime.now()}\n')
time.sleep(sleep_time)
print(f'{multiprocessing.current_process().name}\t func3 fertig: {datetime.datetime.now()}\n')
return sum(*args)
def smap(f, *arg):
if len(arg) == 2:
args, kwargs = arg
return f(list(args), **kwargs)
elif len(arg) == 1:
args = arg
return f(*args)
if __name__ == '__main__':
start = timer()
with Pool(processes=3) as pool:
result = pool.starmap(smap, [(func1, [1,2,3],{'a':123, 'b':456}), (func2, [11,22,33]), (func3, [111,222,333])])
print(f'Ergebnis: {result}')
ende = timer()
diff = ende - start
print(f'Ausführzeit: {diff}s')

12
teil12/pool2.py Normal file
View File

@@ -0,0 +1,12 @@
# Quelle: https://stackoverflow.com/questions/35528093/multithreading-in-python-with-a-threadpool
from multiprocessing import Pool
import sys
if __name__ == '__main__':
job_list = [range(10000000)]*6
print(f'{job_list}')
p = Pool(2)
print("Parallel map")
print(p.map(sum, job_list))

20
teil12/pool3.py Normal file
View File

@@ -0,0 +1,20 @@
# Quelle: https://www.codesdope.com/blog/article/multiprocessing-using-pool-in-python/
import time
from multiprocessing import Pool
def square(x):
print(f"start process:{x}")
square = x * x
print(f"square {x}:{square}")
time.sleep(1)
print(f"end process:{x}")
if __name__ == "__main__":
starttime = time.time()
pool = Pool()
pool.map(square, range(0, 5))
pool.close()
endtime = time.time()
print(f"Time taken {endtime-starttime} seconds")

80
teil12/pool_squares.py Normal file
View File

@@ -0,0 +1,80 @@
#encoding: UTF-8
import datetime
from timeit import default_timer as timer
import multiprocessing
import time
import random
from multiprocessing import Pool
__verbose__ = False
# gibt den String s nur aus, wenn __verbose__ True ist.
def print_verbose(s):
if __verbose__:
print(s)
# Arbeitsfunktion läuft in der Zahlenliste von start bis ende
# und summiert die Quadratzahlen in dem Bereich auf.
# Die Methode wird in jedem Prozess mit unterschiedlichen Werten
# für start und ende abgearbeitet.
def calc_sum_square(zahlen, *args,**kwargs):
print(f'calc_sum_square() {args}')
time.sleep(1.0)
start = kwargs['start']
ende = kwargs['end']
threadnr = kwargs['threadnr']
summe = 0
print_verbose(f'von {start} bis {ende}')
for n in range(start,ende):
i = zahlen[n]
print_verbose(f'Berechnung:{threadnr}: {i}, {i*i}')
summe = summe + i*i
return summe
# Diese Methode wird initial pro Prozess von der Poolsteuerung aufgerufen und
# steuert die Verteilung der Parameter.
# f ist der Zeiger auf die aufzurufende Methode
# *arg wnthält das Tupel mit den Argumenten
#
def smap(f, *arg):
# Auflösen des Tupels: args enthält die Liste mit den Zahlen,
# kwarg das Dictionary mit den Parametern für jeden Prozess
args, kwargs = arg
# Aufruf der übergebenen Funktion mit den Parametern
return f(args, **kwargs)
if __name__ == '__main__':
start = timer()
# Liste mit 10 Mio Integerzahlen anlegen.
zahlen = [i for i in range(10000000)]
ende = timer()
print(f'Zahlenliste erzeugt in {ende-start}s')
split = int(len(zahlen) / 3)
print_verbose(f'split={split}')
time.sleep(1.0)
start = timer()
# Pool mit drei Prozesssen
with Pool(processes=3) as pool:
# Die Methode pool.starmap() bekommt neben der aufzurufenden Methode smap() eine Liste von Tupeln.
# Jedes Tupel enthält pro Prozess die auszuführende Methode, die Liste mit den Zahlen und ein Dictionary mit
# den Parametern 'threadnr', 'start' und 'end'
# starmap() wartet solange, bis alle drei Teilprozesse beendet sind und gibt dann eine Liste mit den return Werten
# zurück.
result = pool.starmap(smap, [(calc_sum_square, zahlen, {'threadnr':1,'start':0, 'end':split}), (calc_sum_square, zahlen, {'threadnr':2,'start':split+1,'end':split*2}), (calc_sum_square, zahlen,{'threadnr':3,'start':(split*2)+1,'end':split*3})])
print(f'Ergebnis: {result}')
ende = timer()
print(f'Ausführzeit: {ende-start}s')

14
teil12/pools.py Normal file
View File

@@ -0,0 +1,14 @@
from multiprocessing import Pool
import time
def calculate_square(n):
return n*n
if __name__ == "__main__":
starttime = time.time()
pool = Pool()
pool.map(calculate_square, range(0, 5))
pool.close()
endtime = time.time()
print(f"Time taken {endtime-starttime} seconds")

37
teil12/race_condition.py Normal file
View File

@@ -0,0 +1,37 @@
import threading
import time
import random
gesamtwert = 0
message = ''
def calculate_sum(thread_nummer):
global gesamtwert
global message
for i in range(100 + thread_nummer):
zwischen = gesamtwert
#Zufällige Wartezeit zwischen 0,1s und 0,5s
wartezeit = random.randint(1,5+thread_nummer)
time.sleep(0.1 * wartezeit)
zwischen += 1
gesamtwert = zwischen
message = f'Thread {thread_nummer} fertig'
print(f'Thread + {thread_nummer} abgearbeitet.')
# zwei Threads starten, um die Summe der Zahlen zu berechnen
gesamtwert = 0
t1 = threading.Thread(target=calculate_sum, args=(1,))
t2 = threading.Thread(target=calculate_sum, args=(2,))
t3 = threading.Thread(target=calculate_sum, args=(3,))
t1.start()
t2.start()
t3.start()
t1.join()
t3.join()
t2.join()
print(f'gesamtwert={gesamtwert}')
print(f'message={message}')

View File

@@ -0,0 +1,44 @@
import asyncio
import random
import time
gesamtwert = 0
message = ''
async def calculate_sum(lock, thread_nummer):
global gesamtwert
global message
for i in range(100 + thread_nummer):
async with lock:
zwischen = gesamtwert
#Zufällige Wartezeit zwischen 0,1s und 0,5s
wartezeit = random.randint(1,5+thread_nummer)
time.sleep(0.1 * wartezeit)
zwischen += 1
async with lock:
gesamtwert = zwischen
message = f'Thread {thread_nummer} fertig'
print(f'Thread + {thread_nummer} abgearbeitet.')
async def main():
#async Lock erzeugen
lock = asyncio.Lock()
# drei Threads starten, um die Summe der Zahlen zu berechnen
threads = [asyncio.create_task(calculate_sum(lock, _+1)) for _ in range(3)]
#Warten auf alle Threads
await asyncio.gather(*threads)
print(f'gesamtwert={gesamtwert}')
print(f'message={message}')
if __name__ == '__main__':
asyncio.run(main())

View File

@@ -0,0 +1,43 @@
import threading
import time
import random
gesamtwert = 0
message = ''
lock = threading.Lock()
def calculate_sum(thread_nummer,lock):
global gesamtwert
global message
for i in range(100 + thread_nummer):
with lock:
zwischen = gesamtwert
#Zufällige Wartezeit zwischen 0,1s und 0,5s
wartezeit = random.randint(1,5+thread_nummer)
time.sleep(0.1 * wartezeit)
zwischen += 1
with lock:
gesamtwert = zwischen
message = f'Thread {thread_nummer} fertig'
print(f'Thread + {thread_nummer} abgearbeitet.')
# zwei Threads starten, um die Summe der Zahlen zu berechnen
gesamtwert = 0
t1 = threading.Thread(target=calculate_sum, args=(1,lock,))
t2 = threading.Thread(target=calculate_sum, args=(2,lock,))
t3 = threading.Thread(target=calculate_sum, args=(3,lock,))
t1.start()
t2.start()
t3.start()
t1.join()
t3.join()
t2.join()
print(f'gesamtwert={gesamtwert}')
print(f'message={message}')

37
teil12/threadpools.py Normal file
View File

@@ -0,0 +1,37 @@
import concurrent.futures
import random
import time
gesamtwert = 0
message = ''
def calculate_sum(thread_nummer):
global gesamtwert
global message
for i in range(100 + thread_nummer):
zwischen = gesamtwert
#Zufällige Wartezeit zwischen 0,1s und 0,5s
wartezeit = random.randint(1,5+thread_nummer)
time.sleep(0.1 * wartezeit)
zwischen += 1
gesamtwert = zwischen
message = f'Thread {thread_nummer} fertig'
print(f'Thread + {thread_nummer} abgearbeitet.')
def main():
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
threads = [executor.submit(calculate_sum, i+1) for i in range(3)]
results = [t.result() for t in threads]
print(f'gesamtwert={gesamtwert}')
print(f'message={message}')
if __name__ == '__main__':
main()