26. Bibliotheken und Module

../../_images/library.png

Eine Bibliothek ist eine Sammlung von Code für Funktionen und Klassen. Häufig werden diese Bibliotheken von einer anderen Person geschrieben und in das Projekt eingefügt, damit der Programmierer das Rad nicht neu erfinden muss. In Python nennt man die Bibliothek auch Modul.

Durch die Verwendung von import arcade und import random haben die bisher erstellten Programme bereits Module verwendet. Eine Bibliothek kann aus mehreren Modulen bestehen, die importiert werden können. Häufig besteht eine Bibliothek nur aus einem Modul, sodass diese Wörter manchmal synonym verwendet werden können.

Module sind häufig in Gruppen mit ähnlicher Funktionalität organisiert. In diesem Kurs haben Programme bereits Funktionen aus dem math-Modul, dem random-Modul und der arcade-Bibliothek verwendet. Module können so organisiert werden, dass einzelne Module andere Module enthalten. Zum Beispiel enthält das arcade-Modul Submodule für arcade.key und arcade.color.

Module werden nur geladen, wenn das Programm sie dazu auffordert. Dies spart Zeit und Arbeitsspeicher. In diesem Kapitel erfährst du, wie man ein Modul erstellt und dieses Modul importiert und verwendt.

26.1. Warum sollte man eine Bibliothek erstellen?

Es gibt drei wichtige Gründe für einen Programmierer, seine eigenen Bibliotheken zu erstellen:

  1. Es zerlegt den Code in kleinere, einfacher zu verwendende Teile.

  2. Dadurch können mehrere Personen gleichzeitig an einem Programm arbeiten.

  3. Der geschriebene Code kann problemlos mit anderen Programmierern geteilt werden.

Einige der Programme, die bereits in diesem Buch erstellt wurden, sind schon ziemlich lang. Indem man ein großes Programm in mehrere kleinere Programme aufteilen, kann man den Programmcode einfacher verwalten. Beispielsweise könnte ein Programmierer im Sprite-Beispiel des vorherigen Kapitels die Sprite-Klasse in eine separate Datei verschieben. In einem komplexen Programm kann jedes Sprite in einer eigenen Datei enthalten sein.

Wenn mehrere Programmierer an demselben Projekt arbeiten, ist dies nahezu unmöglich, wenn sich der gesamte Programmcode in einer Datei befindet. Durch Aufteilen des Programms in mehrere Teile wird es jedoch einfacher. Ein Programmierer könnte an der Entwicklung einer „Orc“-Sprite-Klasse arbeiten. Ein anderer Programmierer könnte an der Sprite-Klasse „Goblin“ arbeiten. Da sich die Sprites in separaten Dateien befinden, treten bei den Programmierern keine Konflikte auf.

Moderne Programmierer erstellen Programme selten von Grund auf neu. Oft werden Programme aus Teilen anderer Programme erstellt, die die gleiche Funktionalität haben. Wenn ein Programmierer Code erstellt, der ein Hypothekenantragsformular verarbeiten kann, wird dieser Code idealerweise in eine Bibliothek verschoben. Dann kann jedes andere Programm, das ein Hypothekenantragsformular bei dieser Bank verwalten muss, diese Bibliothek aufrufen.

26.2. Erstellen Ihrer eigenen Modul- / Bibliotheksdatei

Video: Bibliotheken

In diesem Beispiel werden wir ein kurzes Programm in mehrere Dateien aufteilen. Hier haben wir eine Funktion in einer Datei namens test.py und einen Aufruf dieser Funktion:

test.py mit allem drin
1
2
3
4
5
6
7
8
9
# Foo function
def foo():
    print("foo!")

def main():
    # Foo call
    foo()

main()

Ja, dieses Programm ist nicht zu lang, um in einer Datei zu sein. Wenn jedoch sowohl die Funktion als auch der Hauptprogrammcode lang wären, wäre dies anders. Wenn wir mehrere Funktionen mit jeweils 100 Zeilen Länge hätten, wäre es zeitaufwändig, diese große Datei zu verwalten. In diesem Beispiel wird der Code jedoch aus Gründen der Übersichtlichkeit kurz gehalten.

