Kategorie: simple

Veröffentlicht am

Python strftime und strptime richtig verwenden

Python bietet mit strftime() und strptime() aus der datetime Standardbibliothek zwei nützliche Funktionen um mit Zeit-Strings arbeiten zu können, schauen wir uns an, wie wir sie richtig verwenden.

Mit strftime() Zeit-Strings erstellen

Mit Hilfe der strftime() Funktion (merke: string from time) erstellt man aus date, datetime und time Objekten einfache Strings. Dazu benötigt es nur einen sogenannten Format-String, der beschreibt, was in dem Zeit String enthalten sein soll. Damit erstellt man dann beliebige Strings, die z.B. in einer grafischen Oberfläche angezeigt werden können.

In einem einfachen Beispiel erzeugen wir zunächst ein datetime Objekt, also ein Objekt, das sowohl ein Datum als auch eine Uhrzeit enthält. Mit der strftime() Funktion und unterschiedlichen Format String erstellen wir dann verschiedene Strings, z.B. um für Menschen unterschiedlicher Herkunft ihre gewohnte Schreibweise zu erzeugen.

german_date_format = "%d.%m.%Y"
us_date_format = "%Y-%m-%d"
time_obj = datetime.datetime.now()
print(time_obj)
print(time_obj.strftime(german_date_format))
print(time_obj.strftime(us_date_format))
„Python strftime und strptime richtig verwenden“ weiterlesen
Veröffentlicht am

Python Listen erstellen und bearbeiten

Ein einfaches Array – Python List

Listen in Python zu erstellen und zu bearbeiten ist mit nur wenigen Schritten möglich. Deswegen zeige ich hier, wie es geht:

Erstellen einer Liste

Arrays bzw Listen können in Python ähnlich zu anderen Programmiersprachen benutzt werden. Eine Liste erstellt man mit Hilfe von eckigen Klammern. Die Werte einer Liste können unterschiedlichen Typs sein und werden per Komma getrennt.

>>> my_list = ['a', 'b', 1, 2, ['c', 3], {'key': 'value'}]

Unsere Liste enthält Strings und Integers, eine weitere Liste und auch ein Dictionary.

Zugriff auf Elemente einer Liste

Der Zugriff auf einzelne Elemente einer Liste kann über die genaue Angabe der Listenposition erfolgen. Diese Listenposition heißt Index. Ist das selektierte Element der Liste ebenso eine Liste, kann man erneut über den Index auf ein Element dieser zweiten Liste zugreifen.

>>> my_cars = ['Audi', 'Mercedes', 'BMW', ['VW Golf', 'VW Passat'], 'Ford']
>>> my_cars[3]
['VW Golf', 'VW Passat']

>>> my_cars[3][0]  
# returns the 1st element from the object 
# at index 3 of the my_cars list 
'VW Golf'
„Python Listen erstellen und bearbeiten“ weiterlesen
Veröffentlicht am

Python kwargs – Python Funktions Parameter

Python kwargs – keyword arguments

Python Funktionen enthalten in der Regel Parameter. Meistens werden neben den normalen Parametern auch Parameter, die einen Standardwert bzw default bereits in der Funktionsdefinition enthalten, benutzt.

Positionsgebunden oder über Schlüsselwort

Ein einfaches Beispiel:

def welcome(first_name, last_name="Last Name"):
    print(first_name, last_name)

Die Funktion welcome besitzt zwei Parameter: first_name und last_name

Der zweite Parameter last_name hat per Funktionsdefinition bereits einen Standardwert zugewiesen bekommen. Wird nun beim Funktionsaufruf das Argument für last_name weggelassen, so wird dem Parameter automatisch der Standartwert zugewiesen. Andernfalls benutzt der Interpreter das entsprechende Argument.

>>> welcome("Christian") 
Christian Last Name 
>>> welcome("Christian", last_name="Scholz") 
Christian Scholz
„Python kwargs – Python Funktions Parameter“ weiterlesen
Veröffentlicht am

Python Parameter Typen

Python Parameter Typen können seit der Version 3.5 in einer Funktion angegeben werden. Man kann also in der Funktion bereits definieren, dass ein Parameter z.B. vom Typ float ist. Genauso können auch die Rückgabewerte der Funktion definiert werden.

Ein einfaches Beispiel aus der aktuellen Python 3.7 Dokumentation zu Type aliases :

from typing import List
Vector = List[float]
 
