FizzBuzz Katas

 1: def fizzbuzz_method(n):
 2:     for i in range(n):
 3:         if i % 3 == 0 and i % 5 == 0:
 4:             print("fizzbuzz")
 5:         elif i % 3 == 0:
 6:             print("fizz")
 7:         elif i % 5 == 0:
 8:             print("buzz")
 9:         else:
10:             print(i)
11: 
12: fizzbuzz_method(20)

 1: def fizzbuzz_method(n):
 2:     for i in range(n):
 3:         s = ""
 4: 
 5:         if i % 3 == 0:
 6:             s = "fizz"
 7:         if i % 5 == 0:
 8:             s += "buzz"
 9:         if len(s) == 0:
10:             s = i
11: 
12:         print(s)
13: 
14: fizzbuzz_method(20)

 1: def fizzbuzz_recursive(i):
 2:     if i == 0:
 3:         return
 4:     else:
 5:         fizzbuzz_recursive(i-1)
 6: 
 7:         if i % 3 == 0 and i % 5 == 0:
 8:             print("fizzbuzz")
 9:         elif i % 3 == 0:
10:             print("fizz")
11:         elif i % 5 == 0:
12:             print("buzz")
13:         else:
14:             print(i)
15: 
16: 
17: fizzbuzz_recursive(20)

 1: import threading
 2: import time
 3: 
 4: def fizzbuzz_thread(i):    
 5:     time.sleep(1)
 6:     if i % 3 == 0 and i % 5 == 0:
 7:         print(i, "fizzbuzz")
 8:     elif i % 3 == 0:
 9:         print(i, "fizz")
10:     elif i % 5 == 0:
11:         print(i, "buzz")
12:     else:
13:         print(i)
14: 
15: def fizzbuzz_start_threads():
16:     for i in range(20):
17:         # Creating a thread object that will execute the method above
18:         # with the given argument i.
19:         th = threading.Thread(target=fizzbuzz_thread, args=(i,))
20:         th.start()
21: 
22: fizzbuzz_start_threads()

 1: import time
 2: import multiprocessing
 3: 
 4: def fizzbuzz_process(i):
 5:     time.sleep(1)
 6:     if i % 3 == 0 and i % 5 == 0:
 7:         print(i, "fizzbuzz")
 8:     elif i % 3 == 0:
 9:         print(i, "fizz")
10:     elif i % 5 == 0:
11:         print(i, "buzz")
12:     else:
13:         print(i)
14: 
15: def fizzbuzz_start_processes():
16:     for i in range(20):
17:         # Creating a process that will execute the method above
18:         # with the given argument i.
19:         pr = multiprocessing.Process(target=fizzbuzz_process, args=(i,))
20:         pr.start()
21: 
22: fizzbuzz_start_processes()

 1: import socketserver
 2: import socket
 3: import threading
 4: 
 5: class FizzBuzzHandler(socketserver.BaseRequestHandler):
 6:     def handle(self):
 7:         # received bytes from request and take the first one
 8:         i = self.request.recv(1)[0]        
 9:         if i % 3 == 0 and i % 5 == 0:
10:             answer = "fizzbuzz"
11:         elif i % 3 == 0:
12:             answer = "fizz"
13:         elif i % 5 == 0:
14:             answer = "buzz"
15:         else:
16:             answer = i
17: 
18:         print("[server] received:", i, "answer:", answer)
19: 
20: class FizzBuzzClient:
21:     def __init__(self, ip, port):
22:         self.socket = (ip, port)
23: 
24:     def send(self, i):
25:         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
26:             sock.connect(self.socket)
27:             print("[client] sending", i)
28:             sock.sendall(bytes([i]))
29: 
30: def fizzbuzz_client_server():
31:     # Starting the server in a separate thread
32:     server_socket = ("127.0.0.1", 8081)
33:     server = socketserver.TCPServer(server_socket, FizzBuzzHandler)
34:     th = threading.Thread(target=server.serve_forever, daemon=True)
35:     th.start()
36: 
37:     # starting the client
38:     cl = FizzBuzzClient(*server_socket)
39:     for i in range(20):
40:         cl.send(i)
41: 
42: fizzbuzz_client_server()

 1: import tkinter
 2: 
 3: class GUI:
 4:     def __init__(self):
 5:         self.i = 0
 6: 
 7:         root = tkinter.Tk()
 8:         root.title("FizzBuzz")
 9: 
10:         # add menu
11:         menubar = tkinter.Menu(root)
12:         root.config(menu=menubar)
13:         # adding Tools-menu to menubar
14:         tools_menu = tkinter.Menu(menubar)
15:         menubar.add_cascade(label="Tools", menu=tools_menu)
16:         tools_menu.add_command(label="Next", command=self.click)
17: 
18:         # add button
19:         btn = tkinter.Button(root, text="next", command=self.click)
20:         btn.pack()
21: 
22:         self.lbl = tkinter.Label(root, text="fizzbuzz GUI")
23:         self.lbl.pack()
24:         self.ent = tkinter.Entry(root)
25:         self.ent.pack()
26:         # entering main event loop
27:         root.mainloop()
28: 
29:     def click(self):
30:         i = self.i
31: 
32:         # update label
33:         self.lbl.configure(text="fizzbuzz von " + str(i))
34: 
35:         # clear the entry field
36:         self.ent.delete(0, tkinter.END)
37: 
38:         if i % 3 == 0 and i % 5 == 0:
39:             self.ent.insert(0, "fizzbuzz")
40:         elif i % 3 == 0:
41:             self.ent.insert(0, "fizz")
42:         elif i % 5 == 0:
43:             self.ent.insert(0, "buzz")
44:         else:
45:             self.ent.insert(0, i)
46: 
47:         self.i += 1
48: 
49: GUI()

 1: class FizzBuzzerOutput:
 2:     def __init__(self, n):
 3:         self.n = n
 4: 
 5:     def print(self):
 6:         i = self.n
 7: 
 8:         if i % 3 == 0 and i % 5 == 0:
 9:             print("fizzbuzz")
