Importer modul ind Python med eksempler

Afsnittene nedenfor forklarer moduler, pakker, de forskellige importstile og hvordan absolut og relativ import fungerer i Python.

Hvad er modulerne i Python?

Et modul er en fil med Python kode. Koden kan være i form af variabler, funktioner eller en defineret klasse. Filnavnet bliver modulnavnet.

For eksempel, hvis dit filnavn er guru99.py, vil modulnavnet være guru 99. Med modulfunktionalitet kan du opdele din kode i forskellige filer i stedet for at skrive alt i én fil.

Hvad er det Python import modul?

En fil betragtes som et modul i PythonFor at bruge modulet skal du importere det ved hjælp af importere nøgleord. Funktionerne eller variablerne i filen kan bruges i en anden fil ved at importere modulet. Denne funktionalitet er tilgængelig på andre sprog som f.eks. TypeScript, Javamanuskript, Java, Ruby osv.

Sådan opretter og importerer du et modul i Python?

Nu opretter vi et modul og importerer det til en anden fil.

Her er flowet til at oprette og importere modulet som vist på skærmbilledet:

Følg de givne trin for at oprette et modul i Python.

Mappestrukturen, der bruges til at teste koden, er som følger:

modtest/
	test.py
	display.py	

Trin 1) Opret en fil og navngiv den test.py

Trin 2) Inde i test.py opret en funktion kaldet display_message()

Def display_message():
    return "Welcome to Guru99 Tutorials!"

Trin 3) Opret nu endnu en fil display.py.

Trin 4) Importer modulet test.py-filen i display.py, som vist nedenfor:

import test

Under importen behøver du ikke at nævne test.py, men kun navnet på filen.

Trin 5) Så kan du kalde funktionen display_message() fra test.py inde i display.py. Du skal bruge module_name.function_name.

For eksempel test.display_message().

Import test
print(test.display_message())

Trin 6) Når du kører display.py, får du følgende Output:

Welcome to Guru99 Tutorials!

Import af en klasse i Python

Tidligere har vi set et simpelt modul med en funktion. Her opretter vi en klasse og refererer til klassen i en anden fil.

Mappens struktur til at teste koden er som følger:

myproj/
	Car.py
	display.py

Opret en fil kaldet Car.py med følgende kode:

Filnavn: 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 findes attributterne brand_name, model og manu_year. Funktionerne defineret i klassen er car_details(), get_Car_brand(), get_Car_model().

Lad os nu bruge filen Car.py som et modul i en anden fil kaldet display.py.

Filnavn: 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())

Output:

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 tilgå alle variabler og funktioner fra Car.py ved hjælp af Car-modulet.

Bruger fra til import modul

Du kan kun importere en lille del af modulet, dvs. kun de nødvendige funktioner og variabelnavne fra modulet, i stedet for at importere hele koden.

Når du kun vil importere bestemte ting, kan du bruge nøgleordet "fra" til at importere det, du ønsker.

Så syntaksen er

from  module import your function_name , variables,... etc.

Mappestrukturen, der bruges til at teste koden, er som følger:

modtest/
	test.py
	display.py	

I test.py er der 2 funktioner som vist:

Filnavn: test.py

defdisplay_message():
	return "Welcome to Guru99 Tutorials!"
	
def display_message1():
	return "All about Python!"

Nu skal du bruge funktionen display_message(). Den funktion eller variabel, du importerer, kan tilgås direkte som vist nedenfor:

Filnavn: display.py

from test import display_message
print(display_message())

Output:

Welcome to Guru99 Tutorials!

Hvis du nu bruger funktionen display_message1(), vil den give en fejl om, at funktionen ikke er defineret som vist nedenfor:

from test import display_message
print(display_message1())

Output:

Traceback (most recent call last):
File "display.py", line 3, in <module>
print(display_message1())
Name Error: name 'display_message1' is not defined

Importerer alt fra modulet

Import giver dig mulighed for at importere hele modulet ved at bruge import efterfulgt af modulnavnet, dvs. filnavnet eller biblioteket, der skal bruges.

Syntaks:

Import module