Wir können die Funktion foo aus dieser Datei heraus verschieben. Dann würde diese Datei nur den Hauptprogrammcode enthalten. (In diesem Beispiel gibt es keinen Grund, sie aus dem Hauptprogrammcode heraus zu holen, außer zu lernen, wie man das macht.)

Erstellen Sie dazu eine neue Datei und kopieren Sie die Funktion foo hinein. Speichern Sie die neue Datei unter dem Namen my_functions.py. Die Datei muss im selben Verzeichnis wie test.py gespeichert werden.

my_functions.py
1
2
3
# Foo function
def foo():
    print("foo!")
test.py die nicht funktioniert
1
2
3
4
5
def main():
    # Foo call that doesn't work
    foo()

main()

Leider ist es nicht so einfach. Die Datei test.py weiß nicht, dass sie die Funktion foo in der Datei my_functions.py findet und sie importieren muss. Wir müssen eine Anweisung hinzufügen, um das Modul zu importieren:

test.py die importiert, aber immer noch nicht funktioniert
1
2
3
4
5
6
7
8
# Import the my_functions.py file
import my_functions

def main():
    # Foo call that still doesn't work
    foo()

main()

Das geht immer noch nicht. Was fehlt uns? Genau wie beim Import von arcade müssen wir den Paketnamen vor die Funktion stellen. Wie folgt:

test.py die endlich funktioniert
1
2
3
4
5
6
7
8
# Import the my_functions.py file
import my_functions

def main():
    # Foo call that does work
    my_functions.foo()

main()

Dies funktioniert, weil my_functions. vor dem Funktionsaufruf steht.

26.3. Namensräume

Video: Namensraum

Ein Programm verfügt möglicherweise über zwei Bibliotheksdateien, die verwendet werden müssen. Was passiert, wenn die Bibliotheken Funktionen hätten, die den gleichen Namen haben? Was passiert, wenn es zwei Funktionen mit dem Namen print_report gibt, eine, die Noten ausgibt, und eine, die einen Kontoauszug ausgibt? Zum Beispiel:

student_functions.py
1
2
def print_report():
    print("Student Grade Report:" )
financial_functions.py
1
2
def print_report():
    print("Financial Report:" )

Wie kann ein Programm angeben, welche Funktion aufgerufen werden soll? Das ist ziemlich einfach. Sie geben den Namensraum an. Der Namensraum ist der Teil, der vor dem Funktionsnamen im folgenden Code angezeigt wird:

test.py, das verschiedene print_report-Funktionen aufruft
1
2
3
4
5
6
7
8
import student_functions
import financial_functions

def main():
    student_functions.print_report()
    financial_functions.print_report()

main()

Jetzt können wir verstehen, warum dies nötig sein könnte. Was aber, wenn es keine Namenskollisionen gibt? Das Eingeben eines Namensraums jedes Mal kann mühsam sein. Man kann dies umgehen, indem man die Bibliothek in den lokalen Namensraum importiert. Der lokale Namensraum ist eine Liste von Funktionen, Variablen und Klassen, denen kein Namensraum vorangestellt werden muss. Um zum Beispiel foo zurückzukehren, entfernen wir den ursprünglichen Import und ersetzen ihn durch einen neuen Importtyp:

test.py
1
2
3
4
5
6
7
# import foo
from my_functions import *

def main():
    foo()

main()

Dies funktioniert auch ohne das my_functions., das dem Funktionsaufruf vorangestellt werden. Das Sternchen ist ein Platzhalter, der alle Funktionen aus my_functions importiert. Ein Programmierer kann bei Bedarf einzelne importieren, indem er den Funktionsnamen angibt.

26.4. Bibliotheken von Drittanbietern

Bei der Arbeit mit Python können viele in Python integrierte Bibliotheken verwendet werden. Schaue dir alle hier verfügbaren Bibliotheken an:

http://docs.python.org/3/py-modindex.html

Es ist möglich, weitere Bibliotheken herunterzuladen und zu installieren. Es gibt Bibliotheken, die mit dem Internet arbeiten, komplexe Zahlen, Datenbanken und mehr.

Mit Jupyter kann man Analysen durchführen und sein eigenes interaktives Notizbuch erstellen:

Einige Bibliotheken, für die wir in diesem Kapitel Beispiele angeben:

Eine wunderbare Liste von Python-Bibliotheken und Links zu Installationsprogrammen für sie finden Sie hier:

Du kannst dir einige Top-Pakete/Bibliotheken und eigenständige Projekte anschauen, um eine Vorstellung davon zu bekommen, was du erreichen kannst. Es gibt viele Artikel wie Top 15 Python Libraries for Data Science in 2017.

26.4.1. Beispiele: OpenPyXL Library

In diesem Beispiel wird eine Bibliothek mit dem Namen OpenPyXL zum Schreiben einer Excel-Datei verwendet. Es ist auch einfach, aus einer Excel-Datei zu lesen. Du kannst OpenPyXL über die Windows-Eingabeaufforderung installieren, indem du pip install openpyxl eingibst. Wenn du auf einem Mac oder Linux-Computer arbeitest, kannst du sudo pip3 install openpyxl eingeben.

Bemerkung

Beim Starten der Eingabeaufforderung musst du möglicherweise mit der rechten Maustaste darauf klicken und „Als Administrator ausführen“ auswählen, wenn bei der Installation Berechtigungsfehler auftreten. Und wenn du an einem Schulrechner arbeitest, bist du möglicherweise nicht berechtigt, Bibliotheken zu installieren.

openpyxl_example.py
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
"""
Example using OpenPyXL to create an Excel worksheet
"""

from openpyxl import Workbook
import random

# Create an Excel workbook
work_book = Workbook()

# Grab the active worksheet
work_sheet = work_book.active

# Data can be assigned directly to cells
work_sheet['A1'] = "This is a test"

# Rows can also be appended
for i in range(200):
    work_sheet.append(["Random Number:", random.randrange(1000)])

# Save the file
work_book.save("sample.xlsx")

Die Ausgabe dieses Programms ist eine Excel-Datei:

../../_images/excel_example.png

26.4.2. Beispiele: Beautiful Soup Bibliothek

In diesem Beispiel werden Informationen von einer Webseite abgerufen. Du kannst Beautiful Soup über die Windows-Eingabeaufforderung installieren, indem du pip install bs4 eingeben. Wenn du auf einem Mac- oder Linux-Computer arbeitest, kannst du sudo pip3 install bs4 eingeben.

bs4_example.py
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
"""
Example showing how to read in from a web page
"""

from bs4 import BeautifulSoup
import urllib.request

# Read in the web page
url_address = "http://simpson.edu"
page = urllib.request.urlopen(url_address)

# Parse the web page
soup = BeautifulSoup(page.read(), "html.parser")

# Get a list of level 1 headings in the page
headings = soup.findAll("h1")

# Loop through each row
for heading in headings:
    print(heading.text)

26.4.3. Beispiele: Matplotlib

Hier ist ein Beispiel dafür, was man mit der Drittanbieter-Bibliothek „Matplotlib“ machen kann. Du kannst Matplotlib über die Windows-Eingabeaufforderung installieren, indem du pip install matplotlib eingibst. Wenn du auf einem Mac- oder Linux-Computer arbeitest, kannst du pip3 install matplotlib eingeben.

26.4.3.1. Beispiel 1: Einfaches Diagramm

Zunächst ist hier der Code zum Erstellen eines einfachen Liniendiagramms mit vier Werten:

../../_images/matplotlib_01.png

Einfaches Liniendiagramm

Beispiel 1
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
"""
Line chart with four values.
The x-axis defaults to start at zero.
"""
import matplotlib.pyplot as plt

y = [1, 3, 8, 4]

plt.plot(y)
plt.ylabel('Element Value')
plt.xlabel('Element Number')

plt.show()

Beachte, dass man das Diagramm vergrößern, schwenken und speichern kann. Man kann das Diagramm sogar in Vektorformaten wie ps und svg speichern, die ohne Qualitätsverlust in Dokumente importiert werden, wie dies bei Raster-Grafiken der Fall wäre.

26.4.3.2. Beispiel 2: Geben Sie x-Werte an

Der x-Wert für Beispiel 1 beginnt standardmäßig bei Null. Man kann diese Standardeinstellung ändern und die eigenen x-Werte angeben, die zu den y-Werten passen. Siehe das Beispiel 2 unten:

../../_images/matplotlib_02.png

Angabe der x-Werte