10:         elif i % 3 == 0:
11:             print("fizz")
12:         elif i % 5 == 0:
13:             print("buzz")
14: 
15: 
16: class NumberOutput:
17:     def __init__(self, n):
18:         self.n = n
19: 
20:     def print(self):
21:         print(self.n)
22: 
23: 
24: class FizzBuzzGame:
25:     def __init__(self, i):
26:         if i % 3 == 0 or i % 5 == 0:
27:             self.printer = FizzBuzzerOutput(i)
28:         else:
29:             self.printer = NumberOutput(i)
30: 
31:     def print(self):
32:         self.printer.print()
33: 
34: 
35: for i in range(20):
36:     f = FizzBuzzGame(i)
37:     f.print()

 1: class Game:
 2:     def start_game_loop(self):
 3:         """Starting the gameloop of the game."""
 4:         self.setup()
 5:         while True:
 6:             self.handle_input()
 7:             self.update()
 8:             self.draw()
 9: 
10:     def setup():
11:         """Will be invoked once at the beginning of a game."""
12:         pass
13: 
14:     def handle_input():
15:         """Evaluate inputs of the player."""
16:         pass
17: 
18:     def update():
19:         """Updating all game objects and game values."""
20:         pass
21: 
22:     def draw():
23:         """Draw the game world."""
24:         pass
25: 
26: class FizzBuzzGame(Game): # Subclass(Superclass)
27:     def __init__(self):
28:         self.n = 1
29:         self.answer_correct = False
30:         self.playerinput = ""
31: 
32:     def setup(self):
33:         print("Spiel gestartet")
34: 
35:     def handle_input(self):
36:         self.playerinput = input(str(self.n) + " ? ")
37: 
38:     def update(self):
39:         # Evaluating player input
40:         soll = self._fizzbuzz(self.n)
41:         self.answer_correct = self.playerinput == str(soll)        
42:         if self.answer_correct:
43:             self.n += 1
44: 
45:         # Checking winning condition
46:         if self.n == 6:
47:             print("Gewonnen!")
48:             exit()
49: 
50:     def draw(self):
51:         if self.answer_correct:
52:             print("Richtig :)")
53:         else:
54:             print("Leider Falsch. Probiere es erneut.")
55: 
56:     def _fizzbuzz(self, i):
57:         if i % 3 == 0 and i % 5 == 0:
58:             return "fizzbuzz"
59:         elif i % 3 == 0:
60:             return "fizz"
61:         elif i % 5 == 0:
62:             return "buzz"
63:         else:
64:             return i
65: 
66: 
67: fbs = FizzBuzzGame()
68: fbs.start_game_loop()

/bin/echo -e "1\n2\nfizz\n4\nbuzz\n" | python3 fizzbuzz_vererbung.py

 1: import functools
 2: 
 3: def by(number):
 4:     """Return a function to prove divisibility by number."""
 5:     return (lambda i: i % number == 0)
 6: 
 7: def fizzbuzz_func(i):
 8:     # create two functions to test for divisibility
 9:     by5 = by(5)
10:     by3 = by(3)
11: 
12:     if by5(i) and by3(i):
13:         return "fizzbuzz"
14:     elif by3(i):
15:         return "fizz"
16:     elif by5(i):
17:         return "buzz"
18:     else:
19:         return i
20: 
21: def fizzbuzz_functional():
22:     # apply fizzbuzz_func to numbers
23:     res = map(fizzbuzz_func, range(20))
24: 
25:     # reduce the result into a string
26:     s = functools.reduce(
27:         lambda acc, i: acc + str(i) + "\n", # updating function
28:         res, # values to be reduced
29:         "") # initial value
30: 
31:     print(s)
32: 
33: fizzbuzz_functional()

pip install bottle

 1: import bottle
 2: 
 3: @bottle.route("/fizzbuzz/<number:int>")
 4: def fizzbuzz_web_route(number):    
 5:     results = []
 6:     for i in range(number):
 7:         if i % 3 == 0 and i % 5 == 0:
 8:             results.append("fizzbuzz")
 9:         elif i % 3 == 0:
10:             results.append("fizz")
11:         elif i % 5 == 0:
12:             results.append("buzz")
13:         else:
14:             results.append(i)
15: 
16:     html = """
17:         <!DOCTYPE html>
18:         <html>
19:           <body>
20:             <h1>FizzBuzz Numbers up to {{max}}</h1>
21:             <table>
22:             % for r in results:
23:               <tr><td> {{r}} </td></tr>
24:             %end
25:             </table>
26:           </body>
27:         </html>
28:         """
29: 
30:     return bottle.template(html, max=number, results=results)
31: 
32: def fizzbuzz_web():
33:     bottle.run(host="127.0.0.1", port=8081)
34: 
35: fizzbuzz_web()

sudo apt install libapache2-mod-py3

 1: import os
 2: import bottle
 3: 
 4: # change working directory
 5: os.chdir(os.path.dirname(__file__))
 6: 
 7: # create the app
 8: application = bottle.Bottle()
 9: 
10: @application.route("/<number:int>")
11: def fizzbuzz_web_route(number):    
12:     results = []
13:     for i in range(number):
14:         if i % 3 == 0 and i % 5 == 0:
15:             results.append("fizzbuzz")
16:         elif i % 3 == 0:
17:             results.append("fizz")
18:         elif i % 5 == 0:
19:             results.append("buzz")
20:         else:
21:             results.append(i)
22: 
23:     html = """
24:         <!DOCTYPE html>
25:         <html>
26:           <body>
27:             <h1>FizzBuzz Numbers up to {{max}}</h1>
28:             <table>
29:             % for r in results:
30:               <tr><td> {{r}} </td></tr>
31:             %end
32:             </table>
33:           </body>
34:         </html>
35:         """
36: 
37:     return bottle.template(html, max=number, results=results)

