Python-modules
Python-modules
In dit artikel leer je om aangepaste modules in Python te maken en te importeren. 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 dat Python-statements en -definities bevat.
Een bestand met Python-code, bijvoorbeeld:example.py , wordt een module genoemd en de modulenaam zou example . zijn .
We gebruiken modules om grote programma's op te splitsen in kleine overzichtelijke en overzichtelijke bestanden. Bovendien bieden modules herbruikbaarheid van code.
We kunnen onze meest gebruikte functies in een module definiëren en 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() in een module met de naam example . De functie neemt twee getallen in en geeft hun som terug.
Hoe modules in Python te importeren?
We kunnen de definities in een module importeren in een andere module of de interactieve interpreter in Python.
We gebruiken de import trefwoord om dit te doen. Om onze eerder gedefinieerde module example te importeren , typen we het volgende in de Python-prompt.
>>> import example
Dit importeert niet de namen van de functies gedefinieerd in example direct in de huidige symbooltabel. Het importeert alleen de modulenaam example daar.
Met behulp van de modulenaam hebben we toegang tot de functie met behulp van de punt . exploitant. Bijvoorbeeld:
>>> example.add(4,5.5)
9.5 Python heeft tonnen standaardmodules. U kunt de volledige lijst met Python-standaardmodules en hun gebruiksscenario's 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 onze door de gebruiker gedefinieerde modules.
Er zijn verschillende manieren om modules te importeren. Ze staan hieronder vermeld..
Python-importstatement
We kunnen een module importeren met behulp van de import statement en krijg toegang tot de definities erin met behulp van 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:
The value of 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 math . hernoemd module als m . Dit kan ons in sommige gevallen tijd besparen bij het typen.
Merk op dat de naam math wordt niet erkend in onze scope. Vandaar, math.pi is ongeldig, en m.pi is de juiste implementatie.
Python van...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 de pi . geïmporteerd attribuut van de math module.
In dergelijke gevallen gebruiken we de puntoperator niet. We kunnen ook als volgt meerdere attributen importeren:
>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045 Alle namen importeren
We kunnen alle namen (definities) uit een module importeren met 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 wiskundemodule geïmporteerd. Dit omvat alle namen die zichtbaar zijn in ons bereik, behalve de 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 naar verschillende plekken. Interpreter zoekt eerst naar een ingebouwde module. Dan (indien ingebouwde module niet gevonden), kijkt Python in een lijst met mappen gedefinieerd in sys.path . De zoekopdracht is in deze volgorde.
- De huidige map.
PYTHONPATH(een omgevingsvariabele met een lijst met mappen).- De installatieafhankelijke standaardmap.
>>> import sys >>> sys.path ['', 'C:\\Python33\\Lib\\idlelib', 'C:\\Windows\\system32\\python33.zip', 'C:\\Python33\\DLLs', 'C:\\Python33\\lib', 'C:\\Python33', 'C:\\Python33\\lib\\site-packages']
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 zou veranderen, zouden we hem opnieuw moeten 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() . gebruiken functie binnen de imp module 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
<module 'my_module' from '.\\my_module.py'> De ingebouwde dir()-functie
We kunnen de dir() . gebruiken functie om namen te vinden die in een module zijn gedefinieerd.
We hebben bijvoorbeeld een functie add() . gedefinieerd in de module example die we in het begin hadden.
We kunnen dir . gebruiken in example module op de volgende manier:
>>> 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).
Bijvoorbeeld de __name__ attribuut bevat de naam van de module.
>>> import example
>>> example.__name__
'example'
Alle namen die in onze huidige naamruimte zijn gedefinieerd, kunnen worden gevonden met behulp van de dir() functie zonder argumenten.
>>> a = 1
>>> b = "hello"
>>> import math
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'b', 'math', 'pyscripter'] Python