Python-Pakete: Erstellung, Verwaltung und Verteilung – Leitfaden für Einsteiger

1. Einführung

Die Bedeutung von Paketen in Python

Python-Pakete sind Sammlungen mehrerer Module und stellen einen wichtigen Mechanismus dar, der die Wiederverwendung und Verwaltung von Code erleichtert. Insbesondere in großen Projekten verbessert eine angemessene Strukturierung der Pakete die Lesbarkeit und Wartbarkeit des Codes.

Das Python-Ökosystem enthält bereits zahlreiche nützliche Pakete (Bibliotheken), aber durch das Erstellen eigener Pakete und deren Anwendung in Projekten wird eine flexiblere Entwicklung möglich.

Ziel und Überblick dieses Artikels

In diesem Artikel erklären wir detailliert die folgenden Inhalte zu Python-Paketen.

• Grundkonzepte und Struktur von Paketen
• Erstellung eigener Pakete
• Importieren von Paketen
• pip zur Paketverwaltung
• Veröffentlichung auf PyPI (Python Package Index)
• Häufige Fehler und deren Lösungen (FAQ)

Durch das Lesen dieses Guides können Sie Python-Pakete systematisch lernen und praktisch anwenden.

Zielgruppe

Dieser Artikel richtet sich an Personen wie folgt.

• Personen, die die Grundsyntax von Python verstehen und Erfahrung mit dem Erstellen einfacher Skripte oder Funktionen haben
• Personen, die Python-Projekte organisieren und wiederverwendbaren Code schreiben möchten
• Personen, die eigene Pakete erstellen und auf PyPI veröffentlichen möchten

Für diese Leser ist dieser Artikel so strukturiert, dass er das Verständnis von Python-Paketen vertieft und praktische Informationen bietet.

2. Was ist ein Paket in Python?

Unterschied zwischen Paket und Modul

In Python gibt es die Konzepte „Modul“ und „Paket“, um Code angemessen zu organisieren und die Wiederverwendbarkeit zu erleichtern.

• Modul (Module)
  Bezieht sich auf eine einzelne Python-Skriptdatei (.py-Datei). Zum Beispiel stellt eine solche Python-Datei ein Modul dar.

  # sample_module.py
  def greet():
      return "Hallo, Python!"

• Paket (Package)
  Ein Verzeichnis, das mehrere Module gruppiert, und enthält normalerweise eine __init__.py-Datei. Durch die Nutzung eines Pakets können mehrere Module organisiert und verwaltet werden.

  mypackage/
  ├── __init__.py
  ├── module1.py
  ├── module2.py

Unterschied zur Bibliothek

Der Begriff „Bibliothek“ wird ebenfalls häufig verwendet, aber eine Bibliothek ist ein breiteres Konzept, das Pakete und Module umfasst.
Konkret kann man eine Bibliothek als eine Sammlung von Paketen betrachten, die ein Toolset für spezifische Funktionen bereitstellt.

Zum Beispiel sind requests und numpy Pakete, während Bibliotheken wie SciPy oder Django Kombinationen aus mehreren Paketen sind.

Die Rolle von __init__.py

In einem Paketverzeichnis ist eine spezielle Datei namens __init__.py erforderlich. Durch das Vorhandensein dieser Datei erkennt Python das Verzeichnis als „Paket“.

Grundlagen von __init__.py

__init__.py kann leer sein, ohne Probleme, aber Sie können wie folgt Initialisierungen oder Hauptfunktionen des Pakets definieren.

# mypackage/__init__.py
from .module1 import greet

def welcome():
    return "Willkommen bei mypackage!"

Durch diese Einstellung können Sie, wenn Sie mypackage von außen importieren, die Funktion greet() direkt verwenden.

from mypackage import greet
print(greet())  # Hallo, Python!

Namespace-Pakete (Namespace Package)

Ab Python 3.3 werden „Namespace-Pakete (Namespace Package)“ unterstützt, die Pakete ohne __init__.py erkennen. Allerdings ist es aus Kompatibilitätsgründen üblich, __init__.py bereitzustellen.

Zusammenfassung

• Modul ist eine einzelne .py-Datei, während ein Paket eine Verzeichnisstruktur mit mehreren Modulen ist.
• Bibliothek ist eine Sammlung von Software, die Pakete und Module kombiniert.
• __init__.py ist notwendig zur Identifikation des Pakets und kann Initialisierungen oder bequeme Imports definieren.
• Ab Python 3.3 sind Pakete ohne __init__.py (Namespace-Pakete) möglich.