<VirtualHost *>
    ServerName www.example.com

    WSGIDaemonProcess fizzbuzz user=www-data group=www-data processes=1 threads=5
    WSGIScriptAlias / /var/www/fizzbuzz/index.wsgi

    <Directory /var/www/fizzbuzz>
        WSGIProcessGroup fizzbuzz
        WSGIApplicationGroup %{GLOBAL}
        Require all granted
    </Directory>
</VirtualHost>

sudo service apache2 restart

 1: # Ein Verzeichnis erstellen und den Quelltext kopieren/erstellen
 2: mkdir /tmp/fizzbuzz_repo
 3: cd /tmp/fizzbuzz_repo
 4: echo 'print("Hallo Welt")' > hallo.py
 5: 
 6: # Repo initialisieren
 7: git init
 8: 
 9: # Dateien für commit vormerken
10: git add hallo.py
11: 
12: # Dateien in Repo einchecken
13: git commit -m "commit hallo.py" hallo.py
14: 
15: # Logfile anschauen
16: git log
17: 
18: # Feature branch erzeugen und wechseln
19: git checkout -b new_feature
20: 
21: # Dateien ändern
22: echo 'print("new feature")' >> hallo.py
23: 
24: # Einen Commit im neuen Branch erzeugen
25: git commit -m "added new feature" hallo.py
26: 
27: # Zurück zum Hauptbranch wechseln
28: git checkout master
29: 
30: # Feature-Branch in den Hauptzweig integrieren
31: git merge new_feature
32: 
33: # Wenn alles geklappt hat, kann der Feature Branch gelöscht werden
34: git branch -d new_feature

1: from setuptools import setup, find_packages
2: 
3: setup(
4:     name = "fizzbuzz_katas",
5:     version = "0.1",
6:     description = "Exercises with the famous FizzBuzz-Game.",
7:     packages = find_packages()
8: )

1: # Release in Unterordner erstellen: 
2: python setup.py sdist

1: # Systemweite Installation:
2: python setup.py install
3: 
4: # Lokale Installation:
5: #python setup.py install --user

 1: import unittest
 2: 
 3: class FizzBuzz:
 4:     def fizzbuzz(self, i):
 5:         if i % 3 == 0 and i % 5 == 0:
 6:             return "fizzbuzz"
 7:         elif i % 3 == 0:
 8:             return "fizz"
 9:         elif i % 5 == 0:
10:             return "buzz"
11:         else:
12:             return i
13: 
14: class FizzBuzzTest(unittest.TestCase):
15:     """This test class tests the class FizzBuzz. 
16: 
17:     Possible input will be testet against desired outputs."""
18: 
19:     def setUp(self):
20:         """Will be invoked before every test."""
21:         self.fizzbuzz = FizzBuzz()
22: 
23:     def test_fizzbuzz(self):
24:         fb = self.fizzbuzz
25: 
26:         # Comparing values
27:         self.assertEqual(fb.fizzbuzz(2), 2)
28:         self.assertEqual(fb.fizzbuzz(15), "fizzbuzz")
29:         self.assertEqual(fb.fizzbuzz(9), "fizz")
30:         self.assertEqual(fb.fizzbuzz(10), "buzz")
31: 
32:         # Boolean comparison
33:         self.assertTrue(fb.fizzbuzz(12) != 12)
34:         self.assertFalse(fb.fizzbuzz(12) == 12)
35: 
36:         # Comparing types
37:         self.assertIsInstance(fb.fizzbuzz(2), int)
38: 
39:         # Comparing with collections
40:         for i in range(20):
41:             result = fb.fizzbuzz(i)            
42:             self.assertIn(result, ['fizz', 'buzz', 'fizzbuzz', i])
43: 
44: def run_unit_tests():
45:     # Run all unit tests
46:     unittest.main()
47: 
48: run_unit_tests()

 1: import doctest
 2: 
 3: class FizzBuzz:
 4:     def fizzbuzz(self, i):
 5:         """This is a comment containing a test. This is called a doctest in Python.
 6: 
 7:         >>> fb = FizzBuzz()
 8:         >>> fb.fizzbuzz(3)
 9:         'fizz'
10:         >>> fb.fizzbuzz(5)
11:         'buzz'
12:         >>> fb.fizzbuzz(10)
13:         'buzz'
14:         >>> fb.fizzbuzz(11)
15:         11
16: 
17:         Now a test that creates an error:
18: 
19:         >>> fb.fizzbuzz(12)
20:         12
21: 
22:         """
23:         if i % 3 == 0 and i % 5 == 0:
24:             return "fizzbuzz"
25:         elif i % 3 == 0:
26:             return "fizz"
27:         elif i % 5 == 0:
28:             return "buzz"
29:         else:
30:             return i
31: 
32: def run_doc_tests():
33:     doctest.testmod()
34: 
35: run_doc_tests()

pip install eapi

 1: import eapi.hw 
 2: 
 3: class FizzBuzzEAModul:
 4:     def __init__(self):
 5:         self.i = 0
 6: 
 7:         eam = eapi.hw.EAModul()
 8:         # switching on green LED only
 9:         eam.schalte_leds(False, False, True)
10:         # register for events when button0 pressed
11:         eam.taster_event_registrieren(0, self.taster0_gedrueckt)
12: 
13:         # wait for taster event
14:         while True:
15:             pass
16: 
17:     def taster0_gedrueckt(self, pin):
18:         if self.i % 3 == 0 and self.i % 5 == 0:
19:             print("fizzbuzz")
20:         elif self.i % 3 == 0:
21:             print("fizz")
22:         elif self.i % 5 == 0:
23:             print("buzz")
24:         else:
25:             print(self.i)
26: 
27:         self.i += 1
28: 
29: FizzBuzzEAModul()

