Grundlagen in

Über Grundlagen

Python ist eine dynamisch und stark typisierte Programmiersprache. Sie verwendet sowohl Duck-Typing als auch graduelle Typisierung, und zwar über Type Hints. Imperative, deklarative (z. B. funktionale) und objektorientierte Programmier_stile_ werden alle unterstützt, aber intern ist in Python alles ein Objekt.

Python legt großen Wert auf die Lesbarkeit des Codes und verwendet (ähnlich wie Haskell) signifikante Einrückung, um Funktions-, Methoden- und Klassendefinitionen zu kennzeichnen.

Python wurde von Guido van Rossum entwickelt und 1991 erstmals veröffentlicht. Die Python Software Foundation verwaltet und lenkt die Ressourcen für die Entwicklung von Python und CPython und erhält Vorschläge für Änderungen an der Sprache von Mitgliedern der Community über Python Enhancement Proposals, kurz PEPs.

Die vollständige Dokumentation für die aktuelle Version findest du unter docs.python.org.

• Python-Tutorial
• Python-Bibliotheksreferenz
• Python-Sprachreferenz
• Python-HOWTOs
• Python-FAQs
• Python-Glossar der Begriffe

Dieses erste Konzept stellt 4 wichtige Sprachmerkmale von Python vor:

1. Namenszuweisung (Variablen und Konstanten),
2. Funktionen (das Schlüsselwort def und das Schlüsselwort return),
3. Kommentare und
4. Docstrings.

Namenszuweisung (Variablen und Konstanten)

In Python gibt es keine Schlüsselwörter, um Variablen oder Konstanten zu erstellen. Stattdessen können Programmierer Namen (auch Variablen genannt) mit dem Zuweisungsoperator = an jeden beliebigen Objekttyp binden: <name> = <value>. Ein Name kann im Laufe seines Bestehens neu zugewiesen (oder neu gebunden) werden, an verschiedene Werte (verschiedene Objekttypen).

Zum Beispiel kann my_first_variable viele Male mit = neu zugewiesen werden und kann bei jeder Neuzuweisung auf verschiedene Objekttypen verweisen:

>>> my_first_variable = 1  # my_first_variable bound to an integer object of value one.
>>> my_first_variable = 2  # my_first_variable re-assigned to integer value 2.

>>> print(type(my_first_variable))
<class 'int'>

>>> print(my_first_variable)
2

>>> my_first_variable = "Now, I'm a string." # <--You may re-bind a name to a different object type and value.
>>> print(type(my_first_variable))
<class 'str'>

>>> my_first_variable = 'You can call me "str".' # <--Strings can be declared using single or double quote marks.
>>> print(my_first_variable)
You can call me "str".

>>> import collections
>>> my_first_variable = collections.Counter([1,1,2,3,3,3,4,5,6,7]) # <--Now my_first_variable has been re-bound to a Counter object.
>>> print(type(my_first_variable))
<class 'collections.Counter'>

>>> print(my_first_variable)
Counter({3: 3, 1: 2, 2: 1, 4: 1, 5: 1, 6: 1, 7: 1})

Konstanten

Konstanten sind Namen, die in einem Programm nur einmal zugewiesen werden sollten. Sie sollten auf Modul-Ebene (Dateiebene) definiert werden und sind typischerweise für alle Funktionen und Klassen im Programm sichtbar. Die Verwendung von SCREAMING_SNAKE_CASE signalisiert, dass der Name nicht neu zugewiesen oder sein Wert nicht verändert werden sollte.

# All caps signal that this is intended as a constant.
MY_FIRST_CONSTANT = 16

# Re-assignment will be allowed by the compiler & interpreter,
# but this is VERY strongly discouraged.
# Please don't do this, it could create problems in your program!
MY_FIRST_CONSTANT = "Some other value"

Funktionen

In Python werden Funktionseinheiten in Funktionen gekapselt, die selbst Objekte sind (es ist Schildkröten bis ganz nach unten).

Funktionen können für sich allein ausgeführt, als Argumente an andere Funktionen übergeben, verschachtelt oder an eine Klasse gebunden werden. Wenn Funktionen an einen Klassen-Namen gebunden sind, bezeichnet man sie als Methoden. Verwandte Funktionen und Klassen (mit ihren Methoden) können in derselben Datei oder demselben Modul gruppiert und teilweise oder vollständig zur Verwendung in anderen Programmen importiert werden.

Das Schlüsselwort def beginnt eine Funktionsdefinition. Jede Funktion kann null oder mehr formale Parameter in den runden Klammern () haben, gefolgt von einem :-Doppelpunkt. Die Anweisungen für den Körper der Funktion beginnen in der Zeile nach def und müssen in einem Block eingerückt werden:

# The body of a function is indented by 2 spaces & prints the sum of the numbers.
def add_two_numbers(number_one, number_two):
  total = number_one + number_two
  print(total)  

>>> add_two_numbers(3, 4)
7


# Inconsistent indentation in your code blocks will raise an error.
>>> def add_three_numbers_misformatted(number_one, number_two, number_three):
...     result = number_one + number_two + number_three   # This was indented by 4 spaces.
...    print(result)     # <--This was only indented by 3 spaces.
...
...
  File "<stdin>", line 3
    print(result)
    ^
IndentationError: unindent does not match any outer indentation level

Funktionen geben über das Schlüsselwort return explizit einen Wert oder ein Objekt zurück:

# Function definition on first line, explicit return used on final line.
def add_two_numbers(number_one, number_two):
  return number_one + number_two   


# Calling the function in the Python shell returns the sum of the numbers.
>>> add_two_numbers(3, 4)
7