3. Methode zur Erstellung eines Python-Pakets

Grundlegende Verzeichnisstruktur eines Pakets

Python-Pakete funktionieren ordnungsgemäß, indem sie einer bestimmten Verzeichnisstruktur folgen. Hier ist ein Beispiel für die Verzeichnisstruktur eines einfachen Pakets.

mypackage/
├── __init__.py  # Datei zur Paketidentifikation
├── module1.py   # Modul 1
├── module2.py   # Modul 2
└── subpackage/  # Subpaket
    ├── __init__.py
    ├── submodule1.py
    └── submodule2.py

Rolle jeder Datei

• mypackage/ : Stammverzeichnis des Pakets
• __init__.py : Datei, die anzeigt, dass dieser Ordner ein Paket ist (ab Python 3.3 optional)
• module1.py, module2.py : Module im Paket
• subpackage/ : Subpaket (enthält weitere Module intern)

Erstellung und Rolle von __init__.py

__init__.py dient der Identifikation des Pakets und definiert Initialisierungsprozesse beim Importieren des Pakets.

Einfaches __init__.py

Schon die Erstellung einer leeren __init__.py wie unten reicht aus, um als Paket zu funktionieren.

# mypackage/__init__.py

Hinzufügen einer Paketinitialisierung zu __init__.py

Hier ist ein praktischeres Beispiel für __init__.py.

# mypackage/__init__.py
from .module1 import greet

def welcome():
    return "Willkommen bei mypackage!"

Mit dieser Einstellung wird beim Importieren des Pakets die greet()-Funktion verfügbar.

from mypackage import greet
print(greet())  # "Hallo, Python!"

Erstellung von Modulen und Subpaketen

Erstellung eines Moduls (module1.py)

Jedes Modul kann eigene Funktionen oder Klassen definieren.

# mypackage/module1.py
def greet():
    return "Hallo, Python!"

Erstellung eines Subpakets (subpackage/)

Durch die Erstellung eines Subpakets können Funktionen weiter unterteilt werden.

mypackage/
└── subpackage/
    ├── __init__.py
    ├── submodule1.py
    └── submodule2.py

Durch die Definition von Funktionen in der __init__.py des Subpakets wird der Import erleichtert.

# mypackage/subpackage/__init__.py
from .submodule1 import sub_function

def subpackage_greeting():
    return "Hallo aus dem Subpaket!"

Überprüfung des Paketverhaltens

Um das erstellte Paket zu testen, verwenden Sie die interaktive Python-Shell.

1. Zum übergeordneten Verzeichnis von mypackage navigieren

   cd path/to/your/package

2. Python-Shell öffnen

   python

3. mypackage importieren und Funktion ausführen

   import mypackage
   print(mypackage.welcome())  # "Willkommen bei mypackage!"

Zusammenfassung

• Python-Pakete bestehen aus einem Verzeichnis und __init__.py.
• __init__.py wird für die Paketidentifikation und Initialisierung verwendet.
• Module und Subpakete erleichtern die Organisation des Codes.
• Nach der Erstellung im Python-Shell testen, um die korrekte Funktionalität zu bestätigen.

4. Methode zum Importieren von Paketen

Import von Modulen in einem Paket

Beim Verwenden von Python-Paketen verwendet man normalerweise dieimport-Anweisung. Zum Beispiel nehmen wir an, es gibt eine solche Paketstruktur.

mypackage/
├── __init__.py
├── module1.py
├── module2.py
└── subpackage/
    ├── __init__.py
    ├── submodule1.py

Direkter Import von Modulen

Angenommen, inmodule1.py ist diegreet()-Funktion definiert.

# mypackage/module1.py
def greet():
    return "Hallo aus module1!"

Um diese Funktion zu verwenden, nutzt man dieimport-Anweisung wie folgt.

import mypackage.module1

print(mypackage.module1.greet())  # Hallo aus module1!

Import mit demfrom-Schlüsselwort

Für einen kompakteren Import kann man dasfrom-Schlüsselwort verwenden.

from mypackage.module1 import greet

print(greet())  # Hallo aus module1!

Unterschiede zwischen relativem und absolutem Import

In Python gibt es beim Importieren von Modulen in einem Paket zwei Methoden: relativer Import und absoluter Import.

