En nybörjarguide för att skapa och använda paket i Python

Föreställ dig den skrämmande uppgiften att utveckla en omfattande applikation begränsad till en enda Python-fil. Även om det är tekniskt genomförbart, går det emot kärnprinciperna för att bygga effektiv, underhållsbar och återanvändbar programvara. Av sådana skäl är paket och moduler viktiga för att bygga och utveckla mjukvara.

Vad är ett paket?

I Python ger ett paket ett sätt att organisera logiskt relaterade moduler och resurser tillsammans. Det är en katalog som innehåller flera Python-moduler, underpaket och andra resurser.

Paket tillhandahåller en hierarkisk struktur, så att du kan organisera ditt projekts kod på olika abstraktionsnivåer.

Skillnaden mellan paket och moduler

Även om du kan använda både paket och moduler för att organisera kod, finns det skillnader mellan dem:

  • Modul: En modul är en fil som innehåller Python-kod. Den definierar funktioner, klasser, variabler och andra objekt som du kan importera och använda i din kod.
  • Paket: Ett paket är en samling av en eller flera moduler och kan även innehålla underpaket.

Hur man skapar ett paket i Python

Följ dessa steg för att skapa ett paket.

Steg 1: Skapa en projektkatalog

Börja med att skapa en projektkatalog.

 study_bud/

Steg 2: Skapa en paketkatalog

Inuti din projektkatalog, skapa en annan katalog som kommer att fungera som paketkatalogen. Ge det ett meningsfullt namn som representerar paketets syfte eller funktion. Paketkatalogen kommer att innehålla modulerna och underpaketen relaterade till ditt paket.

 study_bud/
    math_tool/

Steg 3: Definiera paketet __init__.py-filen

Skapa en __init__.py-fil i paketkatalogen. Närvaron av filen __init__.py är det som gör katalogen till ett paket i Python.

Om du behöver initiera en kod när du använder paketet, inkludera den i filen __init__.py annars är den alltid tom.

 study_bud/
    math_tool/
        __init__.py

Steg 4: Lägg till moduler till paketet

Lägg till Python-moduler (.py) i paketkatalogen som definierar funktioner, klasser eller variabler.

Dessa moduler innehåller den faktiska koden som ger ditt pakets funktionalitet. Du kan skapa flera moduler i paketkatalogen.

 study_bud/
    math_tool/
        __init__.py
        operations.py
        statistics.py

Steg 5: Lägg till underpaket till paketet

Om ditt paket behöver ha en hierarkisk struktur eller innehåller distinkta funktioner kan du skapa underpaket i paketkatalogen.

Ett underpaket är helt enkelt en annan paketkatalog i huvudpaketkatalogen. Varje underpaket bör ha sin __init__.py-fil. Underpaket möjliggör ytterligare organisation och separation av kod.

 study_bud/
    math_tool/
        __init__.py
        operations.py
        statistics.py
        geometry/
            __init__.py
            shapes.py
        calculus/
            __init__.py
            integrations.py

I dessa steg har du skapat ett math_tool-paket, lagt till två moduler (operations.py och statistics.py) och två underpaket geometri och kalkyl med var och en av sina moduler.

Genom att följa dessa steg kan du enkelt organisera relaterad funktionalitet med hjälp av ett paket och underpaket, vilket gör det lättare att hantera och återanvända kod.

Hur man arbetar med ett paket i Python

För att arbeta med ett paket måste du importera det. Nyckelorden import och från låter dig importera och använda ett paket i din kod.

 import math_tool 

Du kan också använda punktnotationen för att importera moduler, underpaket eller specifika egenskaper från ett paket. Punktnotationen låter dig navigera genom paketkatalogstrukturen. Punktnotering gör dina importer mer läsbara och lättare att underhålla.

 from math_tool.operations import add, multiply 

I koden ovan navigerade du från paketkatalogen (math_tool) till operationsmodulen med hjälp av punktnotationen och importerade två funktioner (lägg till och multiplicera).

Absolut import vs. relativ import

Med absoluta importer anger du hela sökvägen från toppnivåpaketet (rotpaketet) till önskad modul eller underpaket. Detta är det vanligaste och mest rekommenderade sättet att importera moduler och paket i Python.

 from math_tool.geometry.shapes import parallelogram

