Kommentare im Code

Kommentare im Code#

Kommentare im Code sind wichtig, um den Code verständlicher zu machen. Sie werden vom Interpreter ignoriert und dienen nur den Menschen, die den Code lesen.

  • Notwending, um eigene Programme auch später noch zu verstehen

  • Hilfreich für andere, die den Code lesen (z.B. bei Teamarbeit)

    • Besonders nützlich für die Übungen (= soziale Komponente der Übung)

  • Sehr brauchbar zur Fehlersuche

    • Fehler können so leichter gefunden/ eingekreist werden

    • Teile des Codes können so temporär deaktiviert werden

  • Wichtig: Kommentare sollten den Code erklären, nicht den offensichtlichen Code wiederholen

    • Schlecht: x = x + 1  # increase x by 1

    • Gut: x = x + 1  # count the number of tries

In Python beginnen Kommentare mit dem # Zeichen und gehen bis zum Ende der Zeile. Beispiel:

# Script to read in two numbers and print their minimum

# Read the numbers from the user
a = float(input("Enter the first number: "))
b = float(input("Enter the second number: "))

# Determine the minimum
if a < b:
    minimum = a
else:
    minimum = b

# Print the result
print("The minimum is:", minimum)

The minimum is: 3.0

# Demonstration of swapping two variables in Python
x = 5
y = 10
print("Before swapping: x =", x, ", y =", y)
x, y = y, x  # This swaps the values of x and y without a temporary variable
print("After swapping: x =", x, ", y =", y)

Before swapping: x = 5 , y = 10
After swapping: x = 10 , y = 5

Beispiel zur Fehlersuche mit Kommentaren#

Wenn der Code unerwartets Verhalten zeigt, kann man Teile des Codes auskommentieren, um den Fehler einzugrenzen.

  • Der Interpreter verortet den Fehler zuerst in der Funktion compute_speed (wo auch tatsächlich durch Null dividiert wird)

  • Das eigentliche Problem ist aber, dass die Funktion get_time den Wert 0 zurückgibt

  • Durch Auskommentieren des Funktionsaufrufs time = get_time() verschwindet der Fehler

  • Daher kann man davon ausgehen, dass das Problem in der Funktion get_time liegt

def compute_speed(distance, time):
    result = distance / time
    print("Result:", result)

def get_time():
    return 0 

distance = 10
time = 1

time = get_time()
compute_speed(distance, time)

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[12], line 12
      9 time = 1
     11 time = get_time()
---> 12 compute_speed(distance, time)

Cell In[12], line 2, in compute_speed(distance, time)
      1 def compute_speed(distance, time):
----> 2     result = distance / time
      3     print("Result:", result)

ZeroDivisionError: division by zero

def compute_speed(distance, time):
    result = distance / time
    print("Result:", result)

def get_time():
    return 0 

distance = 10
time = 1

#time = get_time()
compute_speed(distance, time)

Result: 10.0

Docstrings#

Docstrings sind spezielle Kommentare, die am Anfang von Funktionen, Modulen oder Klassen (später) stehen und deren Zweck und Verwendung beschreiben. Sie werden in dreifachen Anführungszeichen (""") eingeschlossen und können über die help() Funktion oder die .__doc__ Eigenschaft abgerufen werden. Das ist besonders nützlich, wenn Code mit anderen geteilt wird. User können so schnell verstehen, was eine Funktion macht, ohne den Code selbst lesen zu müssen.

def add_numbers(num1, num2):
    """
    Add two numbers and return the result.

    Parameters:
    num1 (float): The first number to add.
    num2 (float): The second number to add.

    Returns:
    float: The sum of num1 and num2.
    """
    return num1 + num2

help(add_numbers)

Help on function add_numbers in module __main__:

add_numbers(num1, num2)
    Add two numbers and return the result.
    
    Parameters:
    num1 (float): The first number to add.
    num2 (float): The second number to add.
    
    Returns:
    float: The sum of num1 and num2.

Viele eingebaute Funktionen und Module haben Docstrings in Python.

help(print)

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

import random
help(random.randint)

Help on method randint in module random:

randint(a, b) method of random.Random instance
    Return random integer in range [a, b], including both end points.

Pfeilnotation (->)#

In Python kann man eine Pfeilnotation ähnlich zur mathematischen Schreibweise verwenden

  • Datentypen werden mit : angegeben

  • Der Rückgabewert wird mit -> angegeben

  • Diese Notation ist optional und wird vom Interpreter ignoriert

  • Die Notation ist mit benannten Parametern kombinierbar

User können diese Informationen über die .__annotations__ Eigenschaft der Funktion abrufen. Auch die help() Funktion zeigt diese Informationen an.

def mult_with_int(x : float, y : int = 10) -> float:
    return x * y

print(mult_with_int.__annotations__)
help(mult_with_int)

{'x': <class 'float'>, 'y': <class 'int'>, 'return': <class 'float'>}
Help on function mult_with_int in module __main__:

mult_with_int(x: float, y: int = 10) -> float
Contents