Vilka är modulerna i Python?
En modul är en fil med pythonkod. Koden kan ha formen av variabler, funktioner eller klassdefinierade. Filnamnet blir modulnamnet.
Till exempel, om ditt filnamn är guru99.py, kommer modulnamnet att vara guru99 . Med modulfunktionaliteten kan du dela upp koden i olika filer istället för att skriva allt i en fil.
I den här handledningen lär du dig:
- Vilka är modulerna i Python?
- Python-importmodul
- Hur skapar och importerar jag en modul i Python?
- Importera en klass i Python
- Använda från att importera modulen
- Importerar allt från modulen
- Använda importmodulen
- Använda import *
- Dir () -funktionen
- Paket
- PythonModuleSearchPath
- Använda modulalias i importen
- Absolut och relativ import i Python
- UsingAbsoluteImports
- UsingRelativeImports
Vad är Python-importmodulen?
En fil betraktas som en modul i python. För att använda modulen måste du importera den med hjälp av importordet. Funktionen eller variablerna som finns i filen kan användas i en annan fil genom att importera modulen. Denna funktion finns på andra språk, som typsnitt, JavaScript, java, rubin, etc.
Hur skapar och importerar jag en modul i Python?
Nu skapar vi en modul och importerar den till 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 som följer:
modtest/test.pydisplay.py
Steg 1) Skapa en fil och ge den namnet 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) Importera moduletest.py-filen inuti display.py, som visas nedan:
import test
Under importen behöver du inte nämna test.py utan bara namnet på filen.
Steg 5)
Sedan kan du ringa funktionen display_message () från test.py inuti display.py, du måste använda modulnamn.funktionsnamn.
Till exempel test.display_message ().
Import testprint(test.display_message())
Steg 6)
När du kör display.py får du följande utdata:
Welcome to Guru99 Tutorials!
Importera en klass i Python
Tidigare har vi sett en enkel modul med en funktion. Här skapas en klass och hänvisar klassen till en annan fil.
Mappstrukturen för att testa koden är som följer:
myproj/Car.pydisplay.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_nameself.model = modelself.manu_year = manu_yeardef 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 attribut brand_name, model och manu_year. Funktionerna definierade 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 Carcar_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:
BMWCar brand is BMWCar model is Z5Car manufacture year is 2020Car brand is BMWCar model is Z5
Så vi kan komma åt alla variabler och funktioner från Car.py med hjälp av bilmodulen.
Använda från att importera modulen
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 hela koden.
När du bara vill att 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 som följer:
modtest/test.pydisplay.py
I test.py finns det två 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 () -funktionen. Funktionen eller variabeln som du importerar kan nås direkt enligt nedan:
Filnamn: display.py
from test import display_messageprint(display_message())
Produktion:
Welcome to Guru99 Tutorials!
Nu om du råkar använda funktionen display_message1 (), kommer det att kasta ett fel att funktionen inte är definierad som visas nedan:
from test import display_messageprint(display_message1())
Produktion:
Traceback (most recent call last):File "display.py", line 3, inprint(display_message1())Name Error: name 'display_message1' is not defined
Importerar allt från modulen
Import låter dig importera hela modulen med hjälp av 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 som följer:
modtest/test.pydisplay.py
Nedan följer kodinformation inuti test.py
my_name = "Guru99"my_address = "Mumbai"defdisplay_message():return "Welcome to Guru99 Tutorials!"def display_message1():return "All about Python!"
Använda importmodulen
Om du bara använder modulnamn för att referera till variablerna och funktionerna inuti modulen måste det prefixas med modulnamnet.
Exempel
Filnamn: display.py
Import testprint(test.display_message())print(test.display_message1())print(test.my_name)print(test.my_address)
Modulnamnetestet används för att referera till funktion och variabler i modultestet.
Produktion:
Welcome to Guru99 Tutorials!All about Python!Guru99Mumbai
Använda import *
Låt oss se ett exempel med import * . Med hjälp av import * ä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!Guru99Mumbai
Dir () -funktionen
Dir () är en inbyggd funktion i python. Dir () returnerar alla egenskaper och metoder, inklusive det angivna objektets inbyggda egenskaper.
Så när dir () används på modulen kommer det att ge dig variablerna, funktionerna som finns i 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 dir () för att se utdata.
Mappstrukturen för att testa koden kommer att vara som följer:
test prop/Car.pytest.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_nameself.model = modelself.manu_year = manu_yeardef 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 Carclass_contents = dir(Car)print(class_contents)
Utgången ger oss namnet på klassen och alla funktioner som definierats i Car.py.
Du kan också försöka använda dir () på en inbyggd modul som finns i Python. Låt oss prova samma sak på json- modulen som visas i exemplet nedan. Den visar alla egenskaper och metoder som finns tillgängliga i json- modulen.
Import jsonjson_details = dir(json)print(json_details)
Produktion:
['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_encoder', 'codecs', 'decoder', 'detect_encoding', 'dump', 'dumps', 'encoder', 'load', 'loads', 'scanner']
Paket
Ett paket är en katalog med alla moduler definierade i den. För att få en Python-tolk att behandla det som ett paket, ska din katalog ha init.pyfile. Init.py gör katalogen som ett paket. Här är layouten för paketet som vi ska arbeta med.
Paketets namn är mitt paket . För att börja arbeta med paketet skapar du en katalog som heter package /. Skapa en tom fil som heter __init__.py i katalogen. Skapa ytterligare 3 filer module1.py, module2.py och module3.py och definiera funktionerna som visas på skärmdumpen. Här är detaljerna i module1.py, module2.py och module3.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")
Det paket är redo för användning. Ring nu paketet i någon av dina filer enligt 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 mod1print(mod1.mod1_func1())print(mod1.mod1_func2())print(mod1.mod1_func2())
Produktion:
Welcome to Module1 function1NoneWelcome to Module1 function2NoneWelcome to Module1 function2None
Vi har just demonstrerat paketet med en enkel modul med funktioner inuti. Enligt ditt projekt kan du också paketera med har underpaket. Undermappar / med moduler med klasser definierade.
Sökväg för Python-modul
Under körning, när python stöter på importmodulnamn , försöker tolken hitta modulen. Den söker i modulen i listan över inbyggda moduler. Senare definierade katalogerna inuti sys.path.
Sammanfattningsvis gör tolk följande sökning för att hitta modulen:
- I din nuvarande katalog.
- 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 ger dig listan över kataloger som visas nedan:
importsysprint(sys.path)
Produktion:
['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\\Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\Python37\\DLLs']
Du kan också ändra sökvägen och behålla katalogerna enligt dina krav.
Använda modulalias i importen
Du kan också konvertera modulnamnet till en kortare form genom att ge det ett aliasnamn. Aliaset kan göras med hjälp av nyckelordet.
Syntax:
import filename as alias name
Mappstrukturen för att testa koden kommer att vara som följer:
Mod test/test.pydisplay.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!"
Kommer nu att använda ett alias för test.py i display.py
Import test as tprint(t.display_message())print(t.display_message1())print(t.my_name)print(t.my_address)
Aliaset som används för testmodul är t. Så funktionen och variablerna från test.py kan hänvisas med aliaset t.
Produktion:
Welcome to Guru99 Tutorials!All about Python!Guru99Mumbai
Absolut och relativ import i Python
Du vet nu hur du importerar en fil som en modul i en annan fil. Låt oss nu se hur man hanterar de filer som är tillgängliga i mappar. Filerna i mapparna kan importeras antingen med absolut eller relativ import.
Tänk på att du har din projektmappstruktur, som visas nedan:
Rotmappen är mitt projekt /. Den har två undermappar package1 och package2.
Mapppaketet1 har två moduler, module1.py och module2.py.
Mapppaketet2 har en klass myclass.py, ett underpaket subpkg med module3.py och sista module4.py.
- I module1.py finns det en funktionsanropadmyfunc1.
- I module2.py finns det en funktionsanropadmyfunc2.
- I module3.py finns det en funktionsanropadmyfunc3.
- I module4.py finns det en funktionsanropadmyfunc4.
Använda absolut import
För absolutimport måste du lägga till hela sökvägen för din modul direkt från projektets rotmapp.
Låt oss nu se hur man använder absolut import för att hänvisa till de funktioner som finns i var och en av modulen.
För att arbeta med functionmyfunc1 måste du importera enligt följande:
from package1.module1 import myfunc1orfrom package1 import module1module1.myfunc1()
För att arbeta med funktionen myfunc3 måste du importera enligt följande:
from package1.subpkg.module3 import myfunc3orfrom package1.subpkg import module3module3.myfunc3()
Fördelar 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 modulerna för kodkontroll.
- Lätt att använda och mycket enkelt.
- Om projektet flyttas till en annan väg kommer importen fortfarande att vara densamma.
Nackdelar med att använda absolut import
Här är nackdelarna med att använda absolut import:
Nackdelar:
- Importvägen kan bli väldigt lång i fallet, modulerna är kapslade och om namnet på modulerna är långt.
Använda relativ import
Med tanke på samma mappstruktur som nämns nedan ser vi hur man importerar samma med relativ import.
I relativ import är den modul som ska importeras i förhållande till den aktuella platsen där importdeklarationen finns.
Syntax:
I relativ import måste du lägga till en period (.) Före modulnamnet när du importerar med från .
Det kommer att ta två perioder (...) före modulnamnet om modulen befinner sig i en nivå upp från den aktuella platsen.
Med hänvisning till den ovan nämnda mappstrukturen har vi följande moduler med deras funktion, som vi måste referera till.
- I module1.py finns det en funktionsanropadmyfunc1.
- I module2.py finns det en funktionsanropadmyfunc2.
- I module3.py finns det en funktionsanropadmyfunc3.
- I module4.py finns det en funktionsanropadmyfunc4.
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 nuvarande plats kan importen förkortas jämfört med absolut import.
Nackdelar med relativ import
Nackdelar:
- Med relativ import är det svårt att spåra var koden finns
Sammanfattning:
- Import i Python hjälper dig att hänvisa till koden, dvs .funktioner / objekt som är skrivna i en annan fil. Det används också för att importera python-bibliotek / paket som installeras med pip (python-pakethanterare), och du måste sedan använda i din kod.
- Importfunktionalitet finns på andra språk som typsnitt, JavaScript, java, rubin, etc.
- En modul är python är koden skriven i filen, till exempel (test.py). Inne i filen kan du definiera dina variabler, funktioner eller din klass. Hela filen blir en modul och kan importeras inuti en annan fil för att referera till koden.
- Med modulfunktionaliteten kan du dela upp koden i olika filer istället för att skriva allt i en fil. Senare, med hjälp av import, kan du hänvisa till koden i filen du behöver.
- Python har sina inbyggda moduler och även externa bibliotek / paket installerade med hjälp av en python-pakethanterare (pip), t.ex. pandor, NumPy, etc. kallas moduler.
- 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 hela koden.
- Du kan också konvertera modulnamnet till en kortare form genom att ge det ett aliasnamn. Aliaset kan göras med hjälp av nyckelordet.
- Ett paket är en katalog med alla moduler definierade i den. För att få en Python-tolk att behandla det som ett paket, ska din katalog ha __init.pyfile. Init.py gör katalogen som ett paket. Här är layouten för paketet som vi ska arbeta med.
- Under körning, när python stöter på importmodulnamn , försöker tolken hitta modulen. Den söker i modulen i listan över inbyggda moduler. Senare definierade katalogerna inuti sys.path.
- För absolutimport måste du lägga till hela sökvägen för din modul direkt från projektets rotmapp.
- I relativ import är den modul som ska importeras i förhållande till den aktuella platsen där importdeklarationen finns.