Börja med math_tool och gå in i underpaketet geometri, hitta shapes.py-modulen och importera parallellogramfunktionen.

Medan relativa importer kan du göra importer i förhållande till den aktuella modulens plats med hjälp av punktnotationen för att specificera relativa importer.

Inuti modulen calculus/integrations.py kan du till exempel använda relativ import för att importera en funktion från shapes.py-modulen i underpaketet geometri.

 
from ..geometry.shapes import rhombus

Dubbelpunkten (”..”) säger till Python att:

  • Börja från underpaketskatalogen (kalkyl) där modulen (integrations.py) finns.
  • Gå in i katalogen överordnat paket (math_tool) för underpaketet.
  • Hitta underpaketet för geometri i den överordnade katalogen.
  • Gå in i shapes.py-modulen och importera rhombus från den.

Så punktnotationen representerar antalet kataloger att navigera till från den aktuella modulkatalogen.

Alias ​​import för bekvämlighet

Du kan tilldela ett alias till en import vilket gör det lättare att referera till i din kod. Alias ​​är praktiskt när man har att göra med långa paket- eller modulnamn.

Använd nyckelordet som för att tilldela ett alias.

 import math_tool.calculus as cal

Hur du distribuerar ditt paket i Python

Python ger dig verktyg och en plattform för att bygga och distribuera ditt paket. Genom att distribuera ditt paket kan du dela din kod med andra utvecklare, främja samarbete, förenkla installationen för användare och bidra till den bredare Python-gemenskapen.

Steg 1: Skapa ett konto på PyPI

Python-paketindex (PyPI) är standardförrådet för Python-paket. Du kan publicera dina paket på PyPI så att andra utvecklare enkelt kan hitta och installera dem.

Se till att komma ihåg ditt användarnamn och lösenord eftersom du behöver dem för autentisering när du laddar upp ditt paket till PyPI.

Steg 2: Installera pakethanteringsverktyg

Dessa verktyg gör det enkelt för dig att konfigurera, bygga och skicka ett distribuerbart paket i ett enda kommando.

 pip install build wheel twine

Steg 3: Skapa en setup.py-fil

För att distribuera ditt paket, skapa en filen setup.py i ditt projekts rotkatalog. Filen setup.py innehåller metadata om ditt paket, såsom dess namn, version, författare, beskrivning, beroenden och mer.

Pakethanteringsverktygen kommer att använda filen setup.py för att konfigurera och bygga ditt paket.

 
from setuptools import setup, find_packages

setup(
    name="<package name>",
    version='1.0.0',
    author="<Your Name>",
    description='A collection of mathematical utility functions',
    packages=find_packages(),
    install_requires=[
        'numpy',
        'scipy',
    ],
)

Steg 4: Bygg paketet

När du har filen setup.py redo kan du använda den för att bygga ett distribuerbart paket. I din terminal eller kommandotolk, navigera till katalogen som innehåller filen setup.py och kör följande kommando:

 python setup.py sdist bdist_wheel

Detta kommando genererar en dist-katalog som innehåller ett källdistributionspaket (.tar.gz) och ett hjuldistributionspaket (.whl). Du kommer också att se en bygg- och informationskatalog.

Steg 5: Ladda upp paketet till PyPI

Med ditt paket redo kan du ladda upp det till PyPI.

Kör följande kommando:

 twine upload dist/*
> Uploading distributions to https://upload.pypi.org/legacy/
> Enter your username: **********
> Enter your password: **********

Besök din PyPI projektledningssida för att se ditt paket.

Nu kan andra utvecklare som tycker att ditt paket är användbart installera och använda det lokalt.

Hur man installerar ett Python-paket

Pakethanterare som pip gör det enkelt att installera och hantera Python-paket från olika källor, inklusive Python Package Index (PyPI). För att installera ett paket med pip, öppna din terminal eller kommandotolk och använd följande kommando:

 pip install <package_name>

För att se alla tillgängliga kommandon och alternativ för pip, använd alternativet –help.

Att skriva rena moduler

Paket innehåller moduler och delpaket som i sin tur innehåller andra moduler. Det är en bra praxis att modularisera din kod, särskilt när du arbetar med större projekt, eftersom det främjar bättre kodorganisation och läsbarhet. Så det är viktigt att skriva moduler med tydlighet när du utvecklar med Python.