Eller ved at bruge

from module import *

Mappestrukturen, der bruges til at teste koden, er som følger:

modtest/
	test.py
	display.py	

Følgende er kodedetaljerne inde i test.py

my_name = "Guru99"
my_address = "Mumbai"

defdisplay_message():
	return "Welcome to Guru99 Tutorials!"
	
	
def display_message1():
	return "All about Python!"

Brug af importmodulet

Hvis du udelukkende bruger importmodulnavnet, skal du sætte modulnavnet foran variablerne og funktionerne i modulet.

Eksempel

Filnavn: display.py

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

Modulnavnet test bruges til at referere til funktionerne og variablerne i modultesten.

Output:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Brug af import *

Lad os se et eksempel ved hjælp af import *. Ved brug af import *, er funktionerne og variablerne direkte tilgængelige, som vist i eksemplet nedenfor:

from test import *

print(display_message())
print(display_message1())
print(my_name)
print(my_address)

Output:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Dir( )-funktionen

dir() er en indbygget funktion i Pythondir() returnerer alle egenskaber og metoder, inklusive det givne objekts indbyggede egenskaber.

Så når dir() bruges på modulet, vil det give dig de variabler og funktioner, der findes i modulet.

Her er et eksempel på dir() i et modul. Vi har en klasse kaldet Car.py. Lad os importere Car og tildele den til dir() for at se outputtet.

Mappestrukturen til at teste koden vil være som følger:

test prop/
	Car.py
	test.py	

Filnavn: 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) 

Filnavn: test.py

import Car

class_contents = dir(Car)
print(class_contents)

Outputtet giver os navnet på klassen og alle de funktioner, der er defineret i Car.py.

Du kan også prøve at bruge dir() på et indbygget modul tilgængeligt i PythonLad os prøve det samme på json modulet som vist i eksemplet nedenfor. Det vil vise alle de egenskaber og metoder, der er tilgængelige i json modul.

Import json
json_details = dir(json)
print(json_details)

Output:

['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']

Pakker

En pakke er en mappe med alle moduler defineret inde i den. At lave en Python Hvis fortolkeren behandler det som en pakke, skal din mappe indeholde filen __init__.py. __init__.py gør mappen til en pakke. Her er layoutet af den pakke, vi skal arbejde med.

Pakkens navn er minpakkeFor at begynde at arbejde med pakken skal du oprette en mappe kaldet mypackage/. Inde i mappen skal du oprette en tom fil kaldet __init__.py. Opret 3 filer mere: module1.py, module2.py og module3.py, og definer funktionerne som vist på skærmbilledet. Her er detaljerne for module1.py, module2.py og module3.py.

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

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

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

pakke er klar til brug. Kald nu pakken i en af ​​dine filer som vist nedenfor i test.py:

Her importeres mypackage.module1 og får et aliasnavn som tilstand 1På samme måde kan du bruge de andre moduler module2.py og module3.py fra mypackage.

import mypackage.module1 as mod1

print(mod1.mod1_func1())
print(mod1.mod1_func2())
print(mod1.mod1_func2())

Output:

Welcome to Module1 function1
None
Welcome to Module1 function2
None
Welcome to Module1 function2
None

Vi har lige demonstreret pakken med et simpelt modul med funktioner i det. Som i dit projekt kan du også oprette pakker, der har underpakker, dvs. undermapper med moduler med definerede klasser.

Python Modulsøgningssti

Under udførelsen, når Python kommer på tværs import modulnavn, forsøger fortolkeren at finde modulet. Den søger efter modulet i den indbyggede modulliste og derefter i alle de mapper, der er defineret i sys.path.

For at opsummere udfører tolken følgende søgning for at finde modulet:

1. I din nuværende mappe.
2. I den indbyggede modulliste.
3. Inde i sys.path-mapperne.

Du kan få oplysninger om sys.path ved at importere sys-modulet og udskrive sys.path. Det vil give dig en liste over mapper som vist nedenfor:

importsys
print(sys.path)

Output:

