Beispiele

Python, Programmieren macht Spaß
#!/usr/bin/env python3

#
# Python Beispiele zu
# http://www.thomas-guettler.de/vortraege/python/einfuehrung.html
#
# (c) 2003-2019 Thomas Güttler
# http://www.thomas-guettler.de/
#

# Mein Vorschlag: PyCharm installieren.
# Dann ein neues Projekt erstellen.
# Dann die unten stehenden Beispiele lesen, verstehen und **selbständig im PyCharm eintippen**.
# In PyCharm: Rechte Maustaste "New / Python File".
# Ausführen mit Menü "Run / Run", bzw Alt+Shift+F10.
#
# Wer denkt mit Copy&Paste schneller voranzukommen: Ja, du bist schneller,
# aber am Ende nicht klüger.
# Der Lerneffekt ist höher, wenn du die Beispiele eintippst. Ziel der Übung ist es, das
# Schreiben von Programmen zu lernen. Copy&Paste kann jeder, das ist keine Kunst.
# PyCharm Intro: https://www.jetbrains.com/help/pycharm/quick-start-guide.html


# Beispiel ZINSEN:
# Ein Versicherungsvertreter verspricht dir, dass du einen großen
# Betrag bekommst, wenn du 35 Jahre jährlich 900 Euro einzahlst. Du
# willst nun wissen, wieviel Geld du hättest, wenn du keine
# Rentenversicherung abschließt, sondern das Geld mit 3 Prozent
# Zinsen anlegst. Vielleicht gibt es dafür eine Formel, aber iterativ
# (in einer Schleife) lässt sich das auch leicht berechnen.

summe = 0
for jahr in range(35):
    summe *= 1.03  # 3 Prozent Zinsen
    summe += 900
    print(f'Jahr {jahr+1} Betrag: {summe}')

# ---------------------------------------------------------------------
# Beispiel FIFO:
# FIFO (first in first out) (Queue)
# Vergleich: Autobahntunnel
#
l = []  # Nehme eine leere Liste
for i in range(10):
    l.append(i)  # An Liste anhängen
print(l)
while l:  # Solange 'l' nicht leer ist ...
    print(l.pop(0))  # Entferne erstes Element der Liste

# Ergebnis: 0, 1, 2, ...


# ---------------------------------------------------------------------
# Beispiel FILO:
# FILO (first in last out) (Stack)
# Vergleich: Stapel von Münzen
#
l = []
for i in range(10):
    l.append(i)
while l:
    print(l.pop())  # Entferne letztes Element der Liste

# Ergebnis: 9, 8, 7, ...

# ---------------------------------------------------------------------
# Beispiel ZÄHLEN
for i, wort in enumerate(['null', 'eins', 'zwei']):
    print(i, wort)  # 0 null, 1 eins, ....

# ---------------------------------------------------------------------
# Beispiel ENDE:
# Das dicke Ende
#
file = 'foo.jpg'
if file[-4:] == '.jpg':  # unschön
    print('Foto')
if file.endswith('.jpg'):  # besser, analog 'startswith()'
    print('Foto')

# ---------------------------------------------------------------------
# Beispiel DIE WAHRHEIT:
# Was ist wahr und was ist falsch?
# Folgende Bedingungen sind wahr:
#
if True:
    print('wahr')
if 1:
    print('wahr')
if -1:  # Alle Zahlen außer 0 sind wahr
    print('wahr')
if '0':  # Nichtleere Zeichenkette
    print('wahr')
if 'False':  # Nichtleere Zeichenkette
    print('wahr')
if [[]]:  # Nichtleere Liste
    print('wahr')

if not False:
    print('wahr')
if not 0:
    print('wahr')
if not []:  # Leere Liste
    print('wahr')
if not {}:  # Leeres Dictionary
    print('wahr')
if not '':  # Leere Zeichenkette
    print('wahr')
if not None:
    print('wahr')
if not bool('0'):
    print('wahr')
if True and True:
    print('wahr')
if False or True:
    print('wahr')