def scale(scalar: float, vector: Vector) -> Vector:
    return [scalar * num for num in vector]
 
# typechecks; a list of floats qualifies as a Vector.
new_vector = scale(2.0, [1.0, -4.2, 5.4])

In dem oben geziegten Code Ausschnitt importieren wir zunächst den Typ ‚List‘. Diesen benutzen wir anschließend, um einen neuen Typ ‚Vector‘ zu definieren. Vector ist dabei ein Alias für eine Liste von float Werten.

„Python Parameter Typen“ weiterlesen
Veröffentlicht am

Das import Statement

Module importieren

Im Artikel über Scripte in Python sind wir bereits darüber gestolpert: das import Statement. Wir haben in diesem Script ein weiteres Script bzw „Modul“ importiert, und waren somit in der Lage auf Variablen und Funktionen dieses importierten Moduls zuzugreifen. Doch was passiert eigentlich genau wenn der Python Interpreter ein import Statement verarbeitet, und welche Varianten gibt es neben dem bereits verwendetem „import x“ weiterhin?

Eine Standard-Installation von Python bietet bereits eine Fülle von Modulen und Paketen mit denen ein Programmierer direkt starten kann. Ich werde hier ein paar dieser Standard-Module benutzen, um das import Statement näher zu erläutern. Eine Liste aller verfügbaren Module findet sich im Python Module Index.

Das es sich bei „import“ um ein Statement handelt, gibt es hier keine Klammern oder Anführungszeichen bei dem sich anschließenden Modulnamen. Genauso wenig gibt es hier Rückgabewerte. Der Modulname legt zudem zwei Dinge fest: zum einen das Modul, das gesucht und import werden soll, zum anderen den Variablennamen, unter dem das Modul nachfolgend angesprochen werden kann.

Im folgenden Code Stück wird das Modul „os“ (Miscellaneous operating system interfaces) importiert. „os“ ist nun der Name der Variable, die wir für den Zugriff auf Funktionen oder Attribute des importieren Moduls benutzen können. Wir rufen die Funktion „getcwd“ auf.

import os 
os.getcwd()
„Das import Statement“ weiterlesen
Veröffentlicht am

Scripte in Python #!/usr/bin/env python

Der Einstieg in Python

Oft kommt man mit Python in Kontakt wenn es zum Beispiel darum geht, sich wiederholende Aufgaben programmatisch zu automatisieren. Ich hatte in meiner Studienzeit die Aufgabe, Protein-Sequenzen von einer öffentlichen Quelle herunterzuladen und diese in die Datenbank meines Instituts einzupflegen. Hierfür eignen sich natürlich auch andere Programmiersprachen, aber in diesem Fall habe ich ein bereits existierendes Python Script eines Kollegen bekommen, und musste hier nur wenige Anpassungen machen, um die Aufgabe zu erledigen.

Python macht das Scripting sehr einfach, gerade weil die Sprache selbst soweit selbst-erklärend geschrieben werden kann, dass man als Neuling relativ schnell versteht, worum es geht und was passiert.

Ein großer Vorteil von Python ist, dass geschriebene Scripte direkt ausführbar sind und daher Code Anpassungen direkt sichtbar werden. Der Weg zum Ziel ist hier also recht kurz, und das ist oft einer der Hauptgründe auf Python zurückzugreifen.

Aufbau eines Scripts

Ein Python Script, welches in einem Terminal direkt ausgeführt werden kann, besteht aus nur wenigen Komponenten:

  1. optionale shebang line
  2. optionale encoding line
  3. Variablen & Funktionen
  4. Funktionsaufruf(e)
  5. optionale „main“ Prüfung
„Scripte in Python #!/usr/bin/env python“ weiterlesen
Veröffentlicht am

Python *args **kwargs – Funktionen mit variabler Parameter Anzahl

Parameter in Python

Meistens verwendet man in Funktionen und Methoden von Python eine ganz konkrete Anzahl von Parametern. Ich halte das für die verständlichste und sauberste Art und Weise eine Funktion zu beschreiben. Jemand der diese Funktionen benutzen möchte, weiß somit, wie diese konkret anzusprechen sind und im Idealfall, welche Typen bzw Objekte an welcher Position zu übergeben sind oder welche Parameter optional (default parameter values, bzw Standardparameter oder voreingestellter Parameter) übergeben werden können.

Hier findet man die genaue Definition für Parameter bzw Argumente: https://docs.python.org/3/glossary.html#term-argument

