# `test.py` Pythonzeuch ([edit](?plug=pencil), [live](?plug=livemarkdown), [raw](?plug=none), [meta](?plug=meta)) ### tkinter test ``` import tkinter as tk class App(tk.Frame): def __init__(self, master=None): tk.Frame.__init__(self, master) self.pack() self.createWidgets() def createWidgets(self): self.hi = tk.Button(self, text='Hello\n(click me)', command=self.greet) self.hi.pack(side='top') self.quit = tk.Button(self, text='QUIT', fg='red', command=root.destroy) self.quit.pack(side='bottom') def greet(self): print('Hello, world!') root = tk.Tk() app = App(master=root) app.mainloop() ``` ### Object oriented stuff ``` class Item: def __init__(self, name, cost, dmg, arm): self.name = name self.cost = cost self.dmg = dmg self.arm = arm class Unit: def __init__(self, name, maxHp, baseDmg, baseArm): self.name = name self.maxHp = maxHp self.baseDmg = baseDmg self.baseArm = baseArm self.hp = maxHp self.items = [] def equip(self, item): self.items.append(item) def damage(self, amount): dmg = max(1, amount - self.getArm()) self.hp = max(0, self.hp - dmg) print('{} took {} damage'.format(self.name, dmg) + ('. {}HP left.'.format(self.hp) if self.hp else ' and died.')) def getDmg(self): return self.baseDmg + sum([i.dmg for i in self.items]) def getArm(self): return self.baseArm + sum([i.arm for i in self.items]) def getCost(self): return sum([i.cost for i in self.items]) def fight(self, enemy): print('{}({}HP {}D {}A) fighting against {}({}HP {}D {}A)' .format(self.name, self.hp, self.getDmg(), self.getArm(), enemy.name, enemy.hp, enemy.getDmg(), enemy.getArm())) round = 0 while self.hp > 0 and enemy.hp > 0: round += 1 print('Round {}:'.format(round)) enemy.damage(self.getDmg()) if enemy.hp > 0: self.damage(enemy.getDmg()) player = Unit('Player', 100, 1, 0) boss = Unit('Boss', 100, 10, 5) player.equip(Item('Dagger', 8, 5, 0)) player.fight(boss) def zaehlen(): stand +=1 class Zaehler: def __init__(self, anfangsstand = 0): self.stand = anfangsstand def weiter(self, step = 1): self.stand += step dinge = Zaehler() dinge.weiter() dinge.weiter(2) print(dinge.stand) #3 dinge = {stand: 0} test = {foo: False} def weiter(dictionary, step): dictionary.stand += 1 weiter(dinge, 3) weiter(test) print(dinge.stand) #3 mask = 65535 # ...00 11111111 11111111 n = 65537 # 1 00000000 00000001 n & mask == 1 def mask(n): return n & 65535 mask(ergebnis) ``` ## Exercises ########################################################################### ### Advent of code day 20 ``` def advent20(data): import time start_time = time.time() housenbr = 0 presents = 0 while presents < int(data): presents = 0 housenbr += 1 liste = [] [liste.extend(set((i, housenbr//i))) for i in range(1, int((housenbr**0.5)+1)) if housenbr%i == 0] [liste.remove(f) for f in liste if housenbr > 50*f] presents = sum([i for i in liste]*10) if housenbr%10000 == 0: print(housenbr, presents) print(housenbr) print(time.time() - start_time) advent20("""34000000""") ``` ### Advent of code day 21 ``` def gears(): gearlist = """Weapons: Cost Damage Armor Dagger 8 4 0 Shortsword 10 5 0 Warhammer 25 6 0 Longsword 40 7 0 Greataxe 74 8 0 Armor: Cost Damage Armor Leather 13 0 1 Chainmail 31 0 2 Splintmail 53 0 3 Bandedmail 75 0 4 Platemail 102 0 5 Rings: Cost Damage Armor Damage +1 25 1 0 Damage +2 50 2 0 Damage +3 100 3 0 Defense +1 20 0 1 Defense +2 40 0 2 Defense +3 80 0 3""" dicts = {} gearlist = [i.split() for i in gearlist.splitlines()] kind = "" for i in gearlist: if len(i) > 0: if ":" in i[0]: dicts.update({i[0][:-1]:{}}) kind = i[0][:-1] if not ":" in i[0]: if len(i) == 5: dicts[kind].update({" ".join((i[0],i[1])):[int(s) for s in i[2:]]}) else: dicts[kind].update({i[0]:[int(s) for s in i[1:]]}) return dicts def advent21(data): gear = gears() liste = [] for w in gear["Weapons"]: for a in gear["Armor"]: for r1 in gear["Rings"]: for r2 in gear["Rings"]: if not r1 == r2: liste.append([sum(x) for x in zip(gear["Weapons"][w], gear["Armor"][a], gear["Rings"][r1], gear["Rings"][r2])]) liste.append([sum(x) for x in zip(gear["Weapons"][w], gear["Armor"][a], gear["Rings"][r1])]) liste.append([sum(x) for x in zip(gear["Weapons"][w], gear["Armor"][a])]) for r2 in gear["Rings"]: liste.append([sum(x) for x in zip(gear["Weapons"][w], gear["Armor"][a], gear["Rings"][r2])]) for r1 in gear["Rings"]: liste.append([sum(x) for x in zip(gear["Weapons"][w], gear["Rings"][r1])]) for r2 in gear["Rings"]: liste.append([sum(x) for x in zip(gear["Weapons"][w], gear["Rings"][r1], gear["Rings"][r2])]) liste.append(gear["Weapons"][w]) data = [f.split() for f in data.splitlines()] bhp,bdmg,barm = [int(*g) for g in [[g for g in i if g.isdigit()] for i in data]] kampf = [] for stats in liste: bosshp = bhp bossdmg = bdmg bossArmor = barm mehp = 100 cost,medmg,meArmor = stats ## pt 2 ##while mehp > 0: while bosshp > 0: bosshp -= medmg-bossArmor if bosshp <= 0: break mehp -= bossdmg-meArmor ## pt 2 ##if mehp <= 0 and bosshp > 0: if bosshp <= 0 and mehp > 0: kampf.append((cost,mehp,bosshp)) minimum = min([i[0] for i in kampf]) maximum = max([i[0] for i in kampf]) print(minimum) print(maximum) advent21("""Hit Points: 100 Damage: 8 Armor: 2""") ``` ### Advent of code day 11 ``` def advent11(data): alphabet = "abcdefghijklmnopqrstuvwxyz" password = [int(alphabet.index(char)) for char in data] '''indexcount = 0 for i in data: password[indexcount] = int(alphabet.index(password[indexcount])) indexcount += 1''' for i in range(250): # increment pos = -1 while pos: # wrap around if password[pos] < 25: password[pos] += 1 pos = 0 else: password[pos] = 0 pos -= 1 pos = -1 if password[pos] < 25: password[pos] += 1 else: if password[pos - 1] < 25: password[pos -1] += 1 password[pos] = 0 print(password) return password def advent11b(data): alphabet = 'abcdefghijklmnopqrstuvwxyz' length = len(data) num = 0 for char in data: num *= 26 num += alphabet.index(char) def convert(num): chars = [] for n in range(length): chars.append(alphabet[num % 26]) num //= 26 return ''.join(chars) def check(str): #TODO return true num += 1 while not check(convert(num)): num += 1 return convert(num) advent11("aup") ``` ### Advent of code day 9 ``` def advent9(data): list = [] step = 0 solutions = [] integers = [] for line in data.splitlines(): parts = line.split() split2 = [parts[2], parts[1], parts[0], parts[3], parts[4]] list.append(parts) list.append(split2) #print(list) for i in range(len(list)): x = 0 #solutions.append(list[i][0]) while x < len(list): if list[i][2] == list[x][0] and list[i][0] != list[x][2]: solutions.append([list[i][0],list[i][2],list[x][2],list[i][4],list[x][4]]) integers.append(int(list[i][4])+int(list[x][4])) x+=1 else: x+=1 #print(solutions) #print(min(integers)) advent9("""London to Dublin = 464 London to Belfast = 518 Dublin to Belfast = 141""") def advent9(data): connections = [[f[0], f[2], int(f[4])] for f in [l.split() for l in data.splitlines()]] locations = [] for [start, end, dist] in connections: for loc in [start, end]: if not loc in locations: locations.append(loc) dist = {} for loc in locations: dist[loc] = {} # dist == {'London': {}, 'Dublin': {}, 'Belfast': {}} connection[0] == ['London', 'Dublin', 464] for con in connections: dist[con[0]][con[1]] = con[2] dist[con[1]][con[0]] = con[2] ``` ### Human readable duration format ``` def format_duration(seconds): if seconds == 0: return "now" years, seconds = seconds // 31536000, seconds % 31536000 days, seconds = seconds // 86400, seconds % 86400 hours, seconds = seconds // 3600, seconds % 3600 minutes, seconds = seconds // 60, seconds % 60 x = (years, days, hours, minutes, seconds) units = [" years", " days", " hours", " minutes", " seconds"] solution = [] count = len([f for f in x if f]) for i in range(len(x)): if x[i]: if x[i]>1: solution.append(str(x[i]) + units[i]) else: solution.append((str(x[i]) + units[i])[:-1]) if len(solution) == 1: result = solution[0] else: result = ', '.join(solution[0:-1]) + ' and ' + solution[-1] return result print(format_duration(3662)) print(format_duration(8645200)) print(format_duration(2456)) print(format_duration(315360000)) print(format_duration(564516488)) print(format_duration(0)) ``` ### Palindrome checker ``` def paliondrome(s): sentence = "" count = 0 for letter in s.lower(): if letter.isalpha(): sentence += letter if sentence == sentence[::-1]: return s + "\npaliondrome gefunden\n" else: return s + "\nkein paliondrome\n" words = ["eis","uhu","ein Eis esse., sie nie","nein, kann anna knien?"] for word in words: break### print(paliondrome(word)) ``` ### Min of two ``` def min1(input): for g in input.splitlines()[1:]: print((min([int(x) for x in g.split()]))) def min3(input): #print(min([int(x) for x in g.split() for g in input.splitlines()[1:]])) #print([map(int, g.split())for g in input.splitlines()[1:]]) nums = [map(int, g.split()) for g in input.splitlines()[1:]] mins = map(min, nums) print(" ".join(str(x) for x in map(min, [map(int, l.split())for l in input.splitlines()[1:]]))) print(" ".join(map(str, map(min, [map(int, g.split())for g in input.splitlines()[1:]])))) #nums = [[-6963985, -6891438], [..., ...], ...] print('\n'.join(*[map(str, g) for g in mins])) #print(min(... for ... in ...)) #falsch #result = [min(...) for ... in ...] def min1(input): h = [] for g in input.splitlines()[1:]: h.append((min([int(x) for x in g.split()]))) print(" ".join(map(str, h)) print(" ".join(str(x) for x in h))) min1("""27 -6963985 -6891438 5552468 -1599995 2024852 -5075822 4275138 9362176 1190005 2884316 9049580 -2924364 -5854669 9214873 -8547150 429828 -2462475 -4311828 -2385847 73114 -1535172 3757925 1623058 8141740 8769258 -4104422 -1609381 3520530 -5698855 3769354 -2401427 -2662840 6877915 -6848958 5737165 -1097233 -1924780 12304 -1735056 9265224 -7103380 -2685475 -3659140 -2958049 -3470601 -2206291 7471779 4066923 3481881 -4914067 -5859962 -8053290 8843857 5763096""") lines = [map(int, input().split()) for _ in range(int(input()))] mins = map(min, lines) print(' '.join(map(str, mins))) ints = [[int(x) for x in line.split()] for line in data] int = [map(int, line.split()) for line in data] ``` ### ``` lines = [map(int, input().split()) for _ in range(int(input()))] mins = map(min, lines) print(' '.join(map(str, mins))) ### Sums num = int(input()) inputs = [map(int, input().split()) for _ in range(num)] sums = map(sum, inputs) print(' '.join(map(str, sums))) ``` ### Bmi ``` def bmi(input): print(' '.join([ 'under' if bmi < 18.5 else 'normal' if bmi < 25 else 'over' if bmi < 30 else 'obese' for bmi in [float(weight)/(float(height)**2) for weight, height in [line.split() for line in input.splitlines()[1:]]]])) bmi("""28 112 2.94 44 1.33 59 1.28 40 1.12 81 1.92 72 2.19 68 1.94 60 1.33 54 1.50 74 2.22 61 1.53 64 1.51 105 2.35 95 2.44 116 2.99 85 1.60 53 1.40 70 1.78 84 2.00 58 2.20 106 1.98 59 1.98 112 2.16 44 1.91 119 2.27 58 1.85 43 1.31 111 1.81""") ``` ### Password cracking list generation stuff ``` from string import ascii_lowercase, ascii_uppercase from random import randint def randomChar(alphabet): return alphabet[randint(0,len(alphabet))] def randomString(alphabet, length): return ''.join([randomChar(alphabet) for _ in range(length)]) def generateList(alphabet, maxLength): result = [] if maxLength == 1: return [alphabet[pos] for pos in range(len(alphabet))] else: return [oneShorter + alphabet[pos] for oneShorter in generateList(alphabet, maxLength - 1) for pos in range(len(alphabet))] digits =''.join(map(str, range(10))) digitsAndLetters = digits + ascii_uppercase + ascii_lowercase passwordLength = 7 passwordAlphabet = digits secretPassword = randomString(passwordAlphabet, passwordLength) print('Password: ' + secretPassword) list = generateList(passwordAlphabet, passwordLength) for word in list: if word == secretPassword: print('Found password: {}'.format(word)) ``` ## Internals ########################################################################### ### Iterable unpacking ``` list = ['a', 'b'] [1, 2, list] == [1, 2, ['a', 'b']] [1, 2, *list] == [1, 2, 'a', 'b'] ``` ### Lambda and list comprehension equivalence ### List comprehension With multiple `for VARS in`. The right-most `VARS` change fastest: ``` >>> [a+b for a in [1,2,3] for b in [100,200,300]] [101, 201, 301, 102, 202, 302, 103, 203, 303] ``` `map` with list comprehension: ``` list(map(f, [1, 2, 3])) [f(1), f(2), f(3)] ``` List comprehension with a loop: ``` list = [] for VAR in Iterable: list.append(EXPR) ``` List comprehension using lambda: ``` # in a generalized form, this: map(lambda ARGS: EXPR, Iterable) # is equal to: [EXPR for ARGS in Iterable] # for example, this: map(lambda line: line.split(), s.splitlines()[1:]) # is equal to: [line.split() for line in s.splitlines()[1:]] ``` Filtered and/or nested list comprehension: ``` list = [EXPR for VAR in Iterable] list = [[EXPR for VAR in Iterable] for VAR in Iterable] list = [EXPR for VAR in [EXPR for VAR in Iterable]] list = [EXPR for VAR1 in Iterable1 for VAR2 in Iterable2] list = [] for VAR1 in Iterable1: for VAR2 in Iterable2: list.append(EXPR) ''' 1 2 3 10 20 30 ''' list = [[int(x)**2 for x in line.split()] for line in data] ''' [[1, 4, 9],[100, 400, 900]] ''' list = [x[0]**2 for x in [int(line) for line in data]] ''' -> [1,100] x = [[1,2,3],[10,20,30]] ''' ``` ### Disassembling python code ``` from dis import dis # define a simple example function def test(a, b): return [a + x for x in b] # show the code it gets assembled into dis(test) ``` ## Misc ################################################################################ ### Rosalind loader [`rosalind.py`](https://thefiletree.com/g/rosalind.py?plug=none) ``` def run(problemName, solve, show = True): """Run `solve` with input data from `rosalind_{problemName}.txt` and return results Data is passed to `solve` a `list` of `str`, one for each line in the input file. The result of `solve` is converted to `str` if necessary, by mapping with `str` and `join`ing with '\n'. """ # read input file as array of lines with open('rosalind_'+ problemName +'.txt', 'r') as file: data = [line.rstrip('\n') for line in file.readlines()] # calculate the solution and format it as output string solution = solve(data) if type(solution) == list: solution = '\n'.join([line if type(line) == str else str(line) for line in solution]) else if type(solution) != str: solution = str(solution) if show: print(solution) return solution def save(problemName, solve, overwrite = False): """Run `solve` with input data from `rosalind_{problemName}.txt` and save output to a file. The output file will be called `rosalind_{problemName}_output.txt`. """ solution = run(problemName, solve) def save(mode): with open('rosalind_'+ problemName +'_output.txt', mode) as file: file.write(solution) try: save('x') except FileExistsError: print('File exists.') if overwrite: print('Overwriting...') save('w') ``` It can be used like this: ``` import rosalind # Solver function taking a list of lines and returning the answer def test(data): return [''.join(reversed(line)) for line in data] # run `test` with data from `rosalind_test.txt` and prints output rosalind.run('test', test) # same as above, but also saves output to `rosalind_test_output.txt` if it doesn't exist yet rosalind.save('test', test) # same as above, but overwrites the file if it exists rosalind.save('test', test, True) ```