Python List Comprehension erstellen

Im folgenden Beitrag erkläre ich Python List Comprehension als Methode um Listen effektiv und mit wenig Code zu erstellen. Grundlage bilden hierbei immer andere iterierbare Objekte, wie Listen oder Dictionaries.

Wie man durch Listen iterieren kann oder auf Elemente einer Liste zugreift, erkläre ich im Artikel Python Listen erstellen und bearbeiten

List Comprehension erstellen

Eine List Comprehensionist immer eine Liste, die einen Ausdruck, eine Schleife und gegebenenfalls mehrere weitere Schleifen oder Bedingungen enthält.

Ein einfaches Beispiel, in dem die Werte der ursprünglichen Liste mit 2 multipliziert werden:

>>> numbers = [1,2,3,4,5,6]
>>> numbers_times_2 = [x*2 for x in numbers]
>>> numbers_times_2
[2, 4, 6, 8, 10, 12]

„Python List Comprehension erstellen“ weiterlesen

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

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

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

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

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

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

Kommentare in Python

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 = {}

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“ weiterlesen

einfach python

Python möglichst einfach erklärt

Dieses wordpress Blog ist mein neuestes Projekt und befasst sich mit der Programmiersprache Python. Mit kleinen kurzen Beiträgen möchte ich die Sprache Neulingen in der Programmierung näher bringen, aber auch mal alten Programmierhasen oder Quereinsteigern ein paar A-ha Effekte entlocken.

Ausschließlich in deutscher Sprache

Das Blog ist bewusst in Deutsch gehalten. Natürlich ist die Sprache der Wahl in der Programmierung Englisch, aber ich denke, dass es gerade für Einsteiger beim Lesen von How-To’s und Tutorials in englischer Sprache oft Verständnisproblem gibt. Mir ging und geht es zum Teil manchmal immer noch so. Außerdem möchte ich das Netz nicht noch zusätzlich mit grammatikalisch nicht ganz flüssigem Englisch füllen, das haben andere schon zu oft erledigt.

Zu meinen Artikeln werde ich zusätzlich noch weiterführende Links angeben, in denen man sich dann noch tiefgreifender mit dem ein oder anderen Thema beschäftigen kann.

Ich hoffe, dass dieses Blog und die kommenden Artikel dem ein oder anderen weiterhelfen und freue mich immer über Kommentare, positive wie auch kritische. Zu lernen haben wir alle immer etwas…

Viel Spaß beim Lesen und Stöbern,

Christian