Beispiel 2
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
"""
Line chart with four values.
The x-axis values are specified as well.
"""
import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y = [1, 3, 8, 4]

plt.plot(x, y)

plt.ylabel('Element Value')
plt.xlabel('Element')

plt.show()

26.4.3.3. Beispiel 3: Hinzufügen einer zweiten Datenreihe

Es ist trivial, dem Diagramm eine weitere Datenreihe hinzuzufügen.

../../_images/matplotlib_03.png

Zwei Datenreihen graphisch darstellen

Beispiel 3
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
"""
This example shows graphing two different series
on the same graph.
"""
import matplotlib.pyplot as plt

x =  [1, 2, 3, 4]
y1 = [1, 3, 8, 4]
y2 = [2, 2, 3, 3]

plt.plot(x, y1)
plt.plot(x, y2)

plt.ylabel('Element Value')
plt.xlabel('Element')

plt.show()

26.4.3.4. Beispiel 4: Legende hinzufügen

Man kann dem Diagramm eine Legende hinzufügen:

../../_images/matplotlib_04.png

Legende hinzufügen

Beispiel 4
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import matplotlib.pyplot as plt

x =  [1, 2, 3, 4]
y1 = [1, 3, 8, 4]
y2 = [2, 2, 3, 3]

plt.plot(x, y1, label = "Series 1")
plt.plot(x, y2, label = "Series 2")

legend = plt.legend(loc='upper center', shadow=True, fontsize='x-large')
legend.get_frame().set_facecolor('#00FFCC')

plt.ylabel('Element Value')
plt.xlabel('Element')

plt.show()

26.4.3.5. Beispiel 5: Hinzufügen von Anmerkungen

Man kann einem Diagramm Anmerkungen hinzufügen:

../../_images/matplotlib_05.png

Anmerkungen hinzufügen

Beispiel 5
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
"""
Annotating a graph
"""
import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y = [1, 3, 8, 4]

plt.annotate('Here',
             xy = (2, 3),
             xycoords = 'data',
             xytext = (-40, 20),
             textcoords = 'offset points',
             arrowprops = dict(arrowstyle="->",
                               connectionstyle="arc,angleA=0,armA=30,rad=10"),
             )

plt.plot(x, y)

plt.ylabel('Element Value')
plt.xlabel('Element')

plt.show()

26.4.3.6. Beispiel 6: Ändern von Linienstilen

Mag man die Standard-Linienstile für das Diagramm nicht? Dies kann durch Hinzufügen eines dritten Parameters zum Zeichenbefehl geändert werden.

../../_images/matplotlib_06.png

Festlegen des Linienstils

Beispiel 6
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
"""
This shows how to set line style and markers.
"""
import matplotlib.pyplot as plt

x =  [1, 2, 3, 4]
y1 = [1, 3, 8, 4]
y2 = [2, 2, 3, 3]

# First character: Line style
# One of '-', '--',  '-.', ':', 'None', ' ', "

# Second character: color
# http://matplotlib.org/1.4.2/api/colors_api.html

# Third character: marker shape
# http://matplotlib.org/1.4.2/api/markers_api.html

plt.plot(x, y1, '-ro')
plt.plot(x, y2, '--g^')

plt.ylabel('Element Value')
plt.xlabel('Element')

plt.show()

26.4.3.7. Beispiel 7: Balkendiagramm

Ein Balkendiagramm bekommt man einfach durch Ändern von plot in bar.

../../_images/matplotlib_07.png

Balkendiagramm

Beispiel 7
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
"""
How to do a bar chart.
"""
import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y = [1, 3, 8, 4]

plt.bar(x, y)

plt.ylabel('Element Value')
plt.xlabel('Element')

plt.show()

26.4.3.8. Beispiel 8: Achsenbeschriftungen

Man kann an die Achsen Beschriftungen hinzufügen.

../../_images/matplotlib_08.png

X-Achsenbeschriftungen

Beispiel 8
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
"""
How to add x axis value labels.
"""
import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y = [1, 3, 8, 4]

plt.plot(x, y)

labels = ['Frogs', 'Hogs', 'Bogs', 'Slogs']
plt.xticks(x, labels)

plt.ylabel('Element Value')
plt.xlabel('Element')

plt.show()