python -m pydoc eapi.hw.EAModul

 1: import sqlite3
 2: 
 3: def fizzbuzz_insert_into_db():
 4:     conn = sqlite3.connect("fizzbuzz.db")
 5:     c = conn.cursor()
 6:     c.execute("CREATE TABLE IF NOT EXISTS fizzbuzz(nr int, ergebnis text)")
 7: 
 8:     for i in range(20):
 9:         erg = ""
10:         if i % 3 == 0 and i % 5 == 0:
11:             erg = "fizzbuzz"
12:         elif i % 3 == 0:
13:             erg = "fizz"
14:         elif i % 5 == 0:
15:             erg = "buzz"
16:         else:
17:             erg = i
18: 
19:         c.execute("INSERT INTO fizzbuzz VALUES(?,?)", (i,erg))
20: 
21:     conn.commit()
22:     conn.close()
23: 
24: def fizzbuzz_select_from_db():
25:     conn = sqlite3.connect("fizzbuzz.db")
26:     c = conn.cursor()
27:     rows = c.execute("SELECT nr, ergebnis FROM fizzbuzz")
28: 
29:     print("Nr.\tErgebnis")
30:     for i,erg in rows:
31:         print(i, "    ", erg)
32: 
33:     conn.close()
34: 
35: fizzbuzz_insert_into_db()
36: fizzbuzz_select_from_db()

rm fizzbuzz.db

 1: class FizzBuzzGame:
 2:     """A class for a fizzbuzz game."""
 3: 
 4:     def fizzbuzz_documented(n):
 5:         """This method runs through all numbers from 0 to n-1.  
 6: 
 7:         It prints 'fizz' if the number is divisible by 3, 'buzz' if it
 8:         is divisble by 5, 'fizzbuzz' if it is divisible 3 and 5 and
 9:         the number itseld otherwise.
10:         """
11: 
12:         for i in range(n):
13:             if i % 3 == 0 and i % 5 == 0:
14:                 print("fizzbuzz")
15:             elif i % 3 == 0:
16:                 print("fizz")
17:             elif i % 5 == 0:
18:                 print("buzz")
19:             else:
20:                 print(i)
21: 
22: help(FizzBuzzGame)

pydoc3 fizzbuzz.fizzbuzz_dokumentiert
python -m pydoc fizzbuzz.fizzbuzz_dokumentiert

pydoc -p 8080

# alternativ:
python -m pydoc -p 8080

pip install sopel

sopel

1: [core]
2: nick = FizzBuzzBot
3: host = irc.freenode.net
4: use_ssl = false
5: port = 6667
6: owner = fizzbuzz_owner
7: channels = #fizzbuzz

 1: from sopel import module
 2: 
 3: @module.commands('fizzbuzz')
 4: def echo(bot, trigger):
 5:     # to everybody:   bot.say("...")
 6:     # to questioner: bot.reply("...")
 7: 
 8:     # take and convert argument
 9:     i = int(trigger.group(2))
10: 
11:     if i % 3 == 0 and i % 5 == 0:
12:         bot.reply("fizzbuzz")
13:     elif i % 3 == 0:
14:         bot.reply("fizz")
15:     elif i % 5 == 0:
16:         bot.reply("buzz")
17:     else:
18:         bot.reply(i)

sopel

 1: import sys
 2: 
 3: def fizzbuzz_cluster():
 4:     i = int (sys.argv[1])
 5: 
 6:     if i % 3 == 0 and i % 5 == 0:
 7:         print(i, "fizzbuzz")
 8:     elif i % 3 == 0:
 9:         print(i, "fizz")
10:     elif i % 5 == 0:
11:         print(i, "buzz")
12:     else:
13:         print(i, i)
14: 
15: fizzbuzz_cluster()

seq 20 | parallel --sshlogin server1,server2,server3 python3 fizzbuzz.py

 1: class FizzBuzzGame:
 2:     def __init__(self, n):
 3:         # protected/private attributes are marked with one/two underscores
 4:         self.__number = n
 5: 
 6:     def fizzbuzz(self):
 7:         if self.__number % 3 == 0 and self.__number % 5 == 0:
 8:             return "fizzbuzz"
 9:         elif self.__number % 3 == 0:
10:             return "fizz"
11:         elif self.__number % 5 == 0:
12:             return "buzz"
13:         else:
14:             return self.__number
15: 
16: fb = FizzBuzzGame(2)
17: print("Eingabe:", 2, "Ausgabe:", fb.fizzbuzz())
18: fb = FizzBuzzGame(15)
19: print("Eingabe:", 15, "Ausgabe:", fb.fizzbuzz())

pip install --user paho-mqtt

 1: import paho.mqtt.client as mqtt
 2: import threading
 3: import time
 4: 
 5: class FizzbuzzPublisher:
 6:     def __init__(self, server="iot.eclipse.org", port=1883):
 7:         self.client = mqtt.Client()
 8:         self.client.connect(server, port, keepalive=60)
 9: 