# ---------------------------------------------------------------------
# Beispiel REFERENZ:
# Referenz vs. Kopie
#
list1 = [1, 2, 3, 4]
list2 = list1  # Zwei Referenzen zeigen auf eine Liste
list2[0] = 5
print(list1 == list2)  # --> 1

list1 = [1, 2, 3, 4]
list2 = list1[:]  # Erstelle eine Kopie der ersten Liste
list2[0] = 5
print(list1 == list2)  # --> 0


# ---------------------------------------------------------------------
# Beispiel SETS:
# Mengenlehre
bis_fuenf = set([1, 2, 3, 4, 5])
gerade = set([2, 4, 6, 8, 10])
vereinigung = bis_fuenf | gerade  # Union
schnittmenge = bis_fuenf & gerade  # Intersection
differenz = bis_fuenf - gerade
print('Mengenlehre', vereinigung, schnittmenge, differenz)



# ---------------------------------------------------------------------
# Beispiel SORTDICT:
# Ein Dictionary sortieren.
# Da Dictionaries nicht sortiert gespeichert werden,
# will man sie für die Ausgabe ggf. sortieren:
mydict = {'a': ['Auto', 'Ampel'],
          'b': ['Bus', 'Banane'],
          'c': ['Chemnitz', 'Chaos'],
          'd': ['Dame', 'Diesel'],
          'e': ['Esel']}
print('Unsortiert:', mydict)
for buchstabe, woerter in sorted(mydict.items()):
    print(f'{buchstabe} {woerter}')


# ---------------------------------------------------------------------
#Beispiel DOWNLOAD:
#Herunterladen eine Webseite:

import urllib.request
with urllib.request.urlopen('http://www.python.org/') as f:
    content = f.read()
print(content)

# ---------------------------------------------------------------------
#Beispiel WEBBROWSER:
#Anzeigen der heruntergeladene Seite in einem Browser:
#Es wird der Standard-Browser des Systems genommen.

import tempfile
import webbrowser
htmlfile = tempfile.mktemp('foo.html')
with open(htmlfile, 'wb') as fd:
    fd.write(content)
webbrowser.open(f'file://{htmlfile}')

# ---------------------------------------------------------------------
# Beispiel CHARCOUNT:
# Zähle wie oft die Zeichen einer Datei vorkommen
datei = 'beispiele.py'
inhalt = open(datei).read() # Lese die gesamte Datei 
countdict = {}  # Erstelle leeres Dictionary
for char in inhalt:  # char (character) == Zeichen
    old = countdict.get(char, 0)  # Falls Zeichen noch nicht gezählt, nehme die Null
    old += 1  # Zähle um eins hoch
    countdict[char] = old  # Speichere Zähler im Dictionary (char == key (Schlüssel)

items = list(countdict.items())  # Liste [(key1, value1), (key2, value2), ...]
items.sort()  # Sortiere die Liste nach den Zeichen
for char, count in items:
    if char == '\n':
        char = '\\n'  # Newline als \n ausgeben.
    print(f'Zeichen {char}: {count:4}') # :4 --> rechtsbündig mit einer Breite von 4 Zeichen ausgeben.

# ---------------------------------------------------------------------
# Beispiel UNICODE die "heile" Objekt-Welt und die schnöden Bytes.
print(len('üöäß'))   #  <-- "heile" Objekt-Welt. Bytes gibt es hier nicht.
print(len('üöäß'.encode('utf8')))
print(len('üöäß'.encode('utf16')))
print(len('üöäß'.encode('latin1')))

# ---------------------------------------------------------------------
# Beispiel EINMALEINS:
# Das Einmaleins als HTML-Tabelle
#
import tempfile
import webbrowser

rows = []
heading = []
for i in range(1, 11):
    heading.append(f'<th bgcolor="gray">{i}</th>')
    cols = []
    for j in range(1, 11):
        cols.append(f'<td align="right">{i * j}</td>')
    row = f'<tr><th bgcolor="gray">{i}</th>{"".join(cols)}</tr>')
    rows.append(row)