# Assigning the function call to a variable and printing 
# the variable will also return the value.
>>> sum_with_return = add_two_numbers(5, 6)
>>> print(sum_with_return)
11

Funktionen, bei denen auf ein return kein expliziter Ausdruck folgt, geben implizit das Objekt None zurück. Die Details von None werden in einem späteren Konzept behandelt. Für diese Übung und Erklärung ist None ein Platzhalter, der nichts, also null, repräsentiert:

# This function will return `None`
def square_a_number(number):
    square = number * number
    return # <-- note that this return is not followed by an expression

# Calling the function in the Python shell appears 
# to not return anything at all.
>>> square_a_number(2)
>>>


# Using print() with the function call shows that 
# the function is actually returning the **None** object.
>>> print(square_a_number(2))
None

Funktionen, die return weglassen, geben ebenfalls implizit das Objekt None zurück. Das bedeutet: Wenn du return nicht in einer Funktion verwendest, gibt Python das Objekt None für dich zurück.

# This function omits a return keyword altogether
def add_two_numbers(number_one, number_two):
  result = number_one + number_two

>>> add_two_numbers(5, 7)
>>> print(add_two_numbers(5, 7))
None

# Assigning the function call to a variable and printing 
# the variable will also show None.
>>> sum_without_return = add_two_numbers(5, 6)
>>> print(sum_without_return)
None

Funktionen aufrufen

Funktionen werden aufgerufen oder aufgerufen, indem ihr Name gefolgt von () verwendet wird. Die Punktnotation (.) wird verwendet, um Funktionen aufzurufen, die innerhalb einer Klasse oder eines Moduls definiert sind.

>>> def raise_to_power(number, power):
...     return number ** power
...

>>> raise_to_power(3,3) # Invoking the function with the arguments 3 and 3.
27


# A mis-match between the number of parameters and the number of arguments will raise an error.
>>> raise_to_power(4,)
...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: raise_to_power() missing 1 required positional argument: 'power'


# Calling methods or functions in classes and modules.
>>> start_text = "my silly sentence for examples."
>>> str.upper(start_text)  # <--Calling the upper() method from the built-in str class on start_text.
'MY SILLY SENTENCE FOR EXAMPLES.'

# Because a string is an instance of the str class, methods can also be called on them "directly".
>>> start_text = "my silly sentence for examples."
>>> start_text.upper()  # <--Calling the upper() method on start_text directly.
'MY SILLY SENTENCE FOR EXAMPLES.'

# Alternatively, we can skip the variable assignment (although this gets messy quick).
>>> "my silly sentence for examples.".upper()
'MY SILLY SENTENCE FOR EXAMPLES.'


# Importing the math module
>>> import math
>>> math.pow(2,4)  # <--Calling the pow() function from the math module.
16.0

Kommentare

Kommentare beginnen in Python mit einem #, das nicht Teil eines Strings ist, und enden am Zeilenende. Anders als viele andere Programmiersprachen unterstützt Python keine mehrzeiligen Kommentarzeichen. Jede Zeile eines Kommentarblocks muss mit dem Zeichen # beginnen.

Kommentare werden vom Interpreter ignoriert:

# This is a single line comment.

x = "foo"  # This is an in-line comment.

# This is a multi-line
# comment block over multiple lines --
# these should be used sparingly.

Docstrings

Die erste Anweisung eines Funktionskörpers kann optional ein Docstring sein, der den Zweck der Funktion oder des Objekts kurz zusammenfasst. Docstrings werden mit dreifachen doppelten Anführungszeichen (""") deklariert und auf derselben Ebene wie der Codeblock eingerückt:

# An example from PEP257 of a multi-line docstring
# reformatted to use Google style non-type hinted docstrings.
# Some additional details can be found in the Sphinx documentation:
# https://www.sphinx-doc.org/en/master/usage/extensions/napoleon.html#getting-started

def complex(real=0.0, imag=0.0):
    """Form a complex number.

    Keyword Arguments:
        real (float): The real part of the number (default 0.0)
        imag (float): The imaginary part of the number (default 0.0)
        
    """

    if imag == 0.0 and real == 0.0:
        return complex_zero

Docstrings werden von automatisierten Dokumentationswerkzeugen gelesen und zurückgegeben, wenn man das spezielle Attribut .__doc__ auf dem Funktions-, Methoden- oder Klassennamen aufruft. Sie werden für Programme jeder Größe empfohlen, in denen Dokumentation benötigt wird, und ihre Konventionen sind in PEP257 beschrieben.

Docstrings können auch als leichtgewichtige Unit-Tests dienen, die von PyTest oder durch Importieren des Moduls doctest gelesen und ausgeführt werden können. Tests und doctest werden in einem späteren Konzept behandelt.

# An example on a user-defined function using a Google style docstring. 
>>> def raise_to_power(number, power):
    """Raise a number to an arbitrary power.

    Parameters:
        number (int): The base number.
        power (int): The power to raise the base number to.
    
    Returns:
        int: The number raised to the specified power.
    
    Takes a number and raises it to the specified power, returning the result.

    """

    return number ** power
...

# Calling the .__doc__ attribute of the function and printing the result.
>>> print(raise_to_power.__doc__)
Raise a number to an arbitrary power.

Parameters:
    number (int): The base number.
    power (int): The power to raise the base number to.

Returns:
    int: The number raised to the specified power.

Takes a number and raises it to the specified power, returning the result.

...

# Printing the __doc__ attribute of the built-in type: str.
>>> print(str.__doc__)
str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or
errors is specified, then the object must expose a data buffer
that will be decoded using the given encoding and error handler.
Otherwise, returns the result of object.__str__() (if defined)
or repr(object).
encoding defaults to 'utf-8'.
errors defaults to 'strict'.