Absoluter Import (Absolute Import)

Diese Methode spezifiziert den Pfad vom Root-Verzeichnis des Pakets aus.

# mypackage/module2.py
from mypackage.module1 import greet

def call_greet():
    return greet()

Der Vorteil dieser Methode ist die hohe Lesbarkeit und die klare Darstellung der Paketstruktur.

Relativer Import (Relative Import)

Diese Methode importiert andere Module basierend auf der Position des aktuellen Moduls. Mit. (Punkt) kann man auf andere Module im selben Paket verweisen.

# mypackage/module2.py
from .module1 import greet

def call_greet():
    return greet()

Beim relativen Import kann die Anzahl der.-Punkte verwendet werden, um die Hierarchie des übergeordneten Verzeichnisses anzugeben.

• from .module1 import greet → Importiert greet() aus module1.py im selben Paket
• from ..subpackage.submodule1 import some_function → Importiert some_function aus subpackage/submodule1.py aus einer Ebene höher

Relativer Import vs. Absoluter Import

Beim relativen Import kann einImportError auftreten, wenn das Skript außerhalb des Pakets ausgeführt wird. Daher wird in großen Projekten der absolute Import empfohlen.

Vereinfachung des Imports durch Nutzung von__init__.py

Durch das Definieren spezifischer Funktionen oder Klassen in__init__.py kann der Import des Pakets vereinfacht werden.

# mypackage/__init__.py
from .module1 import greet

Mit dieser Einstellung kann die Funktion in einfacher Form importiert werden.

from mypackage import greet

print(greet())  # Hallo aus module1!

Zusammenfassung

• Importmethoden für Module umfassen import und from ... import.
• Absoluter Import ist explizit und lesbar, kann aber lang sein.
• Relativer Import ist kurz, kann aber je nach Ausführungsmethode zu ImportError führen.
• Nutzung von__init__.py vereinfacht den Import des Pakets.

5. Verwaltung von Python-Paketen (Nutzung von pip)

pip zur Installation und Deinstallation von Paketen

In Python können externe Bibliotheken mit pip einfach installiert werden.
Vom offiziellen Python Package Index (PyPI) heruntergeladen und zur Umgebung hinzugefügt werden.

Installation des Pakets

Durch Ausführen des folgenden Befehls kann das angegebene Paket installiert werden.

pip install package_name

Zum Beispiel, um die requests-Bibliothek zu installieren:

pip install requests

Nach Abschluss der Installation kann in Python-Skripten mit import verwendet werden.

import requests

response = requests.get("https://example.com")
print(response.status_code)

Deinstallation des Pakets

Um unnötige Pakete zu entfernen, wird pip uninstall verwendet.

pip uninstall package_name

Als Beispiel, um requests zu deinstallieren:

pip uninstall requests

Beim Ausführen wird eine Bestätigung für die Deinstallation angefordert, geben Sie y ein, um zu löschen.

pip freeze und requirements.txt zur Umgebungsverwaltung

Um die Liste der in einem Projekt verwendeten Pakete zu teilen, ist es üblich, eine Datei namens requirements.txt zu erstellen.

Ausgabe der aktuellen Paketliste

Um die im Projekt installierten Pakete aufzulisten, wird der folgende Befehl verwendet.

pip freeze

Ausgabebeispiel:

requests==2.26.0
numpy==1.21.2
pandas==1.3.3

Durch Speichern dieser Liste in requirements.txt können dieselben Pakete in anderen Umgebungen einfach reproduziert werden.

pip freeze > requirements.txt

Massive Installation von Paketen aus requirements.txt

Beim Einrichten eines Projekts in einer anderen Umgebung können alle Pakete aus requirements.txt installiert werden.

pip install -r requirements.txt

Paketverwaltung in virtuellen Umgebungen (Verwendung von venv)

In Python ist es üblich, virtuelle Umgebungen (venv) zu verwenden, um unterschiedliche Paketumgebungen pro Projekt zu verwalten.
Mit virtuellen Umgebungen kann entwickelt werden, ohne die Paketeinstellungen des gesamten Systems zu beeinflussen.

Erstellen einer virtuellen Umgebung

Wechseln Sie in das Projektverzeichnis und erstellen Sie eine virtuelle Umgebung mit dem folgenden Befehl.

python -m venv myenv

Eine virtuelle Umgebung namens myenv/ wird erstellt, die die Python-Ausführungsumgebung enthält.

