Anmerkungen zu den Aufgaben bzw. Lösungen

1. Allgemeine Hinweise

1. DocStrings statt Kommentaren im Kopf von Modulen, Funktionen, Klassen und Methoden (und nur dort!):

   def factorial(n):
       """function without recursion"""
       if n > 0:
           ...
   

2. Bei Bedingungen: keine Klammern erforderlich, ggf. True und False verwenden:

   while True:
       ...
   
   # nicht: while(1):
   

3. Styleguide (Lesbarkeit): Keyword Arguments ohne, Zuweisungen mit Leerzeichen; vor und nach Operatoren Leerzeichen:

   def __init__(self, anrede="", ...):
       self.anrede = anrede
   
   result = wert1 * wert2
   

4. Innerhalb von Klammern ist bei mehrzeiligen Ausdrücken kein "continuation character" () am Zeilenende erforderlich:

   person = AdressLabel(anrede="Herr", titel="Dr.", vorname="Hans",
              nachname="Mueller", strasse="Holzweg", hausnummer=6,
              plz= 12345, ort="Dorf")
   

5. Namen mit Doppel-Unterstrich sind per Konvention für Python-interne Zwecke reserviert:

   # nicht: def __checkValue__(value):  sondern einfach:
   
   def checkValue(value):
       ...
   

6. Der Aufbau langer Strings durch Konkatenierung (+ Operator) ist ineffizient, da bei jeder Operation ein neues String Objekt erzeugt und der Inhalt des bisherigen String kopiert wird; bessere Lösung: Ablegen der Teilstrings (Felder, Zeilen) in einer Liste, am Schluss per join() zusammenfügen, etwa:

   lines = []
   fields = []
   if self.address:
       fields.append(self.address)
   if self.title:
       fields.append(self.title)
   ...
   lines.append(' '.join(fields))
   ...
   return '\n'.join(lines)
   

• Noch einfacher lassen sich solche Strings per list comprehension aufbauen:

  lines.append(' '.join([f for f in (self.address, self.title, ...)
                           if f]))
  ...
  return '\n'.join(lines)
  

7. Interne Methoden ("__xxx__") nicht unmittelbar aufrufen sondern die entsprechenden eingebauten Funktionen verwenden:

   self.firma = str(firma)  # nicht: firma.__str__()
   # ist hier aber eigentlich auch überflüssig...
   
   if len(self.args) != 0:  # nicht: self.args.__len__
   # oder noch einfacher:
   if self.args:
   
   if 'url' in self.args:   # nicht: self.args.__contains__('url')
   

8. Styleguide: Groß-/Kleinschreibung beachten:

   self.anrede             # nicht: self.Anrede
   class Label(object):    # nicht: class label(object):
   def drive(self):        # nicth: def Drive(self):
   

9. Sprechende Namen verwenden:

   label = Label(anrede, name, ...)  # (statt: Label(an, na, ...)
   

10. Niemals from xxxx import * verwenden - das macht den Namensraum unkontrollierbar und führt dazu, dass nicht mehr nachvollzogen werden kann, woher welche Funktionen kommen.

11. Umwandlung von Zeit-Strings in Sekunden, dadurch einfacher Vergleich von Zeitwerten; mit strptime lassen sich auch Datumseingaben parsen:

    from time import time, mktime, strptime
    if time() >= mktime(strptime(<Zeit-String>, <Format>)):
        ...
    

12. Veränderliche Objekte nicht auf Klassen-Ebene definieren, da sie sonst allen instances der Klasse gemeinsam sind:

    class Scheduler(object):
    
    # nicht: commands = []
    
    def __init__(self, filename):
        self.filename
        self.commands = []
    

13. Styleguide: Package- und Modulnamen immer durchgängig in Kleinbuchstaben, ohne Sonderzeichen (z.B. Unterstriche); so wird sichergestellt, dass es keine unerwarteten Probleme auf unterschiedlichen Betriebssystemen gibt.

14. Dynamische Zuordnung von Funktionen (Kommandos) zu Strings: am einfachsten über ein Dictionary:

    from operator import add, sub, mul, div
    operators = {'+': add, '-': sub, '*': mul, '/': div}
    op = operators.get(operator)
    if op is None:
        result = 'invalid operator'
    else:
        result = op(a, b)
    

15. Fehlertolerante Dictionary-Abfrage (statt try:/except:):

    if key in dictionary:  # has_key() ist veraltet
        ...
    # oder:
    value = dictionary.get(key, None) # oder anderer default statt None
    

16. Anführungszeichen z.B. für die Generierung von HTML- oder XML-Tags können ohne Backslash eingegeben werden, wenn der String in die alternativen Anführungszeichen eingeschlossen wird:

    line = '<input name="operand1" type="text" size="9" />'
    

17. Schleifen nicht über range(len(x)) laufen lassen, sondern die Liste unmittelbar verwenden, ggf. unter Nutzung der enumerate() Funktion; auch für den Index-Zugriff in Listen ist len(x) nicht erforderlich:

    lastweek = current_month[-1]
    for j, d in enumerate(lastweek):
        if d == 0:
            current_month[-1][j] = firstweekafter[j]
    

18. Styleguide: Attribut- und Methoden-Namen mit Doppel-Unterstrich am Anfang sollten nur verwendet werden, wenn aus technischen Gründen zwingend erforderlich, standardmäßig also:

    class Address(object):
    
        anrede = ''
        # nicht: __anrede
    

19. String-Operationen: Für String-Operationen nicht das veraltete string Modul verwenden, sondern String-Methoden:

    '\n'.join(lines)    # nicht: string.join(lines, '\n')
    

20. for statt while: Schleifen mit for und range() sind meist die bessere (kürzere und schnellere) Lösung, z.B.:

    result = 1
    for x in range(1, n + 1):
        result *= x
    

2. Hinweise zu einzelnen Aufgaben