26.4.3.9. Beispiel 9: Diagrammfunktionen

Man kann auch Funktionen graphisch darstellen. Hierbei wird ein anderes Paket namens numpy verwendet, um eine Sinusfunktion graphisch darzustellen.

../../_images/matplotlib_09.png

Eine Sinusfunktion grafisch darstellen

Beispiel 9
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
"""
Using the numpy package to graph a function over
a range of values.
"""
import numpy
import matplotlib.pyplot as plt

x = numpy.arange(0.0, 2.0, 0.001)
y = numpy.sin(2 * numpy.pi * x)

plt.plot(x, y)

plt.ylabel('Element Value')
plt.xlabel('Element')

plt.show()

26.4.3.10. Beispiel 10: Diagrammfunktionen mit Füllung

Man kann ein Diagramm ausfüllen, wenn man möchte.

../../_images/matplotlib_10.png

Ein Diagramm ausfüllen

Beispiel 10
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
"""
Using 'fill' to fill in a graph
"""
import numpy
import matplotlib.pyplot as plt

x = numpy.arange(0.0, 2.0, 0.001)
y = numpy.sin(2 * numpy.pi * x)

plt.plot(x, y)

# 'b' means blue. 'alpha' is the transparency.
plt.fill(x, y, 'b', alpha=0.3)

plt.ylabel('Element Value')
plt.xlabel('Element')

plt.show()

26.4.3.11. Beispiel 11: Tortendiagramm

Erstellen eines Tortendiagramms.

../../_images/matplotlib_11.png

Tortendiagramm

Beispiel 11
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
"""
Create a pie chart
"""
import matplotlib.pyplot as plt

# Labels for the pie chart
labels = ['C', 'Java', 'Objective-C', 'C++', 'C#', 'PHP', 'Python']

# Sizes for each label. We use this to make a percent
sizes = [17, 14, 9, 6, 5, 3, 2.5]

# For list of colors, see:
# https://matplotlib.org/examples/color/named_colors.html
colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral', 'darkcyan', 'aquamarine', 'rosybrown']

# How far out to pull a slice. Normally zero.
explode = (0, 0.0, 0, 0, 0, 0, 0.2)

# Set aspect ratio to be equal so that pie is drawn as a circle.
plt.axis('equal')

# Finally, plot the chart
plt.pie(sizes, explode=explode, labels=labels, colors=colors,
        autopct='%1.1f%%', shadow=True, startangle=90)

plt.show()

26.4.3.12. Beispiel 12: Candlestick-Chart

Man kann wirklich ausgefallene Dinge tun, zum Beispiel Bestandsdaten aus dem Web abrufen und ein Candlestick-Diagramm des Börsenkurse von Apple Computer erstellen:

../../_images/matplotlib_12.png

Candlestick-Chart

Beispiel 12
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
"""
Create a candlestick chart for a stock
"""
import matplotlib.pyplot as plt
from matplotlib.dates import DateFormatter, WeekdayLocator,\
     DayLocator, MONDAY
from matplotlib.finance import quotes_historical_yahoo_ohlc, candlestick_ohlc

# Grab the stock data between these dates
date1 = (2014, 10, 13)
date2 = (2014, 11, 13)

# Go to the web and pull the stock info
quotes = quotes_historical_yahoo_ohlc('AAPL', date1, date2)
if len(quotes) == 0:
    raise SystemExit

# Set up the graph
fig, ax = plt.subplots()
fig.subplots_adjust(bottom=0.2)

# Major ticks on Mondays
mondays = WeekdayLocator(MONDAY)
ax.xaxis.set_major_locator(mondays)

# Minor ticks on all days
alldays = DayLocator()
ax.xaxis.set_minor_locator(alldays)

# Format the days
weekFormatter = DateFormatter('%b %d')  # e.g., Jan 12
ax.xaxis.set_major_formatter(weekFormatter)
ax.xaxis_date()

candlestick_ohlc(ax, quotes, width=0.6)

ax.autoscale_view()
plt.setp(plt.gca().get_xticklabels(), rotation=45, horizontalalignment='right')

plt.show()

Es gibt noch viele andere Dinge, die mit matplotlib erledigt werden können. Schau dir die Thumbnail-Galerie an:

http://matplotlib.org/gallery.html