In dit artikel leert u aangepaste modules maken en importeren in Python. Ook vindt u verschillende technieken om aangepaste en ingebouwde modules in Python te importeren en te gebruiken.
Video: Python-modules
Wat zijn modules in Python?
Modules verwijzen naar een bestand met Python-instructies en definities.
Een bestand met Python-code, bijvoorbeeld example.py:, wordt een module genoemd en de modulenaam zou example.
We gebruiken modules om grote programma's op te splitsen in kleine beheersbare en georganiseerde bestanden. Bovendien bieden modules herbruikbaarheid van code.
We kunnen onze meest gebruikte functies in een module definiëren en deze importeren, in plaats van hun definities naar verschillende programma's te kopiëren.
Laten we een module maken. Typ het volgende en sla het op als example.py.
# Python Module example def add(a, b): """This program adds two numbers and return the result""" result = a + b return result
Hier hebben we een functie gedefinieerd add()binnen een module met de naam example. De functie neemt twee getallen op en geeft hun som terug.
Hoe modules importeren in Python?
We kunnen de definities in een module importeren naar een andere module of naar de interactieve interpreter in Python.
Hiervoor gebruiken we het importtrefwoord. Om onze eerder gedefinieerde module te importeren example, typen we het volgende in de Python-prompt.
>>> import example
Hiermee worden de namen van de functies die zijn gedefinieerd in niet examplerechtstreeks in de huidige symbolentabel geïmporteerd . Het importeert exampledaar alleen de modulenaam .
Met behulp van de modulenaam hebben we toegang tot de functie met behulp van de puntoperator .. Bijvoorbeeld:
>>> example.add(4,5.5) 9.5
Python heeft tonnen standaardmodules. Je kunt de volledige lijst met Python-standaardmodules en hun use-cases bekijken. Deze bestanden bevinden zich in de Lib-map op de locatie waar u Python hebt geïnstalleerd.
Standaardmodules kunnen op dezelfde manier worden geïmporteerd als we onze door de gebruiker gedefinieerde modules importeren.
Er zijn verschillende manieren om modules te importeren. Ze staan hieronder vermeld …
Python-importinstructie
We kunnen een module importeren met behulp van de importinstructie en toegang krijgen tot de definities erin met de puntoperator zoals hierboven beschreven. Hier is een voorbeeld.
# import statement example # to import standard module math import math print("The value of pi is", math.pi)
Wanneer u het programma uitvoert, is de uitvoer:
De waarde van pi is 3,141592653589793
Importeren met hernoemen
We kunnen een module importeren door deze als volgt te hernoemen:
# import module by renaming it import math as m print("The value of pi is", m.pi)
We hebben de mathmodule hernoemd naar m. Dit kan ons in sommige gevallen tijd besparen.
Merk op dat de naam mathniet wordt herkend in ons bereik. Daarom math.piis het ongeldig en m.piis het de juiste implementatie.
Python from… import-instructie
We kunnen specifieke namen uit een module importeren zonder de module als geheel te importeren. Hier is een voorbeeld.
# import only pi from math module from math import pi print("The value of pi is", pi)
Hier hebben we alleen het piattribuut uit de mathmodule geïmporteerd .
In dergelijke gevallen gebruiken we de puntoperator niet. We kunnen ook meerdere attributen als volgt importeren:
>>> from math import pi, e >>> pi 3.141592653589793 >>> e 2.718281828459045
Importeer alle namen
We kunnen alle namen (definities) uit een module importeren met behulp van de volgende constructie:
# import all names from the standard module math from math import * print("The value of pi is", pi)
Hier hebben we alle definities uit de wiskundige module geïmporteerd. Dit omvat alle namen die zichtbaar zijn in ons bereik, behalve namen die beginnen met een onderstrepingsteken (privédefinities).
Alles importeren met het asterisk-symbool (*) is geen goede programmeerpraktijk. Dit kan leiden tot dubbele definities voor een identifier. Het belemmert ook de leesbaarheid van onze code.
Zoekpad voor Python-module
Tijdens het importeren van een module kijkt Python op verschillende plaatsen. De tolk zoekt eerst naar een ingebouwde module. Vervolgens (als de ingebouwde module niet wordt gevonden), kijkt Python naar een lijst met mappen die zijn gedefinieerd in sys.path. De zoekopdracht is in deze volgorde.
- De huidige directory.
PYTHONPATH(een omgevingsvariabele met een lijst met mappen).- De installatie-afhankelijke standaardmap.
>>> import sys >>> sys.path ('', 'C: \ Python33 \ Lib \ idlelib', 'C: \ Windows \ system32 \ python33.zip', 'C: \ Python33 \ DLL's ',' C: \ Python33 \ lib ',' C: \ Python33 ',' C: \ Python33 \ lib \ site-pakketten ')
We kunnen deze lijst toevoegen en wijzigen om ons eigen pad toe te voegen.
Een module opnieuw laden
De Python-interpreter importeert een module slechts één keer tijdens een sessie. Dit maakt de zaken efficiënter. Hier is een voorbeeld om te laten zien hoe dit werkt.
Stel dat we de volgende code hebben in een module met de naam my_module.
# This module shows the effect of # multiple imports and reload print("This code got executed")
Nu zien we het effect van meerdere importen.
>>> import my_module This code got executed >>> import my_module >>> import my_module
We kunnen zien dat onze code maar één keer is uitgevoerd. Dit wil zeggen dat onze module maar één keer is geïmporteerd.
Als onze module in de loop van het programma is gewijzigd, moeten we deze opnieuw laden. Een manier om dit te doen is door de interpreter opnieuw te starten. Maar dit helpt niet veel.
Python biedt een efficiëntere manier om dit te doen. We kunnen de reload()functie binnen de impmodule gebruiken om een module opnieuw te laden. We kunnen het op de volgende manieren doen:
>>> import imp >>> import my_module This code got executed >>> import my_module >>> imp.reload(my_module) This code got executed
De ingebouwde functie dir ()
We kunnen de dir()functie gebruiken om namen te achterhalen die binnen een module zijn gedefinieerd.
We hebben bijvoorbeeld een functie gedefinieerd add()in de module exampledie we in het begin hadden.
We kunnen dirin examplemodule op de volgende manier gebruiken:
>>> dir(example) ('__builtins__', '__cached__', '__doc__', '__file__', '__initializing__', '__loader__', '__name__', '__package__', 'add')
Hier kunnen we een gesorteerde lijst met namen zien (samen met add). Alle andere namen die beginnen met een onderstrepingsteken, zijn standaard Python-attributen die aan de module zijn gekoppeld (niet door de gebruiker gedefinieerd).
Het __name__attribuut bevat bijvoorbeeld de naam van de module.
>>> import example >>> example.__name__ 'example'
Alle namen die in onze huidige naamruimte zijn gedefinieerd, kunnen dir()zonder argumenten worden achterhaald met de functie.
>>> a = 1 >>> b = "hello" >>> import math >>> dir() ('__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter')