10:     def publish(self, payload):
11:         print("[publish]", payload)
12:         self.client.publish("fizzbuzz/", payload)
13: 
14: 
15: class FizzbuzzSubscriber:
16:     def __init__(self, server="iot.eclipse.org", port=1883):
17:         self.client = mqtt.Client()
18:         self.client.on_connect = self.on_connect
19:         self.client.on_message = self.on_message
20:         self.client.connect(server, port, keepalive=60)
21: 
22:     def start(self):
23:         self.client.loop_forever()
24: 
25:     def on_connect(self, client, userdata, flags, rc):
26:         print("[connected]")
27:         self.client.subscribe("fizzbuzz/")
28: 
29:     def on_message(self, client, userdata, msg):
30:         i = int(msg.payload)
31: 
32:         if i % 3 == 0 and i % 5 == 0:
33:             answer = "fizzbuzz"
34:         elif i % 3 == 0:
35:             answer = "fizz"
36:         elif i % 5 == 0:
37:             answer = "buzz"
38:         else:
39:             answer = i
40: 
41:         print("[msg reveived] topic:", msg.topic, "payload:", i, "answer:", answer)
42: 
43: 
44: #### Subscriber ####
45: 
46: # Start thread in background that responds to messages
47: print("[subscribing]")
48: sub = FizzbuzzSubscriber()
49: th1 = threading.Thread(target=sub.start, daemon=True)
50: th1.start()
51: 
52: #### Publisher ####
53: 
54: print("[start publishing]")
55: pub = FizzbuzzPublisher()
56: for i in range(1,21):
57:     pub.publish(i)
58:     # waiting some time and give the subscribed client time to do the job.
59:     time.sleep(0.1)
60: 
61: time.sleep(1)

 1: import eapi.hw
 2: import paho.mqtt.client as mqtt
 3: 
 4: 
 5: class MqttModul():
 6:     def __init__(self, server="iot.eclipse.org", port=1883):
 7:         self.num = 1
 8:         self.client = mqtt.Client()
 9:         self.client.connect(server, port, keepalive=60)
10:         self.client.on_connect = self.on_connect
11:         self.client.on_message = self.on_message
12:         self.client.connect(server, port, keepalive=60)
13: 
14:         self.eamodul = eapi.hw.EAModul()
15:         self.eamodul.taster_event_registrieren(0, self.taster_gedrueckt)
16: 
17:     def taster_gedrueckt(self, pin):
18:         print("[publish]", self.num)
19:         self.client.publish("eamodul/taster0/pressed/", 1)
20: 
21:     def on_connect(self, client, userdata, flags, rc):
22:         print("[connected]")
23:         self.client.subscribe("eamodul/taster0/pressed/")
24: 
25:     def on_message(self, client, userdata, msg):
26:         print("[msg reveived] topic:", msg.topic, "payload:", msg.payload)
27: 
28:         # turn off all LED rot, gelb, grün
29:         self.eamodul.schalte_leds(False, False, False)
30: 
31:         if self.num % 3 == 0 or self.num % 5 == 0:
32:             if self.num % 3 == 0:
33:                 self.eamodul.schalte_led(eapi.hw.EAModul.LED_GELB, True)
34:             if self.num % 5 == 0:
35:                 self.eamodul.schalte_led(eapi.hw.EAModul.LED_ROT, True)
36:         else:
37:             self.eamodul.schalte_led(eapi.hw.EAModul.LED_GRUEN, True)
38: 
39:         self.num += 1
40: 
41:     def start(self):
42:         self.client.loop_forever()
43: 
44: 
45: def main():
46:     mqttmod = MqttModul()
47:     mqttmod.start()
48: 
49: if __name__ == "__main__":
50:     main()

 1: import sys
 2: 
 3: def fizzbuzz(n):
 4:     for i in range(n):
 5:         if i % 3 == 0 and i % 5 == 0:
 6:             print("fizzbuzz")
 7:         elif i % 3 == 0:
 8:             print("fizz")
 9:         elif i % 5 == 0:
10:             print("buzz")
11:         else:
12:             print(i)
13: 
14: if __name__ == "__main__":
15:     print("Evaluating command line:", sys.argv)
16: 
17:     # sys.argv contains all parameters, program name at position 0.
18:     num_arg = sys.argv[1]
19:     number = int(num_arg)
20: 
21:     fizzbuzz(number)

python fizzbuzz-cli.py 20

 1: import argparse
 2: 
 3: def fizzbuzz(n):
 4:     for i in range(n):
 5:         if i % 3 == 0 and i % 5 == 0:
 6:             print("fizzbuzz")
 7:         elif i % 3 == 0:
 8:             print("fizz")
 9:         elif i % 5 == 0:
10:             print("buzz")
11:         else:
12:             print(i)
13: 
14: if __name__ == "__main__":
15:     # Using class ArgumentParser to help handling parameters
16:     parser = argparse.ArgumentParser(description="FizzBuzz Spiel")
17:     parser.add_argument("--max_wert", type=int, default=20,
18:                         help="Bis zu diesem Wert wird gezählt")
19:     args = parser.parse_args()
20:     fizzbuzz(args.max_wert)

python fizzbuzz-argparse.py --help

python fizzbuzz-argparse.py --max_wert 20

1: [default]
2: max_wert = 20
3: 
4: [informationen]
5: beschreibung = Ein Zählspiel

 1: import configparser
 2: 
 3: def fizzbuzz(n):
 4:     for i in range(n):
 5:         if i % 3 == 0 and i % 5 == 0:
 6:             print("fizzbuzz")
 7:         elif i % 3 == 0:
 8:             print("fizz")
 9:         elif i % 5 == 0:
10:             print("buzz")
11:         else:
12:             print(i)
13: 
14: config = configparser.ConfigParser()
15: config.read("fizzbuzz.ini")
16: 
17: description = config["informationen"]["beschreibung"]
18: print("Beschreibung:", description)
19: 
20: conf_num = config["default"]["max_wert"]
21: num = int(conf_num)
22: fizzbuzz(num)

pip install hug

 1: import hug
 2: 
 3: def fizzbuzz_results(n):
 4:     results = {}
 5:     for i in range(n):
 6:         if i % 3 == 0 and i % 5 == 0:
 7:             results[i] = "fizzbuzz"
 8:         elif i % 3 == 0:
 9:             results[i] = "fizz"
