Importera modul in Python med exempel
Anna Blake
Vad är modulerna i Python?
En modul är en fil med pythonkod. Koden kan vara i form av variabler, funktioner eller klassdefinierade. Filnamnet blir modulnamnet.
Till exempel, om ditt filnamn är guru99.py, kommer modulnamnet att vara guru99. Med modulfunktionalitet kan du dela upp din kod i olika filer istället för att skriva allt i en fil.
Vad är det Python importera modul?
En fil betraktas som en modul i python. För att använda modulen måste du importera den med hjälp av importen nyckelord. Funktionen eller variablerna som finns i filen kan användas i en annan fil genom att importera modulen. Denna funktion är tillgänglig på andra språk, som typskript, JavaScript, java, ruby, etc.
Hur man skapar och importerar en modul i Python?
Nu ska vi skapa en modul och importera den i en annan fil.
Här är flödet för att skapa och importera modulen som visas på skärmdumpen:
Följ stegen för att skapa en modul i python.
Mappstrukturen som används för att testa koden är följande:
modtest/ test.py display.py
Steg 1) Skapa en fil och namnge den test.py
Steg 2) Inuti test.py skapa en funktion som heter display_message()
Def display_message():
return "Welcome to Guru99 Tutorials!"
Steg 3) Skapa nu en annan fil display.py.
Steg 4) Inside display.py importera moduletest.py-filen, som visas nedan:
import test
När du importerar behöver du inte nämna test.py utan bara namnet på filen.
Steg 5) Sedan kan du anropa funktionen display_message() från test.py inuti display.py, du måste använda modulnamn.funktionsnamn.
Till exempel test.display_message().
Import test print(test.display_message())
Steg 6) När du kör display.py får du följande Produktion:
Welcome to Guru99 Tutorials!
Importera en klass i Python
Tidigare har vi sett en enkel modul med en funktion. Här kommer att skapa en klass och hänvisa klassen till en annan fil.
Mappstrukturen för att testa koden är som följer:
myproj/ Car.py display.py
Skapa en fil som heter Car.py med följande kod:
Filnamn: Car.py
class Car:
brand_name = "BMW"
model = "Z4"
manu_year = "2020"
def __init__(self, brand_name, model, manu_year):
self.brand_name = brand_name
self.model = model
self.manu_year = manu_year
def car_details(self):
print("Car brand is ", self.brand_name)
print("Car model is ", self.model)
print("Car manufacture year is ", self.manu_year)
def get_Car_brand(self):
print("Car brand is ", self.brand_name)
def get_Car_model(self):
print("Car model is ", self.model)
I filen Car.py finns attributen brand_name, model och manu_year. Funktionerna som definieras i klassen är car_details(), get_Car_brand(), get_Car_model().
Låt oss nu använda filen Car.py som en modul i en annan fil som heter display.py.
Filnamn: display.py
import Car
car_det = Car.Car("BMW","Z5", 2020)
print(car_det.brand_name)
print(car_det.car_details())
print(car_det.get_Car_brand())
print(car_det.get_Car_model())
Produktion:
BMW Car brand is BMW Car model is Z5 Car manufacture year is 2020 Car brand is BMW Car model is Z5
Så vi kan komma åt alla variabler och funktioner från Car.py med hjälp av bilmodulen.
Använder från till importmodul
Du kan bara importera en liten del av modulen, dvs bara de nödvändiga funktionerna och variabelnamnen från modulen istället för att importera fullständig kod.
När du vill att endast specifika saker ska importeras kan du använda nyckelordet "från" för att importera det du vill ha.
Så syntaxen är
from module import your function_name , variables,... etc.
Mappstrukturen som används för att testa koden är följande:
modtest/ test.py display.py
I test.py finns det 2 funktioner som visas:
Filnamn: test.py
defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Nu vill du ha display_message() funktion. Funktionen eller variabeln som du importerar kan nås direkt enligt nedan:
Filnamn: display.py
from test import display_message print(display_message())
Produktion:
Welcome to Guru99 Tutorials!
Om du nu råkar använda funktionen display_message1() kommer det att ge ett felmeddelande om att funktionen inte är definierad som visas nedan:
from test import display_message print(display_message1())
Produktion:
Traceback (most recent call last): File "display.py", line 3, in <module> print(display_message1()) Name Error: name 'display_message1' is not defined
Importerar allt från modulen
Import låter dig importera hela modulen genom att använda import följt av modulnamn, dvs. filnamnet eller biblioteket som ska användas.
Syntax:
Import module
Eller genom att använda
from module import *
Mappstrukturen som används för att testa koden är följande:
modtest/ test.py display.py
Följande är koddetaljerna inuti test.py
my_name = "Guru99" my_address = "Mumbai" defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Använder importmodulen
Genom att bara använda importera modulnamn, för att referera till variablerna och funktionerna inuti modulen, måste den prefixa med modulnamn.
Exempelvis
Filnamn: display.py
Import test print(test.display_message()) print(test.display_message1()) print(test.my_name) print(test.my_address)
Modulnamnstestet används för att referera till funktionen och variablerna i modultestet.
Produktion:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Använder import *
Låt oss se ett exempel med hjälp av importera *, Använda importera *, är funktionerna och variablerna direkt tillgängliga, som visas i exemplet nedan:
from test import * print(display_message()) print(display_message1()) print(my_name) print(my_address)
Produktion:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Funktionen dir( ).
Dir() är en inbyggd funktion i python. Dir() returnerar alla egenskaper och metoder, inklusive det givna objektets inbyggda egenskaper.
Så när dir() används på modulen kommer det att ge dig variablerna, funktioner som finns inuti modulen.
Här är ett fungerande exempel på dir() på en modul. Vi har en klass som heter Car.py, låt oss importera Car och tilldela till dir() för att se utdata.
Mappstrukturen för att testa koden kommer att vara följande:
test prop/ Car.py test.py
Filnamn: Car.py
class Car:
brand_name = "BMW"
model = "Z4"
manu_year = "2020"
def __init__(self, brand_name, model, manu_year):
self.brand_name = brand_name
self.model = model
self.manu_year = manu_year
def car_details(self):
print("Car brand is ", self.brand_name)
print("Car model is ", self.model)
print("Car manufacture year is ", self.manu_year)
def get_Car_brand(self):
print("Car brand is ", self.brand_name)
def get_Car_model(self):
print("Car model is ", self.model)
Filnamn: test.py
import Car class_contents = dir(Car) print(class_contents)
Utdatan ger oss namnet på klassen och alla funktioner definierade i Car.py.
Du kan också prova att använda dir() på en inbyggd modul tillgänglig i Python. Låt oss prova samma sak json modul som visas i exemplet nedan. Det kommer att visa alla egenskaper och metoder som finns tillgängliga i json modul.
Import json json_details = dir(json) print(json_details)
Produktion:
['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__bu iltins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__pac kage__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_en coder', 'codecs', 'decoder', 'detect_encoding', 'dump', 'dumps', 'encoder', 'loa d', 'loads', 'scanner']
Paket
Ett paket är en katalog med alla moduler definierade i den. Att göra en Python tolk behandla det som ett paket, din katalog bör ha init.pyfile. Init.py gör katalogen som ett paket. Här är layouten på paketet som vi ska arbeta med.
Namnet på paketet är mitt paket. För att börja arbeta med paketet, skapa en katalog som heter package/. Inuti katalogen skapar du en tom fil som heter __init__.py. Skapa ytterligare 3 filer module1.py, module2.py och module3.py och definiera funktionerna som visas på skärmdumpen. Här är informationen om modul1.py, modul2.py och modul3.py
module1.py
def mod1_func1():
print("Welcome to Module1 function1")
def mod1_func2():
print("Welcome to Module1 function2")
def mod1_func3():
print("Welcome to Module1 function3")
module2.py
def mod2_func1():
print("Welcome to Module2 function1")
def mod2_func2():
print("Welcome to Module2 function2")
def mod2_func3():
print("Welcome to Module2 function3")
module3.py
def mod3_func1():
print("Welcome to Module3 function1")
def mod3_func2():
print("Welcome to Module3 function2")
def mod3_func3():
print("Welcome to Module3 function3")
Ocuco-landskapet paketär redo att användas. Ring nu paketet inuti någon av dina filer som visas nedan :test.py:
Här importeras mypackage.module1 och får ett aliasnamn som mod1. På samma sätt kan du använda andra moduler module2.py och module3.py från mitt paket.
import mypackage.module1 as mod1 print(mod1.mod1_func1()) print(mod1.mod1_func2()) print(mod1.mod1_func2())
Produktion:
Welcome to Module1 function1 None Welcome to Module1 function2 None Welcome to Module1 function2 None
Vi har precis demonstrerat paketet med en enkel modul med funktioner inuti. Enligt ditt projekt kan du också paketera med underpaket. Undermappar/ med moduler med definierade klasser.
Python Sökväg för modul
Under utförande, när python stöter på importmodulens namn, försöker tolken hitta modulen. Den söker igenom modulen i den inbyggda modullistan. Later totalt sett katalogerna definierade i sys.path.
Sammanfattningsvis gör tolken följande sökning för att hitta modulen:
- I din nuvarande katalog.
- In i listan över inbyggda moduler
- Inuti sys.path-katalogerna
Du kan få information om sys.path genom att importera sys-modulen och skriva ut sys.path. Det kommer att ge dig listan över kataloger som visas nedan:
importsys print(sys.path)
Produktion:
['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\ \Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\P ython37\\DLLs']
Du kan också ändra sökvägen och behålla katalogerna enligt dina krav.
Använder modulalias i importen
Du kan också konvertera modulnamnet till en kortare form genom att ge det ett alias. Aliaset kan göras med hjälp av nyckelordet.
Syntax:
import filename as alias name
Mappstrukturen för att testa koden kommer att vara följande:
Mod test/ test.py display.py
Följande är koden inuti test.py
my_name = "Guru99" my_address = "Mumbai" def display_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Nu kommer att använda ett alias för test.py i display.py
Import test as t print(t.display_message()) print(t.display_message1()) print(t.my_name) print(t.my_address)
Aliaset som används för testmodulen är t . Så funktionen och variablerna från test.py kan refereras med aliaset t.
Produktion:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Absolut och relativ import i Python
Du vet nu hur man importerar en fil som en modul i en annan fil. Låt oss nu se hur man hanterar de tillgängliga filerna i mappar. Filerna i mapparna kan importeras antingen genom att använda absolut eller relativ import.
Tänk på att du har din projektmappstruktur, som visas nedan:
Rotmappen är mitt projekt/. Den har två undermappar paket1 och paket2.
Mapppaketet1 har två moduler, modul1.py och modul2.py.
Mappen paket2 har en klass myclass.py, ett underpaket subpkg med modul3.py och sista modul4.py.
- I module1.py finns en funktion som hetermyfunc1.
- I module2.py finns en funktion som heter myfunc2.
- I module3.py finns en funktion som heter myfunc3.
- I module4.py finns en funktion som heter myfunc4.
Använder absolut import
För absolut import måste du lägga till hela sökvägen till din modul direkt från projektets rotmapp.
Låt oss nu se hur man använder absolut import för att referera till funktionerna som finns i varje modul.
För att arbeta med functionmyfunc1 måste du importera enligt följande:
from package1.module1 import myfunc1 or from package1 import module1 module1.myfunc1()
För att arbeta med funktionen myfunc3 måste du importera enligt följande:
from package1.subpkg.module3 import myfunc3 or from package1.subpkg import module3 module3.myfunc3()
För- och nackdelar med att använda absolut import
Här är fördelarna med att använda absolut import:
- Det blir lätt att spåra tillbaka modulerna för kodkontroll.
- Lätt att använda och väldigt okomplicerad.
- Om projektet flyttas till en annan väg kommer importen fortfarande att förbli densamma.
Nackdelar med att använda absolut import
Här är nackdelarna med att använda absolut import:
Nackdelar:
- Importsökvägen kan bli väldigt lång om modulerna är kapslade och om namnet på modulerna är långt.
Använda relativ import
Med tanke på samma mappstruktur som nämns nedan kommer vi att se hur man importerar densamma med relativa importer.
Vid relativ import är modulen som ska importeras relativ till den aktuella platsen som är platsen där importsatsen finns.
syntax
Vid relativ import måste du lägga till en punkt (.) före modulnamnet när du importerar med från.
Det kommer att vara 2 punkter (..) före modulnamnet om modulen är på en nivå upp från den aktuella platsen.
Med hänvisning till mappstrukturen som nämns ovan, har vi följande moduler med deras funktion, som vi måste hänvisa till.
- I module1.py finns en funktion som hetermyfunc1.
- I module2.py finns en funktion som heter myfunc2.
- I module3.py finns en funktion som heter myfunc3.
- I module4.py finns en funktion som heter myfunc4.
För att arbeta med functionmyfunc1 måste du importera enligt följande:
from .module1 import myfunc1
För att arbeta med funktionen myfunc3 måste du importera enligt följande:
from .subpkg.module3 import myfunc3
Fördelar med relativ import
fördelar:
- Det är lätt att arbeta med relativ import.
- Från den nuvarande platsen kan importen förkortas i jämförelse med absolut import.
Nackdelar med relativ import
Nackdelar:
- Med hjälp av relativ import är det svårt att spåra tillbaka var koden finns
Sammanfattning
- Importera in Python hjälper dig att referera till koden, dvs .funktioner/objekt som är skrivna i en annan fil. Det används också för att importera pythonbibliotek/paket som är installerade med pip(python package manager), och du måste sedan använda i din kod.
- Importfunktionalitet är tillgänglig på andra språk som typskript, JavaScript, java, ruby, etc.
- En modul är python är koden skriven inuti filen, till exempel (test.py). Inuti din fil kan du ha dina variabler, funktioner eller din klass definierade. Hela filen blir en modul och kan importeras in i en annan fil för att referera till koden.
- Med modulfunktionalitet kan du dela upp din kod i olika filer istället för att skriva allt i en fil. Later, med import kan du referera till koden i filen du behöver.
- Python har sina inbyggda moduler, och även externa bibliotek/paket installerade med en python pakethanterare (pip), t.ex. pandor, NumPy, etc. kallas moduler.
- Du kan bara importera en liten del av modulen, dvs endast de nödvändiga funktionerna och variabelnamnen från modulen istället för att importera fullständig kod.
- Du kan också konvertera modulnamnet till en kortare form genom att ge det ett alias. Aliaset kan göras med hjälp av nyckelordet.
- Ett paket är en katalog med alla moduler definierade i den. Att göra en Python tolk behandla det som ett paket, din katalog bör ha filen __init.py. Init.py gör katalogen som ett paket. Här är layouten på paketet som vi ska arbeta med.
- Under utförande, när python stöter på importmodulens namn, försöker tolken hitta modulen. Den söker igenom modulen i den inbyggda modullistan. Later totalt sett katalogerna definierade i sys.path.
- För absolut import måste du lägga till hela sökvägen till din modul direkt från projektets rotmapp.
- Vid relativ import är modulen som ska importeras relativ till den aktuella platsen som är platsen där importsatsen finns.