html = f'''
 <html>
  <head><title>Einmaleins</title></head>
  <body>
   <table border="1">
    <tr>
     <th>&nbsp;</th> {''.join(heading)}
    </tr>
    {''.join(rows)}
   </table> 
  </body>
 </html>'''

temp = f'{tempfile.mktemp()}.html'
with open(temp, 'w') as f:
    fd.write(html)
webbrowser.open(temp)
# Bei Mozilla oder Firefox muss ggf. noch 'strg-r' (Reload) gedrückt werden.



# ---------------------------------------------------------------------
# Beispiel STACKTRACE:
# Stacktrace einer Exception als String
# Anwendung: Fehler bei einer Web-Anwendung als Email
# verschicken:
def foo():
    raise Exception('Das ist eine Exception')


try:
    foo()
except Exception:
    import traceback

    exc_string = ''.join(traceback.format_exc())
    print(exc_string)
    # raise ohne Argumente führt ein 're-raise' aus:
    # Die aufgefangene Exception wird wieder ausgelöst
    raise

# Hinweis: Eine 'catch-all' Regel, die alle Exceptions auffängt
# sollte vermieden werden. Normalerweise sollte man
# nur bestimmte Exceptions auffangen. Beispiel:
i = 'abc'
try:
    i = int(i)
except ValueError:
    print(f'{i} ist keine Ganzzahl')


# ---------------------------------------------------------------------
# Beispiel LISTCOMPREHENSION:
# Listcomprehension verwende ich selten, da man genauso mit einer
# Schleife arbeiten kann:

# Mit Listcomprehension
staedte = ['Augsburg', 'Bremen', 'Hamburg', 'Berlin']
staedte_mit_b = [s for s in staedte if s.startswith('B')]
print(staedte_mit_b)

# Mit Schleife
staedte_mit_b = []
for s in staedte:
    if s.startswith('B'):
        staedte_mit_b.append(s)
print(staedte_mit_b)


# ---------------------------------------------------------------------
# Beispiel OWNEXCEPTIONS:
# Eigene Exceptions
#
# Hinweis: Das Auffangen aller Exceptions sollte vermieden werden,
# da Fehler wie MemoryError, KeyboardInterrupt oder ZeroDivisionError
# nicht stillschweigend übergangen werden sollten.

class MyException(Exception):
    pass


def test_func():
    raise MyException('Test')


try:
    test_func()
except MyException as exc:
    print(f'Fehler: {exc}')  # --> 'Fehler: Test'

# ---------------------------------------------------------------------
# Beispiel DATETIME:
# Rechnen mit Tagen
import datetime

heute = datetime.date.today()
gestern = heute - datetime.timedelta(days=1)
morgen = heute + datetime.timedelta(days=1)
print(gestern, heute, morgen)

# ---------------------------------------------------------------------
# Beispiel MTIME ZU DATETIME:
# mtime zu datetime
import os
import datetime

mtime = os.path.getmtime('/etc/fstab')  # Wert: Sekunden seit 1970
datetime.datetime.fromtimestamp(mtime)  # High-Level Datumsangabe


# ---------------------------------------------------------------------
# Beispiel os.walk():
# Das Unix-Tool 'find' durchsucht Verzeichnisse rekursiv.
# In Python kann man dafür die Funktion os.walk() verwenden.
# Damit die Ergebnisse reproduzierbar sind, empfiehlt es sich
# die Verzeichnisse und Dateien vor dem durchforsten zu sortieren.
# In diesem Beispiel werden alle Verzeichnisse übersprungen die 'temp'
# oder 'tmp' heißen und Dateien die mit '.pyc' enden.

import os

start = '.'
for root, dirs, files in os.walk(start):
    dirs[:] = [dir for dir in sorted(dirs) if not dir in ['temp', 'tmp']]  # inplace Modifikation.
    for file in sorted(files):
        if file.endswith('.pyc'):
            continue
        file = os.path.join(root, file)
        print(file)