['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\
\Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\P
ython37\\DLLs']

Du kan også ændre stien og beholde mapperne i henhold til dine krav.

Brug af modulalias i importen

Du kan også konvertere modulnavnet til en kortere form ved at give det et aliasnavn. Aliaset kan oprettes ved hjælp af as nøgleord.

Syntaks:

import filename as alias name

Mappestrukturen til at teste koden vil være som følger:

Mod test/
	test.py
	display.py	

Følgende er koden inde i test.py

my_name = "Guru99"
my_address = "Mumbai"

def display_message():
	return "Welcome to Guru99 Tutorials!"	
	
def display_message1():
	return "All about Python!"

Nu bruger vi et alias for 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, der bruges til testmodulet, er t. Så funktionerne og variablerne fra test.py kan refereres til ved hjælp af aliaset t.

Output:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Absolut og relativ import i Python

Du ved nu, hvordan du importerer en fil som et modul i en anden fil. Lad os nu se, hvordan man administrerer de tilgængelige filer i mapper. Filerne i mapperne kan importeres enten ved at bruge absolut eller relativ import.

Overvej, at du har din projektmappestruktur, som vist nedenfor:

Rodmappen er myproject/. Den har to undermapper, pakke1 og pakke2.

Mappen pakke1 har to moduler, modul1.py og modul2.py.

Mappen pakke2 har en klasse myclass.py, en underpakke underpakke med modul3.py og sidste modul4.py.

• I module1.py er der en funktion kaldet myfunc1.
• I module2.py er der en funktion kaldet myfunc2.
• I module3.py er der en funktion kaldet myfunc3.
• I module4.py er der en funktion kaldet myfunc4.

Brug af absolut import

For absolutte importer skal du tilføje hele stien til dit modul direkte fra projektets rodmappe.

Lad os nu se, hvordan man bruger absolutte importer til at referere til de funktioner, der findes i hvert af modulerne.

For at arbejde med funktionen myfunc1 skal du importere den som følger:

from package1.module1  import  myfunc1
or
from package1 import module1
module1.myfunc1()  

For at arbejde med funktionen myfunc3 skal du importere den som følger:

from package1.subpkg.module3  import  myfunc3
or
from package1.subpkg import module3
module3.myfunc3()  

Fordele og ulemper ved at bruge absolut import

Her er fordelene ved at bruge absolut import:

• Det bliver nemt at tracSæt modulerne tilbage for kodekontrol.
• Nem at bruge og meget ligetil.
• Hvis projektet flyttes til en anden sti, vil importerne stadig være de samme.

Ulemper ved at bruge absolut import

Her er ulemperne ved at bruge absolut import:

• Importstien kan blive meget lang, hvis modulerne er indlejrede, og modulnavnene er lange.

Brug af relativ import

I betragtning af den samme mappestruktur som nævnt ovenfor, vil vi se, hvordan man importerer den samme ved hjælp af relativ import.

I en relativ import er det modul, der skal importeres, relativt til den aktuelle placering, det vil sige den placering, hvor import-sætningen er til stede.

Syntaks

Ved relativ import skal du tilføje et punktum (.) før modulnavnet, når du importerer vha fra.

Der vil være to punktummer (..) foran modulnavnet, hvis modulet er et niveau højere oppe fra den aktuelle placering.

Med henvisning til ovenstående mappestrukturfigur har vi følgende moduler med deres funktioner, som vi skal henvise til.

• I module1.py er der en funktion kaldet myfunc1.
• I module2.py er der en funktion kaldet myfunc2.
• I module3.py er der en funktion kaldet myfunc3.
• I module4.py er der en funktion kaldet myfunc4.

For at arbejde med funktionen myfunc1 skal du importere den som følger:

from  .module1  import  myfunc1

For at arbejde med funktionen myfunc3 skal du importere den som følger:

from  .subpkg.module3  import  myfunc3

Fordele ved relativ import

• Det er nemt at arbejde med relativ import.
• Fra den nuværende placering kan importen forkortes i forhold til absolut import.

Ulemper ved relativ import

• Ved at bruge relative importer er det vanskeligt at tractilbage hvor koden befinder sig.

Ofte Stillede Spørgsmål