10:         elif i % 5 == 0:
11:             results[i] = "buzz"
12:         else:
13:             results[i] = i
14: 
15:     return results
16: 
17: @hug.get('/fizzbuzz') # respond to get-requests
18: def fizzbuzz_get(max_number):
19:     """Return fizzbuzz up to the given number."""
20:     n = int(max_number)
21:     return fizzbuzz_results(n)

hug -p 8081 -f fizzbuzz_hug.py

curl localhost:8081

curl localhost:8081/fizzbuzz?max_number=10

curl localhost:8081/fizzbuzz --data max_number=10 --request GET

 1: class FizzBuzzModel:
 2:     def __init__(self):
 3:         self.results = {}
 4: 
 5:         # a list of observers that react to modifications
 6:         # they must implement a method model_changed(added_value)
 7:         self.observers = []
 8: 
 9:     def add_value(self, val):        
10:         if val % 3 == 0 and val % 5 == 0:
11:             self.results[val] = "fizzbuzz"
12:         elif val % 3 == 0:
13:               self.results[val] = "fizz"
14:         elif val % 5 == 0:
15:             self.results[val] = "buzz"
16:         else:
17:             self.results[val] = val
18: 
19:         self._notify_observers(val)
20: 
21:     def add_observer(self, observer):
22:         self.observers.append(observer)
23: 
24:     def _notify_observers(self, added_val):
25:         for o in self.observers:
26:             o.model_changed(added_val)
27: 
28: 
29: class FizzBuzzView:
30:     def __init__(self, model):
31:         self.model = model
32: 
33:     def show(self):
34:         for r in self.model.results:
35:             print(r, self.model.results[r])
36: 
37: 
38: class FizzBuzzController:
39:     def __init__(self, model, view):
40:         self.model = model
41:         self.model.add_observer(self)
42:         self.view = view
43: 
44:     def add_value_to_model(self, new_val):
45:         self.model.add_value(new_val)
46: 
47:     def notify_view(self):
48:         self.view.model_changed()
49: 
50:     def model_changed(self, added_value):
51:         print("[controller] model changed. Added", added_value)
52: 
53:     def show_view(self):
54:         self.view.show()
55: 
56: def main():
57:     # creating and connecting model, view, and controller
58:     model = FizzBuzzModel()
59:     view = FizzBuzzView(model)
60:     controller = FizzBuzzController(model, view)
61: 
62:     print("# Adding values via controller to model")
63:     for i in range(20):
64:         controller.add_value_to_model(i)
65: 
66:     print("# Showing view of the model via controller")
67:     controller.show_view()
68: 
69: 
70: main()

pip install pygame

 1: import sys, pygame
 2: 
 3: class Ball(pygame.sprite.Sprite):
 4:     def __init__(self, screen_width, screen_height):
 5:         super().__init__()
 6:         self.image = pygame.image.load("doc/ball.gif")
 7:         self.rect = self.image.get_rect()
 8:         self.speed = [2, 2] # speed in x and y direction
 9:         self.screen_width = screen_width
10:         self.screen_height = screen_height
11: 
12:     def update(self):
13:         """Update called by the update of the Group method."""
14:         self.rect = self.rect.move(self.speed)
15:         if self.rect.left < 0 or self.rect.right > self.screen_width:
16:             self.speed[0] = -self.speed[0]
17:         if self.rect.top < 0 or self.rect.bottom > self.screen_height:
18:             self.speed[1] = -self.speed[1]
19: 
20:     def is_clicked(self):
21:         """Check whether this Ball has been clicked."""
22:         x,y = pygame.mouse.get_pos()
23:         # Coordinate system starts with (0,0) at top left
24:         return (self.rect.left < x < self.rect.right and
25:                 self.rect.top < y < self.rect.bottom)
26: 
27: 
28: class FizzBuzzGame:
29:     def __init__(self, width, height):
30:         pygame.init()
31: 
32:         self.width, self.height = width, height
33:         self.screen = pygame.display.set_mode((width, height))
34: 
35:         self.ball = Ball(width, height)
36:         self.font = pygame.font.SysFont("Arial", 16)
37: 
38:     def fizzbuzz(self, n):
39:         if n % 3 == 0 and n % 5 == 0:
40:             return "fizzbuzz"
41:         elif n % 3 == 0:
42:             return "fizz"
43:         elif n % 5 == 0:
44:             return "buzz"
45:         else:
46:             return n
47: 
48:     def start_game_loop(self):
49:         clock = pygame.time.Clock()
50:         # group all sprites (here only one)
51:         allsprites = pygame.sprite.Group((self.ball))
52:         number, fb_result = 1, 1
53: 
54:         while True:
55:             clock.tick(60) # limit runtime to 60 Frames/Second
56: 
57:             # handle events
58:             for event in pygame.event.get():
59:                 ## handle events ##
60:                 if event.type == pygame.QUIT:
61:                     sys.exit()
62:                 elif event.type == pygame.MOUSEBUTTONDOWN and self.ball.is_clicked():
63:                     number += 1                    
64:                     fb_result = self.fizzbuzz(number)
65: 
66:             # update all Sprites
67:             allsprites.update()
68: 
69:             # draw the screen: background, sprites, text
70:             self.screen.fill((0,0,0))
71:             # for each sprite in the group draw/blit the image into a rect
72:             allsprites.draw(self.screen)
73:             # draw text on top
74:             fontsurf = self.font.render(str(fb_result), False, (0,255,0))
75:             self.screen.blit(fontsurf, self.ball.rect)                
76:             # flip the buffer
77:             pygame.display.flip()
78: 
79: 
80: game = FizzBuzzGame(320, 240)
81: game.start_game_loop()

sudo apt-get install docker.io

sudo usermod -aG docker mein_username

# We use alpine as base image, since it has a small footprint
FROM alpine

