MicroPython: Module
Module in Python und MicroPython sind ähnlich wie in anderen Programmiersprachen Sammlungen von Funktionen, Klassen und Variablen, die in einer separaten Datei gespeichert sind und von anderen Dateien importiert werden können. Durch die Verwendung von Modulen kann der Code strukturierter und leichter zu warten sein, da Funktionen und Variablen in thematisch passende Einheiten organisiert werden können.
MicroPython hat einige integrierte Module, die nützliche Funktionen bereitstellen:
- machine: zum Zugriff auf Hardware-Ressourcen wie GPIOs und Schnittstellen.
- network: zum Konfigurieren und Verwalten von Netzwerkverbindungen.
- time: für die Arbeit mit Datum und Zeit.
- array: für die Arbeit mit Arrays von numerischen Daten.
- json: zum Kodieren und Dekodieren von Daten im JSON-Format.
- binascii: für die Konvertierung von Binärdaten in ASCII-Zeichen.
- cmath: für komplexe mathematische Funktionen.
- gc: für die Verwaltung des Speicherplatzes durch Garbage Collection.
- math: für mathematische Funktionen wie Sinus, Cosinus und Quadratwurzeln.
- os: für den Zugriff auf Betriebssystemfunktionen wie das Lesen von Dateien und das Arbeiten mit Ordnern.
- sys: für den Zugriff auf die Hardware.
Hinweis: Diese ist unvollständig.
Verwenden von Modulen und deren Funktionen und Methoden
Das Verwenden von Modulen erfolgt mit der import-Anweisung. Auf diese Weise integriert oder bindet man einen Programmcode aus einem externen Programmcode ein, dessen Klassen, Funktionen und Methoden man im eigenen Programmcode nutzen will.
Gib die folgenden Zeilen einzeln in die Kommandozeile ein:
import machine onboard_led = machine.Pin(25, machine.Pin.OUT) onboard_led.on()
Die Onboard-LED auf einem Raspberry Pi Pico wird dann leuchten.
In folgenden Beispiel gehen wir noch einen Schritt weiter und importieren die Funktion „Pin“ aus dem Modul „machine“. Das ist dann sinnvoll, wenn Du nicht jedes Mal den Namen des Moduls schreiben möchtest.
Gib die folgenden Zeilen einzeln in die Kommandozeile ein:
from machine import Pin onboard_led = Pin(25, Pin.OUT) onboard_led.on()
Mit Hilfe von „from“ kann man eine Funktion aus einem Modul direkt importieren.
Hinweis: Zur Lesbarkeit eines umfangreichen Programmcodes ist es empfehlenswert ohne „from“ zu arbeiten. Dadurch muss man zwar mehr schreiben, aber man sieht am Modul-Name vor einer Funktion, woher die Funktion kommt. Das ist auch aus einem zweiten Grund wichtig, weil der Name einer Funktion über mehrere importierte Module mehrfach vorkommen und dann zu Namenskollisionen führen kann.
Eigene Module erstellen
Module sind in Python und MicroPython gewöhnliche Dateien. Wir können also unsere eigenen Module schreiben und importieren. Der Name des Moduls ist gleichzeitig der Dateiname ohne die Dateiendung.
Um Module in MicroPython zu erstellen, muss nur eine neue Datei erstellen, die einfach importiert werden kann. Wenn Du ein Modul mit dem Namen „person“ erstellen willst, dann speicherst Du eine Datei mit dem Namen „person.py“. anschließend kannst Du die Datei als Modul mit „import“ importieren.
Speichere folgenden Programmcode in einer Datei mit dem Namen „person.py“.
class Person(object):
# Klassenattribut, gilt für alle Instanzen
art = "Homo Sapiens"
# Einfacher Konstruktor der Klasse
def __init__(self, name, gender):
# Zuweisung der Argumente zu Attributen der Instanz
self.name = name
self.gender = gender
# Instanzmethode, mit self als erstes Argument
def sagt(self, msg):
return "{name}: {message}".format(name=self.name, message=msg)
# Instanzmethode, mit self als erstes Argument
def getName(self):
return self.name
# Instanzmethode, mit self als erstes Argument
def getSex(self):
return self.gender
# Instanzmethode
def setSex(self, gender):
self.gender = gender
# Klassenmethode, wird von allen Instanzen geteilt
@classmethod
def getArt(cls):
return cls.art
# Statische Methode, wird ohne Instanz aufgerufen
@staticmethod
def hallo():
return "Hallo"
Speichere folgenden Programmcode im selben Verzeichnis mit einem beliebigen Dateinamen und führe ihn aus.
# Klasse "Person" von Modul "person" laden
from person import Person
# Zwei unterschiedliche Instanzen einer Klasse erstellen
herr = Person(name="Peter", gender="Mann")
dame = Person("Beate", "Frau")
# Klassenmethoden der Instand "herr" aufrufen
print(herr.sagt("Guten Tag"))
print('Geschlecht von', herr.getName(), ':', herr.getSex())
# Gemeinsames Attribut anzeigen
print('Art:', herr.getArt())
print()
# Klassenmethoden der Instand "dame" aufrufen
print(dame.sagt("Hallo"))
print('Geschlecht von', dame.getName(), ':', dame.getSex())
# Gemeinsames Attribut anzeigen
print('Art:', dame.getArt())
print()
# Attribut von Instanz "dame" ändern
dame.setSex("Divers")
print('Neues Geschlecht von', dame.getName(), ':', dame.getSex())
print()
# Gemeinsames Attribut ändern
Person.art = "Mensch"
print('Art:', herr.getArt())
print('Art:', dame.getArt())
print()
# Aufruf einer statischen Methode
print(Person.hallo())
Hinweis: Der Programmcode für das Modul und der Programmcode, der das Modul nutzt stammen aus der Beschreibung der Klassen.
Was kann ein Modul alles?
Im Optimalfall sind die Namen von Klassen, Methoden und Attributen in Modulen so gewählt, dass sie selbsterklärend sind. Wenn man also wissen will, was ein Modul alles kann, dann lässt sich das auf der Kommandozeile sehr leicht herausfinden.
import person dir(person)
Oft ist diese Ausgabe nicht detailliert genug. In diesem Fall enthält das Modul auch nur die Klasse „Person“. Wenn man mehr über diese Klasse, also Methoden und Attribute, erfahren möchte, dann muss man die Klasse explizit angeben.
dir(person.Person)
Weitere verwandte Themen:
- MicroPython: Funktionen
- MicroPython: Klassen
- MicroPython: Sprachstruktur
- Raspberry Pi Pico: Programmieren mit MicroPython
- Raspberry Pi Pico: MicroPython
Teilen:
Hardware-nahes Programmieren mit dem Raspberry Pi Pico und MicroPython
Das Elektronik-Set Pico Edition ist ein Bauteile-Sortiment mit Anleitung zum Experimentieren und Programmieren mit MicroPython.
- LED: Einschalten, ausschalten, blinken und Helligkeit steuern
- Taster: Entprellen und Zustände anzeigen
- LED mit Taster einschalten und ausschalten
- Ampel- und Lauflicht-Steuerung
- Elektronischer Würfel
- Eigene Steuerungen programmieren
Online-Workshop
Hardware-nahes Programmieren mit dem Raspberry Pi Pico
Gemeinsam mit anderen und unter Anleitung experimentieren? Wir bieten unterschiedliche Online-Workshops zum Raspberry Pi Pico und MicroPython an. Einführung in die Programmierung, Sensoren programmieren und kalibrieren, sowie Internet of Things und Smart Home über WLAN und MQTT.
Für Ihre Fragen zu unseren Online-Workshops mit dem Raspberry Pi Pico besuchen Sie unseren PicoTalk (Online-Meeting). (Headset empfohlen)
Elektronik-Set Pico Edition
Raspberry Pi Pico: Hardware-nahes Programmieren mit MicroPython
Leichter Einstieg mit All-in-one-Set zum sofort Loslegen, um eigene Steuerungen programmieren.
Elektronik-Set Pico WLAN Edition
Raspberry Pi Pico W: IoT und Smart Home mit WLAN und MQTT
Betreibe Deinen Raspberry Pi Pico W als drahtloser Sensor in Deinem WLAN, versende E-Mails mit Daten und kommuniziere per MQTT im Internet of Things oder Smart Home.
Elektronik-Set Sensor Edition
Erweiterung zu den Elektronik-Sets Pico Edition und Pico WLAN Edition
Elektronik-Set mit den beliebtesten Sensoren zum Messen von Temperatur, Helligkeit, Bewegung, Lautstärke und Entfernung.