Aktivieren der virtuellen Umgebung

Um die erstellte virtuelle Umgebung zu verwenden, führen Sie den folgenden Befehl aus.

• Windows (PowerShell)

  myenvScriptsActivate

• Mac / Linux

  source myenv/bin/activate

Wenn die virtuelle Umgebung aktiviert ist, wird in der Kommandozeile etwas wie (myenv) angezeigt.

Paketverwaltung in der virtuellen Umgebung

In der virtuellen Umgebung können Pakete wie gewohnt mit pip installiert werden.

pip install flask

Um die virtuelle Umgebung zu beenden, führen Sie den folgenden Befehl aus.

deactivate

Versionsverwaltung von Paketen

Versionsüberprüfung installierter Pakete

Um die Versionen der derzeit installierten Pakete zu überprüfen, wird der folgende Befehl verwendet.

pip list

Oder, um detaillierte Informationen zu einem bestimmten Paket zu erhalten, wird pip show verwendet.

pip show package_name

Beispiel:

pip show numpy

Ausgabebeispiel:

Name: numpy
Version: 1.21.2
Summary: NumPy is the fundamental package for array computing with Python.

Pakete auf die neueste Version upgraden

Um ein bestehendes Paket auf die neueste Version zu aktualisieren, führen Sie den folgenden Befehl aus.

pip install --upgrade package_name

Zum Beispiel, um requests auf die neueste Version zu aktualisieren:

pip install --upgrade requests

Um alle Pakete auf einmal zu aktualisieren, wird der folgende Befehl verwendet.

pip list --outdated | awk '{print $1}' | xargs pip install --upgrade

（Hinweis: awk und xargs sind für Linux / Mac verfügbar）

Zusammenfassung

• Pakete mit pip install package_name installieren und mit pip uninstall package_name löschen.
• pip freeze > requirements.txt nutzen, um die Abhängigkeiten des Projekts leichter zu verwalten.
• Mit virtuellen Umgebungen (venv) unabhängige Umgebungen pro Projekt erstellen.
• Mit pip list die Versionen installierter Pakete überprüfen und mit pip install --upgrade aktualisieren.

6. Verteilungsmethode für Python-Pakete

Paketkonfiguration mit pyproject.toml

In Python wird es empfohlen, pyproject.toml zu verwenden, wenn Pakete erstellt und verteilt werden. In dieser Datei werden Metadaten des Pakets und Informationen zu Abhängigkeiten beschrieben.

Grundlegende Struktur von pyproject.toml

Erstellen Sie pyproject.toml im Root-Verzeichnis des Projekts und beschreiben Sie es wie folgt.

[build-system]
requires = ["setuptools", "wheel"]
build-backend = "setuptools.build_meta"
[project]

name = "mypackage" version = "0.1.0" description = "Mein Python-Paket" authors = [{ name = "Ihr Name", email = "your_email@example.com" }] license = { text = "MIT" } dependencies = ["requests", "numpy"]

Mit dieser Einstellung kann das Paket reibungslos gebaut und verteilt werden.

Paket-Erstellung mit setuptools

Um das Paket in eine verteilbare Form (sdist oder wheel) zu bringen, wird setuptools verwendet.

Vorbereitung des Pakets

Bereiten Sie eine Verzeichnisstruktur wie die folgende vor.

mypackage/
├── mypackage/
│   ├── __init__.py
│   ├── module1.py
│   ├── module2.py
├── pyproject.toml
├── README.md
└── LICENSE

• mypackage/: Der eigentliche Code des Pakets
• pyproject.toml: Die Konfigurationsdatei des Pakets
• README.md: Die Beschreibung des Pakets
• LICENSE: Lizenzinformationen

Bau des Pakets

Wechseln Sie im Terminal in das Root-Verzeichnis des Projekts und führen Sie den folgenden Befehl aus.

python -m build

Dadurch werden in das dist/-Verzeichnis eine .tar.gz-Datei (Source-Distribution) und eine .whl-Datei (Wheel) generiert.

dist/
├── mypackage-0.1.0-py3-none-any.whl
├── mypackage-0.1.0.tar.gz

Hochladen auf PyPI mit twine

Um das Paket auf PyPI zu veröffentlichen, wird twine verwendet.

Funktionstest mit TestPyPI