Ein einfaches Beispiel mit festen positionsbezogenen Parametern (positional arguments) und voreingestellten Parametern (keyword arguments):

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
 
def main(a_string, an_int, a_bool=True, a_float=1.0):
    """
    this is the main function, it combines all given parameters and prints its values
 
    :param a_string: a string parameter (as first argument)
    :param an_int: an integer parameter (as second argument)
    :param a_bool: an optional boolean parameter (as keyword argument)
    :param a_float: an optional float parameter (as keyword argument)
    """
    print(a_string, an_int, a_bool, a_float)
 
 
if __name__ == "__main__":
    main("only arguments", 1337)
    main("arguments and keywords", 1337, a_bool=False, a_float=1.23)
    main("arguments and keywords not sorted", 1337, a_float=1.23, a_bool=False)
    main("arguments and some keywords", 1337, a_float=2.34)
    main("argument and one argument keyworded", an_int=1337, a_bool=False)
    main(1337, "argument type does not matter", "T", False)
    main("this will fail")

Führt man dieses einfache Script aus, so ergibt sich folgende Ausgabe:

$ ./simple.py 
('only arguments', 1337, True, 1.0)
('arguments and keywords', 1337, False, 1.23)
('arguments and keywords not sorted', 1337, False, 1.23)
('arguments and some keywords', 1337, True, 2.34)
('argument and one argument keyworded', 1337, False, 1.0)
(1337, 'argument type does not matter', 'T', False)
Traceback (most recent call last):
  File "./simple.py", line 24, in <module>
    main("this will fail")
TypeError: main() takes at least 2 arguments (1 given)
„Python *args **kwargs – Funktionen mit variabler Parameter Anzahl“ weiterlesen
Veröffentlicht am

Kommentare in Python richtig verwenden

Kommentare richtig einsetzen

Kommentare sind in jeder Programmiersprache ein wichtiger Bestandteil. Sie erfüllen verschiedene Aufgaben, je nachdem wo sie eingesetzt werden. Es gibt Kommentare um Funktionen, Methoden oder Klassen zu beschreiben, aber auch Kommentare innerhalb eines Code-Blocks, die dazu dienen eine Stelle im Code näher zu erläutern.

In Python kann man auf verschiedene Weise einen Kommentar schreiben. Am einfachsten geht das mit dem # Zeichen gefolgt vom eigentlichen Kommentar, der sich in der gleichen Zeile anschließt.

# this is a simple comment, in only one line

Möchte man über mehrere Zeilen kommentieren, so kann man entweder in jeder Zeile ein # Zeichen setzen:

# comment starting in the first line 
# continues in the second 
# and maybe third?

oder aber man benutzt einen multiline-string, welcher mit drei Anführungszeichen eingeleitet und ebenso beendet wird:

""" this is a multi line comment 
to describe some more details """

Wie bereits angedeutet, werden die möglichen Kommentar Typen an unterschiedlichen Stellen im Code immer wieder verwendet.

Hier wird ein Line-Kommentar benutzt, um zu erklären, weshalb der nachfolgende Codeblock entsprechend aufgebaut ist:

# Make sure os.environ exists, at least
try:
    environ
except NameError:
    environ = {}

Es ist auch möglich einen Kommentar hinter einem Stück Code einzufügen, so kann man z.B. in einer Zeile den restlichen Code „ignorieren“ ohne ihn komplett entfernen zu müssen. Wir addieren die Variable b nur einmal, da der dritte Summand auskommentiert ist.

def calc(a, b):
    return a + b #+ b

Kommentare über mehrere Zeilen werden meist für die Dokumentation benutzt. Documentation-Strings oder kurz „docstrings“ schließen sich der Funktions- bzw Methodendefinition an.

def removedirs(name):
    """removedirs(name)

    Super-rmdir; remove a leaf directory and all empty intermediate
    ones.  Works like rmdir except that, if the leaf directory is
    successfully removed, directories corresponding to rightmost path
    segments will be pruned away until either the whole path is
    consumed or an error occurs.  Errors during this latter phase are
    ignored -- they generally mean that a directory was not empty.

    """
    rmdir(name)
    head, tail = path.split(name)
    if not tail:
        head, tail = path.split(head)
    while head and tail:
        try:
            rmdir(head)
        except OSError:
            break
        head, tail = path.split(head)

Hier findet man die PEP8 Definitionen zu Kommentaren.

„Kommentare in Python richtig verwenden“ weiterlesen