Importera modul in Python med exempel

Avsnitten nedan förklarar moduler, paket, de olika importstilarna och hur absoluta och relativa importer fungerar i Python.

Vad är modulerna i Python?

En modul är en fil med Python kod. Koden kan vara i form av variabler, funktioner eller en definierad klass. 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 PythonFör att använda modulen måste du importera den med hjälp av importera nyckelord. Funktionerna 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 TypeScript, JavaManus, Java, Ruby, etc.

Hur man skapar och importerar en modul i Python?

Nu ska vi skapa en modul och importera 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 som anges 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 döp den till 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 modulen test.py-filen inuti display.py, som visas nedan:

import test

När du importerar behöver du inte ange test.py utan bara namnet på filen.

Steg 5) Sedan kan du anropa funktionen display_message() från test.py inuti display.py. Du behöver använda module_name.function_name.

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 vi att skapa en klass och referera till klassen i en annan fil.

Mappstrukturen för att testa koden är följande:

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 inuti 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 Car-modulen.

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 hela koden.

När du bara vill importera specifika saker kan du använda nyckelordet "från" för att importera det du vill.

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 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 funktionen display_message(). 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 den att ge ett felmeddelande om att funktionen inte är definierad enligt 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

Med Import kan du importera hela modulen genom att använda import följt av modulnamnet, 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 importmodulens namn, för att referera till variabler och funktioner inuti modulen, måste du prefixa dem med modulnamnet.

Exempelvis

Filnamn: display.py

Import test
print(test.display_message())
print(test.display_message1())
print(test.my_name)
print(test.my_address)

Modulnamnet test används för att referera till funktionerna 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 Pythondir() returnerar alla egenskaper och metoder, inklusive det givna objektets inbyggda egenskaper.

Så när dir() används på modulen, kommer den att ge dig de variabler och 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 den 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 PythonLåt oss försöka detsamma på json modulen som visas i exemplet nedan. Den visar 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 Om tolken behandlar det som ett paket, bör din katalog innehålla filen __init__.py. __init__.py gör katalogen till ett paket. Här är layouten för paketet som vi ska arbeta med.

Namnet på paketet är mittpaketFör att börja arbeta med paketet, skapa en katalog som heter mypackage/. 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ärmbilden. Här är detaljerna för 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")

Ocuco-landskapet paket är redo att användas. Anropa nu paketet i någon av dina filer som visas nedan i test.py:

Här importeras mypackage.module1 och får ett aliasnamn som läge1På samma sätt kan du använda de andra modulerna module2.py och module3.py från mypackage.

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 just demonstrerat paketet med en enkel modul med funktioner inuti. Beroende på ditt projekt kan du också skapa paket som har underpaket, dvs. undermappar som innehåller moduler med definierade klasser.

Python Sökväg för modul

Under utförandet, när Python stöter på importmodulens namn, försöker tolken hitta modulen. Den söker efter modulen i den inbyggda modulistan och sedan i alla kataloger som definierats inuti sys.path.

Sammanfattningsvis gör tolken följande sökning för att hitta modulen:

1. I din nuvarande katalog.
2. I den inbyggda modulens lista.
3. Inuti sys.path-katalogerna.

Du kan få information om sys.path genom att importera sys-modulen och skriva ut sys.path. Det ger dig en lista ö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 aliasnamn. Aliaset kan skapas med hjälp av as nyckelord.

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 ska vi 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å funktionerna och variablerna från test.py kan refereras till med hjälp av 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 myproject/. Den har två undermappar, paket1 och paket2.

Mappen package1 har två moduler, module1.py och module2.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 heter myfunc1.
• 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 absoluta importer 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 absoluta importer för att referera till de funktioner som finns i var och en av modulerna.

För att arbeta med funktionen myfunc1 måste du importera den 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 den 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 tracSätt tillbaka modulerna för kodkontroll.
• Lätt att använda och väldigt okomplicerad.
• Om projektet flyttas till en annan sökväg kommer importerna fortfarande att förbli desamma.

Nackdelar med att använda absolut import

Här är nackdelarna med att använda absoluta importer:

• Importsökvägen kan bli mycket lång om modulerna är kapslade och modulnamnen är långa.

Använda relativ import

Med tanke på samma mappstruktur som nämnts ovan, kommer vi att se hur man importerar densamma med hjälp av relativ import.

I en relativ import är modulen som ska importeras relativ till den aktuella platsen, det vill säga den plats där import-satsen 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 stå två punkter (..) före modulnamnet om modulen är en nivå högre upp från den aktuella platsen.

Med hänvisning till mappstrukturfiguren som nämns ovan har vi följande moduler med deras funktioner, som vi behöver referera till.

• I module1.py finns en funktion som heter myfunc1.
• 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 funktionen myfunc1 måste du importera den enligt följande:

from  .module1  import  myfunc1

För att arbeta med funktionen myfunc3 måste du importera den enligt följande:

from  .subpkg.module3  import  myfunc3

Fördelar med relativ import

• 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

• Med relativ import är det svårt att tractillbaka där koden finns.

Vanliga frågor