Es wird empfohlen, vor dem Hochladen in die Produktionsumgebung die Funktionalität des Pakets mit TestPyPI zu überprüfen.

Zuerst installieren Sie twine.

pip install twine

Anschließend laden Sie das Paket auf TestPyPI hoch.

python -m twine upload --repository testpypi dist/*

Um das Paket von TestPyPI zu installieren, verwenden Sie den folgenden Befehl.

pip install --index-url https://test.pypi.org/simple/ mypackage

Produktions-Upload auf PyPI

Nach der Überprüfung mit TestPyPI laden Sie es nun in die Produktionsumgebung, also PyPI, hoch.

python -m twine upload dist/*

Nach dem Upload können Sie das Paket auf der offiziellen PyPI-Website (https://pypi.org/) suchen und überprüfen, ob es veröffentlicht wurde.

Installation des Pakets von PyPI

Das veröffentlichte Paket kann mit dem folgenden Befehl installiert werden.

pip install mypackage

Zusammenfassung

• Es wird empfohlen, Paketinformationen mit pyproject.toml zu verwalten.
• Verwandeln Sie es mit python -m build in verteilbare Formate (sdist, whl).
• Nach der Funktionsüberprüfung mit twine auf TestPyPI laden Sie es auf PyPI hoch.
• Das veröffentlichte Paket kann mit pip install installiert werden.

7. Häufig gestellte Fragen (FAQ)

__init__.py ist zwingend erforderlich?

Q:__init__.pyist es zwingend erforderlich?A:Ab Python 3.3 wird es als Paket erkannt, auch ohne__init__.py, dank der Einführung der„Namespace-Pakete”.
Trotzdem ist es in vielen Projekten üblich, explizit eine__init__.py zu erstellen.

# mypackage/__init__.py

Durch das Hinzufügen dieser Datei können Sie die Initialisierungsprozesse des Pakets beschreiben und Imports vereinfachen.

Was ist der Unterschied zwischen relativen und absoluten Imports?

Q:Was ist der Unterschied zwischen relativen und absoluten Imports?A:In Python gibt es als Importmethoden zwischen Modulenabsolute Imports undrelative Imports als zwei Arten.

• Absoluter Import

  from mypackage.module1 import greet

• Da der Pfad vom Root-Verzeichnis explizit angegeben wird, ist die Paketstruktur leicht verständlich
• Hohe Lesbarkeit und geringere Fehleranfälligkeit
• Relativer Import

  from .module1 import greet

• Mithilfe von. (Punkt) werden Module im selben Paket referenziert
• Bei Ausführung außerhalb des Pakets kann einImportError auftreten

Gibt es Namenskonventionen für Pakete?

Q:Gibt es Regeln für die Benennung von Paketen und Modulen in Python?A:PEP8 (das offizielle Stilhandbuch von Python) empfiehlt folgende Namenskonventionen.

• Paketname → Kleinschreibung aller Wörter verwenden

  mypackage, utilities, datahandler

• Modulname → Kurze und verständliche Wörter in Kleinschreibung verwenden

  module1, parser, reader

Was ist die Rolle vonrequirements.txt?

Q:Wofür wirdrequirements.txt verwendet?A:requirements.txt listet die im Projekt verwendeten Pakete auf und wird verwendet, um die Reproduzierbarkeit der Umgebung zu gewährleisten.

Zur Erstellung führen Sie den folgenden Befehl aus.

pip freeze > requirements.txt

Um dieselben Pakete in einer anderen Umgebung zu installieren, führen Sie den folgenden Befehl aus.

pip install -r requirements.txt

Warum tretenModuleNotFoundError oderImportError auf?

Q:Was sind die Ursachen und Lösungen fürModuleNotFoundError oderImportError? Bitte erklären Sie.A:Diese Fehler treten auf, wenn Python das Modul oder Paket nicht richtig finden kann.

Lösung fürModuleNotFoundError

1. Paket installiert? Überprüfen

   pip list | grep package_name

2. Falls nicht installiert, mit pip install hinzufügen

   pip install package_name

Lösung fürImportError

1. Absoluten Import ausprobieren

   from mypackage.module1 import greet

2. Python-Ausführungsverzeichnis überprüfen

   import sys
   print(sys.path)

Warum kann ich nach dem Upload auf PyPI keinpip install durchführen?

Q:Ich habe das Paket auf PyPI hochgeladen, aberpip install funktioniert nicht. Was soll ich tun?A:Bitte überprüfen Sie die folgenden Punkte.

1. Upload erfolgreich? Überprüfen

   twine check dist/*

2. Richtigen Paketnamen angeben

   pip install mypackage

3. Auf PyPI-Reflektion warten

• Nach dem Upload kann es einige Minuten dauern, bis es auf PyPI reflektiert wird.

3. Falls auf TestPyPI hochgeladen

• pip install nicht, sondern --index-url angeben

   pip install --index-url https://test.pypi.org/simple/ mypackage

Zusammenfassung

• __init__.py ist ab Python 3.3 nicht zwingend erforderlich, aber es ist üblich, es hinzuzufügen.
• Absoluter Import ist lesbarer und fehlerärmer, daher empfohlen.
• Mit requirements.txt können Paketabhängigkeiten einfach verwaltet werden.
• ModuleNotFoundError oder ImportError können durch Überprüfung des Installationsstatus des Pakets und des Importpfads gelöst werden.

8. Zusammenfassung

Grundlegende Konzepte von Python-Paketen

• Modul ist eine einzelne .py-Datei, Paket ist ein Verzeichnis, das mehrere Module gruppiert.
• Bibliothek ist eine Sammlung von Software, die mehrere Pakete oder Module umfasst.
• __init__.py dient der Identifikation des Pakets und der Vereinfachung des Imports.

Erstellung von Python-Paketen

• Durch das Erstellen des Verzeichnisses mypackage/ und das Hinzufügen von __init__.py wird es als Paket erkannt.
• Module angemessen aufteilen und Code so gestalten, dass er leicht wiederverwendbar ist.
• Die Verwendung von absoluten Imports macht die Referenzierung von Modulen innerhalb des Pakets klarer.

Verwaltung von Paketen

• Pakete mit pip install package_name installieren und mit pip uninstall package_name deinstallieren.
• Mit pip freeze > requirements.txt wird es einfacher, die Projektumgebung zu reproduzieren.
• Mit python -m venv myenv eine virtuelle Umgebung erstellen und für jedes Projekt eine unabhängige Umgebung aufbauen.

Verteilung von Paketen

• Mit pyproject.toml die Metadaten des Pakets verwalten und in standardisierter Form aufbauen.
• Mit python -m build das Paket im dist/-Verzeichnis bauen.
• Mit twine die Funktionalität in TestPyPI überprüfen und bei Problemlosigkeit zu PyPI hochladen.
• Veröffentlichte Pakete können einfach mit pip install mypackage installiert werden.

Häufige Fehler und Maßnahmen

• Bei ModuleNotFoundError die Installation des Pakets oder die Einstellung von sys.path überprüfen.
• Bei ImportError anstelle von relativen Imports absolute Imports ausprobieren.
• Mit pip list --outdated die neuesten Versionen der Pakete überprüfen und bei Bedarf upgraden.

Best Practices für die Paketverwaltung in Python

1. Die Namenskonventionen für Pakete einhalten

• Einfache Namen in Kleinbuchstaben verwenden und auf Lesbarkeit achten.

1. Virtuelle Umgebungen (venv) nutzen

• Entwicklung unabhängig von der globalen Umgebung empfohlen.

1. requirements.txt stets verwalten

• Probleme bei Team-Entwicklung oder Deployment verhindern.

1. Vor der Veröffentlichung auf PyPI die Funktionalität in TestPyPI überprüfen

• Fehler im Voraus verhindern und Qualität gewährleisten.

Zusammenfassung und zukünftiges Lernen

Durch das Verständnis von Python-Paketen und ihre angemessene Verwaltung und Verteilung wird effiziente Entwicklung möglich.
Insbesondere durch das Design mit Fokus auf Wiederverwendbarkeit von Paketen und die Nutzung von virtuellen Umgebungen für den Entwicklungsstil können robustere Python-Projekte erstellt werden.

Im Folgenden können Sie durch das Lernen solcher Themen Ihr Verständnis weiter vertiefen.

• Fortgeschrittene Paketentwicklung (Hinzufügen benutzerdefinierter Skripte, Einführung von C-Erweiterungen)
• Automatische Paket-Deployment mit CI/CD
• Umgebungsbau in Kombination mit Docker

Ich hoffe, dass dieser Artikel hilfreich ist, um Python-Pakete effektiv zu nutzen.
Vielen Dank, dass Sie bis zum Ende gelesen haben!