# apk is alpines package manager - invoked with RUN
RUN apk add --no-cache python3

# Copy the script in the root folder
COPY fizzbuzz_docker.py /

# Run this command when the container is started
CMD ["python3", "/fizzbuzz_docker.py", "20"]

docker build -t fizzbuzz .

 1: import sys
 2: import os
 3: 
 4: def fizzbuzz(n):
 5:     if n % 3 == 0 and n % 5 == 0:
 6:         return "fizzbuzz"
 7:     elif n % 3 == 0:
 8:         return "fizz"
 9:     elif n % 5 == 0:
10:         return "buzz"
11:     else:
12:         return n
13: 
14: # determine parameter for fizzbuzz: environment variable, commandline,
15: # or default value.
16: if "FIZZBUZZ" in os.environ:
17:     print("[using environment variable as parameter]")
18:     n = os.environ["FIZZBUZZ"]
19:     n = int(n)    
20: elif len(sys.argv) > 1:
21:     print("[using command line parameter]")
22:     n = int(sys.argv[1])
23: else:
24:     print("[using default value as parameter]")
25:     n = 20   
26: 
27: for i in range(n):
28:     print(fizzbuzz(i))

docker images fizzbuzz

docker run --rm fizzbuzz

docker run --rm fizzbuzz /usr/bin/python3 /fizzbuzz_docker.py 10

docker run --rm fizzbuzz /usr/bin/python3 /fizzbuzz_docker.py

docker run --rm -e FIZZBUZZ=8 fizzbuzz

docker rmi fizzbuzz

 1: class FizzBuzzException(Exception):
 2:     """An exception for the FizzBuzz game."""
 3:     def __init__(self, errormessage, val):
 4:         """Create the exception with the given message and the problematic value."""
 5:         self.errormessage = errormessage
 6:         self.value = val
 7: 
 8: class FizzBuzzSpiel:
 9:     def fizzbuzz(self, i):
10:         if i < 0:
11:             # Raise an Exception and stop execution if the parameter is negative
12:             raise FizzBuzzException("Das Argument muss positiv sein!", i)
13: 
14:         if i % 3 == 0 and i % 5 == 0:
15:             print("fizzbuzz")
16:         elif i % 3 == 0:
17:             print("fizz")
18:         elif i % 5 == 0:
19:             print("buzz")
20:         else:
21:             print(i)
22: 
23: 
24: fb = FizzBuzzSpiel()
25: for i in range(-5, 5):
26: 
27:     # trying to run the code
28:     try:
29:         print("Probiere", i)
30:         fb.fizzbuzz(i)
31: 
32:     except FizzBuzzException as ex:
33:         # Whenever an exception is raised, jump to this code block
34:         print("[Fehler]", ex.errormessage, ex.value)

  1: import random
  2: 
  3: class Perceptron:
  4:     def __init__(self, num_inputs):
  5:         self.c = 0.01 # coefficient that determines learning speed.
  6: 
  7:         # random values weights in [-1;+1]
  8:         self.weights = [random.randint(-100,100)/100 for i in range(num_inputs)]
  9: 
 10:     def feedforward(self, inputs):
 11:         """Ask a trained perceptron for output on given input."""
 12:         assert len(self.weights) == len(inputs)
 13: 
 14:         sum = 0        
 15:         for i in range(len(self.weights)):
 16:             sum += inputs[i] * self.weights[i]
 17: 
 18:         return self.activate(sum)
 19: 
 20:     def activate(self, sum):
 21:         """Activation function determines when the perceptron fires - if output is positive."""
 22:         if sum > 0:
 23:             return +1
 24:         else:
 25:             return -1
 26: 
 27:     def train(self, inputs, desired):
 28:         """Train for inputs and desired result."""
 29:         assert len(inputs) == len(self.weights)
 30: 
 31:         guess = self.feedforward(inputs)
 32:         error = desired - guess
 33: 
 34:         for i in range(len(self.weights)):
 35:             self.weights[i] += self.c * error * inputs[i]
 36: 
 37: 
 38: class NeuralNetwork:
 39:     def __init__(self, num_inputs, num_outputs):
 40:         """Create a neural network of perceptrons. 
 41: 
 42:         num_inputs denotes the number of inputs per Perceptron, while
 43:         num_outputs denotes the number of perceptrons and therefore
 44:         the number of outputs.
 45:         """
 46:         self.ptrons = []
 47:         for i in range(num_outputs):
 48:             self.ptrons.append(Perceptron(num_inputs))            
 49: 
 50:     def train(self, inputs, desired_outputs):
 51:         """Train the network by training all perceptrons in it."""
 52:         assert len(inputs) == self.num_inputs()
 53:         assert len(desired_outputs) == self.num_outputs()
 54: 
 55:         for pi in range(len(self.ptrons)):
 56:             self.ptrons[pi].train(inputs, desired_outputs[pi])
 57: 
 58:     def ask(self, inputs):
 59:         """Ask the network for an answer. It will return the index and value
 60:         of the perceptron with the maximum value.
 61:         """
 62:         answers = []
 63:         for p in self.ptrons:
 64:             a = p.feedforward(inputs)
 65:             answers.append(a)
 66: 
 67:         # determine maximum output value
 68:         maxval = [0, answers[0]]
 69:         for (i,a) in enumerate(answers):
 70:             if a > maxval[1]:
 71:                 maxval = [i, a]
 72: 
 73:         return maxval
 74: 
 75:     def num_inputs(self):
 76:         assert len(self.ptrons) > 0
 77: 
 78:         return len(self.ptrons[0].weights)
 79: 
 80:     def num_outputs(self):
 81:         return len(self.ptrons)
 82: 
 83: 
 84: class FizzbuzzNetwork(NeuralNetwork):
 85:     def __init__(self, numbers):
 86:         # adding 3 outputs for fizz, buzz and fizzbuzz
 87:         super().__init__(numbers, numbers+3)
 88: 
 89:         self.numbers = numbers
 90:         self.fizz = numbers
 91:         self.buzz = numbers + 1
 92:         self.fizzbuzz = numbers + 2
 93: 
 94:     def train_rounds(self, training_rounds):
 95:         for _ in range(training_rounds):
 96:             for i in range(self.numbers):
 97:                 inputs = self.encode_input(i)
 98: 
 99:                 # answer a is 1 for the right perceptron, -1 otherwise
