Importera modul in Python med exempel

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:

Skapa och importera en modul i Python

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.

Paket in Python

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")

Smakämnen 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:

  1. I din nuvarande katalog.
  2. In i listan över inbyggda moduler
  3. 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:

Absolut och relativ import i Python

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.