100:                 outputs = [-1] * (self.numbers + 3)
101:                 if i%3==0 and i%5==0:                
102:                     outputs[self.fizzbuzz] = 1
103:                 elif i%3==0:
104:                     outputs[self.fizz] = 1
105:                 elif i%5==0:
106:                     outputs[self.buzz] = 1
107:                 else:
108:                     outputs[i] = 1
109: 
110:                 self.train(inputs, outputs)
111: 
112:     def encode_input(self, num):
113:         assert num < self.numbers
114: 
115:         inputs = [0] * self.numbers
116:         inputs[num] = 1
117:         return inputs
118: 
119:     def ask(self, inputs):
120:         idx, value = super().ask(inputs)
121: 
122:         if idx == self.fizz:
123:             idx = "fizz"
124:         elif idx == self.buzz:
125:             idx = "buzz"
126:         elif idx == self.fizzbuzz:
127:             idx = "fizzbuzz"
128: 
129:         return idx, value
130: 
131: 
132: def fizzbuzz_nn():
133:     numbers = 20    
134: 
135:     # training the network several times
136:     for rounds in [10, 45, 100]:
137:         print("training", rounds, "rounds")
138: 
139:         nn = FizzbuzzNetwork(numbers)
140:         nn.train_rounds(rounds)
141: 
142:         # asking the trained network
143:         for i in range(numbers):
144:             inputs = nn.encode_input(i)        
145:             idx, answer = nn.ask(inputs)
146:             print(i, idx)
147: 
148: 
149: fizzbuzz_nn()

 1: import logging
 2: 
 3: class FizzbuzzLogged:
 4:     def __init__(self):        
 5:         logging.info("Logger initialized!")
 6: 
 7:     def fizzbuzz(self, i):
 8:         if i < 0:
 9:             logging.warn("ignoring %s", i)
10:             return
11: 
12:         logging.info("value %s", i)
13:         if i % 3 == 0 and i % 5 == 0:
14:             logging.info("fizzbuzz")
15:         elif i % 3 == 0:
16:             logging.info("fizz")
17:         elif i % 5 == 0:
18:             logging.info("buzz")
19:         else:
20:             logging.info(i)
21: 
22: 
23: if __name__ == "__main__":
24:     # configuring logging: using log-level DEBUG and above
25:     logging.basicConfig(filename="fizzbuzz.log", level=logging.DEBUG)
26: 
27:     fb = FizzbuzzLogged()
28:     for i in range(-5, 20):
29:         fb.fizzbuzz(i)

INFO:root:Logger initialized!
WARNING:root:ignoring -5
WARNING:root:ignoring -4
WARNING:root:ignoring -3
WARNING:root:ignoring -2
WARNING:root:ignoring -1
INFO:root:value 0
INFO:root:fizzbuzz
INFO:root:value 1
INFO:root:1
INFO:root:value 2
INFO:root:2
INFO:root:value 3
INFO:root:fizz
INFO:root:value 4
INFO:root:4
INFO:root:value 5
INFO:root:buzz
INFO:root:value 6
INFO:root:fizz
INFO:root:value 7
INFO:root:7
INFO:root:value 8
INFO:root:8
INFO:root:value 9
INFO:root:fizz
INFO:root:value 10
INFO:root:buzz
INFO:root:value 11
INFO:root:11
INFO:root:value 12
INFO:root:fizz
INFO:root:value 13
INFO:root:13
INFO:root:value 14
INFO:root:14
INFO:root:value 15
INFO:root:fizzbuzz
INFO:root:value 16
INFO:root:16
INFO:root:value 17
INFO:root:17
INFO:root:value 18
INFO:root:fizz
INFO:root:value 19
INFO:root:19

 1: import cProfile
 2: 
 3: def fizzbuzz_method(n):
 4:     for i in range(n):
 5:         if i % 3 == 0 and i % 5 == 0:
 6:             print("fizzbuzz")
 7:         elif i % 3 == 0:
 8:             print("fizz")
 9:         elif i % 5 == 0:
10:             print("buzz")
11:         else:
12:             print(i)
13: 
14: if __name__ == "__main__":
15:     # running the profiler for the given method invocation
16:     cProfile.run("fizzbuzz_method(20)")

 1: import matplotlib.pyplot as plt
 2: 
 3: def fizzbuzz(n):
 4:     if n % 3 == 0 and n % 5 == 0:
 5:         return "fizzbuzz"
 6:     elif n % 3 == 0:
 7:         return "fizz"
 8:     elif n % 5 == 0:
 9:         return "buzz"
10:     else:    
11:         return n
12: 
13: def main():
14:     xs = []
15:     ys = []
16: 
17:     for x in range(100):
18:         res = fizzbuzz(x)
19:         if isinstance(res, int):
20:             # the result was a number - not 'fizz', 'buzz' or 'fizzbuzz'.
21:             xs.append(x)
22:             ys.append(res)
23: 
24:     # clear all figures
25:     plt.clf()
26:     # turn on the grid and set title
27:     plt.grid(True)
28:     plt.title("Fizzbuzz")
29:     # create a plot made of x and y values and save as image
30:     plt.plot(xs, ys, "r.")
31:     plt.savefig("doc/fizzbuzz-plot.png")
32: 
33: if __name__ == "__main__":
34:     main()