Module importeren in Python met voorbeelden

Wat zijn de modules in Python?

Een module is een bestand met python-code. De code kan de vorm hebben van variabelen, functies of gedefinieerde klassen. De bestandsnaam wordt de modulenaam.

Als uw bestandsnaam bijvoorbeeld guru99.py is, is de modulenaam guru99 . Met modulefunctionaliteit kunt u uw code opsplitsen in verschillende bestanden in plaats van alles in één bestand te schrijven.

In deze tutorial leer je:

Wat zijn de modules in Python?
Python-importmodule
Hoe maak en importeer je een module in Python?
Een klasse importeren in Python
Van gebruiken om module te importeren
Alles importeren uit module
De importmodule gebruiken
Import gebruiken *
De dir( ) functie
Pakketten
PythonModuleSearchPath
Module-alias gebruiken bij het importeren
Absolute en relatieve invoer in Python
AbsoluteImports gebruiken
RelativeImports gebruiken

Wat is de Python-importmodule?

Een bestand wordt beschouwd als een module in python. Om de module te gebruiken, moet je deze importeren met de import trefwoord. De functie of variabelen die in het bestand aanwezig zijn, kunnen in een ander bestand worden gebruikt door de module te importeren. Deze functionaliteit is beschikbaar in andere talen, zoals typoscript, JavaScript, java, ruby, enz.

Hoe maak en importeer ik een module in Python?

Nu gaan we een module maken en deze in een ander bestand importeren.

Hier is de procedure voor het maken en importeren van de module zoals weergegeven in de schermafbeelding:

Volg de gegeven stappen om een module in python te maken.

De mapstructuur die wordt gebruikt om de code te testen is als volgt:

modtest/
	test.py
	display.py

Stap 1) Maak een bestand en noem het test.py

Stap 2) Maak binnen test.py een functie met de naam display_message()

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

Stap 3) Maak nu een ander bestand display.py.

Stap 4) Importeer binnen display.py het bestand moduletest.py, zoals hieronder weergegeven:

import test

Tijdens het importeren hoef je niet de test.py te noemen, maar alleen de naam van het bestand.

Stap5)

Dan kun je de functie display_message() aanroepen vanuit test.py binnen display.py, je moet gebruik maken van module_name.function_name.

Bijvoorbeeld test.display_message().

Import test
print(test.display_message())

Stap 6)

Wanneer u display.py uitvoert, krijgt u de volgende uitvoer:

Welcome to Guru99 Tutorials!

Een klasse importeren in Python

Eerder zagen we al een eenvoudige module met een functie. Hier wordt een klas gemaakt en de klas naar een ander bestand verwezen.

De mappenstructuur om de code te testen is als volgt:

myproj/
	Car.py
	display.py

Maak een bestand met de naam Car.py met de volgende code:

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

In het bestand Car.py staan attributen brand_name, model en manu_year. De functies die binnen de klasse zijn gedefinieerd, zijn car_details(), get_Car_brand(), get_Car_model().

Laten we nu het bestand Car.py gebruiken als een module in een ander bestand met de naam display.py.

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

Uitgang:

BMW
Car brand is  BMW
Car model is  Z5
Car manufacture year is  2020
Car brand is  BMW
Car model is  Z5

We hebben dus toegang tot alle variabelen en functies van Car.py met behulp van de Car-module.

Van gebruiken om module te importeren

U kunt slechts een klein deel van de module importeren, d.w.z. alleen de vereiste functies en variabelenamen uit de module in plaats van de volledige code te importeren.

Als u wilt dat alleen specifieke dingen worden geïmporteerd, kunt u het trefwoord "van" gebruiken om te importeren wat u wilt.

Dus de syntaxis is

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

De mapstructuur die wordt gebruikt om de code te testen is als volgt:

modtest/
	test.py
	display.py

In test.py zijn er 2 functies zoals weergegeven:

Bestandsnaam:test.py

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

Nu wil je de functie display_message(). De functie of variabele die u importeert is direct toegankelijk zoals hieronder weergegeven:

Bestandsnaam:display.py

from test import display_message
print(display_message())

Uitvoer:

Welcome to Guru99 Tutorials!

Als je nu de functie display_message1() gebruikt, zal het een foutmelding geven dat de functie niet is gedefinieerd zoals hieronder weergegeven:

from test import display_message
print(display_message1())

Uitvoer:

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

Alles importeren uit de module

Met Importeren kunt u de volledige module importeren met behulp van import gevolgd door de modulenaam, d.w.z. de bestandsnaam of de te gebruiken bibliotheek.

Syntaxis:

Import module

Of door gebruik te maken van

from module import *

De mapstructuur die wordt gebruikt om de code te testen is als volgt:

modtest/
	test.py
	display.py

Hieronder volgen de codedetails in test.py

my_name = "Guru99"
my_address = "Mumbai"

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

De importmodule gebruiken

Als u alleen de modulenaam importeert, om naar de variabelen en functies in de module te verwijzen, moet deze voorafgaan aan de modulenaam.

Voorbeeld

Bestandsnaam:display.py

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

De modulenaamtest wordt gebruikt om te verwijzen naar de functie en variabelen in de moduletest.

Uitgang:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Import gebruiken *

Laten we een voorbeeld bekijken met import * . Met behulp van import * , zijn de functies en variabelen direct toegankelijk, zoals in het onderstaande voorbeeld:

from test import *

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

Uitgang:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

De dir( ) functie

De dir() is een ingebouwde functie in python. De dir() retourneert alle eigenschappen en methoden, inclusief de ingebouwde eigenschappen van het gegeven object.

Dus als dir() op de module wordt gebruikt, krijg je de variabelen, functies die in de module aanwezig zijn.

Hier is een werkend voorbeeld van dir() op een module. We hebben een klasse genaamd Car.py, laten we Car importeren en toewijzen aan dir() om de uitvoer te zien.

De mappenstructuur om de code te testen is als volgt:

test prop/
	Car.py
	test.py

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

Bestandsnaam:test.py

import Car

class_contents = dir(Car)
print(class_contents)

De uitvoer geeft ons de naam van de klasse en alle functies die zijn gedefinieerd in Car.py.

Je kunt ook proberen dir() te gebruiken op een ingebouwde module die beschikbaar is in Python. Laten we hetzelfde proberen op json module zoals weergegeven in het onderstaande voorbeeld. Het toont alle eigenschappen en methoden die beschikbaar zijn in json module.

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

Uitgang:

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

Pakketten

Een pakket is een map waarin alle modules zijn gedefinieerd. Om een Python-interpreter het als een pakket te laten behandelen, moet uw directory het init.pyfile hebben. De init.py maakt de map als een pakket. Hier is de lay-out van het pakket waar we aan gaan werken.

De naam van het pakket is mijn pakket . Om met het pakket te gaan werken, maakt u een map met de naam package/. Maak in de map een leeg bestand met de naam __init__.py. Maak nog 3 bestanden module1.py, module2.py en module3.py en definieer de functies zoals weergegeven in de schermafbeelding. Hier zijn de details van module1.py,module2.py en 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")

Het pakket s klaar voor gebruik. Roep nu het pakket aan in een van uw bestanden zoals hieronder getoond :test.py:

Hier wordt het mijnpakket.module1 geïmporteerd en krijgt het een aliasnaam als mod1. Op dezelfde manier kunt u andere modules module2.py en module3.py uit mijn pakket gebruiken.

import mypackage.module1 as mod1

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

Uitgang:

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

We hebben zojuist het pakket gedemonstreerd met een eenvoudige module met daarin functies. Volgens uw project kunt u ook verpakken met subpakketten. Submappen/modules met gedefinieerde klassen.

Zoekpad voor Python-module

Wanneer python tijdens de uitvoering naam importmodule tegenkomt , probeert de interpreter de module te lokaliseren. Het zoekt de module in de lijst met ingebouwde modules. Later werden de mappen gedefinieerd in sys.path.

Samenvattend doet de tolk de volgende zoekopdracht om de module te lokaliseren:

In uw huidige directory.
In in de lijst met ingebouwde modules
In de sys.path-mappen

U kunt de details van sys.path krijgen door de sys-module te importeren en het sys.path af te drukken. Het geeft je de lijst met mappen zoals hieronder getoond:

importsys
print(sys.path)

Uitgang:

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

U kunt ook het pad wijzigen en de mappen behouden volgens uw vereisten.

Module-alias gebruiken in de import

U kunt de modulenaam ook converteren naar een kortere vorm door er een aliasnaam aan te geven. De alias kan worden gedaan met behulp van het trefwoord.

Syntaxis:

import filename as alias name

De mappenstructuur om de code te testen is als volgt:

Mod test/
	test.py
	display.py

Hieronder volgt de code in test.py

my_name = "Guru99"
my_address = "Mumbai"

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

Gebruikt nu een alias voor test.py in display.py

Import test as t

print(t.display_message())
print(t.display_message1())
print(t.my_name)
print(t.my_address)

De alias die wordt gebruikt voor de testmodule is t . Dus de functie en variabelen van test.py kunnen worden verwezen met de alias t.

Uitgang:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Absolute en relatieve invoer in Python

U weet nu hoe u een bestand als module in een ander bestand kunt importeren. Laten we nu eens kijken hoe we de bestanden die beschikbaar zijn in mappen kunnen beheren. De bestanden in de mappen kunnen worden geïmporteerd door middel van absolute of relatieve import.

Overweeg dat u uw projectmapstructuur heeft, zoals hieronder weergegeven:

De hoofdmap is mijn project/. Het heeft twee submappen package1 en package2.

De map package1 heeft twee modules, module1.py en module2.py.

De map package2 heeft één klasse myclass.py, een subpakket subpkg met module3.py en laatste module4.py.

In module1.py is er een functie genaamdmyfunc1.
In module2.py is er een functie genaamd myfunc2.
In module3.py is er een functie genaamd myfunc3.
In module4.py is er een functie genaamd myfunc4.

Absolute import gebruiken

Voor absolute import moet u het volledige pad van uw module rechtstreeks vanuit de hoofdmap van het project toevoegen.

Laten we nu kijken hoe we gebruik kunnen maken van absolute imports om te verwijzen naar de functies die aanwezig zijn in elk van de modules.

Om met de functiemyfunc1 te werken, moet u als volgt importeren:

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

Om met de functie myfunc3 te werken, moet u als volgt importeren:

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

Voor- en nadelen van het gebruik van absolute import

Dit zijn de voordelen van het gebruik van absolute import:

Het wordt gemakkelijk om de modules te traceren voor codecontrole.
Eenvoudig te gebruiken en zeer eenvoudig.
Als het project naar een ander pad wordt verplaatst, blijft de import hetzelfde.

Nadelen van het gebruik van absolute import

Dit zijn de nadelen van het gebruik van absolute import:

Nadelen:

Het importpad kan erg lang worden als de modules genest zijn en als de naam van de modules lang is.

Relatieve invoer gebruiken

Gezien dezelfde mappenstructuur die hieronder wordt vermeld, zullen we zien hoe we deze kunnen importeren met behulp van relatieve importen.

Bij relatieve import is de te importeren module relatief ten opzichte van de huidige locatie, dat is de locatie waar de importverklaring aanwezig is.

Syntaxis:

Bij relatieve import moet u een punt (.) vóór de modulenaam toevoegen wanneer u importeert met van .

Het zal 2 punten (..) voor de modulenaam staan als de module zich in het ene niveau hoger bevindt dan de huidige locatie.

Verwijzend naar de hierboven genoemde mapstructuur, hebben we de volgende modules met hun functie, waarnaar we moeten verwijzen.

In module1.py is er een functie genaamdmyfunc1.
In module2.py is er een functie genaamd myfunc2.
In module3.py is er een functie genaamd myfunc3.
In module4.py is er een functie genaamd myfunc4.

Om met de functiemyfunc1 te werken, moet u als volgt importeren:

from  .module1  import  myfunc1

Om met de functie myfunc3 te werken, moet u als volgt importeren:

from  .subpkg.module3  import  myfunc3

Voordelen van relatieve invoer

Voordelen:

Het is gemakkelijk om met relatieve importen te werken.
Vanaf de huidige locatie kunnen de importen worden verkort in vergelijking met absolute importen.

Nadelen van relatieve invoer

Nadelen:

Met relatieve import is het moeilijk om te achterhalen waar de code zich bevindt

Samenvatting:

Importeren in Python helpt je om naar de code te verwijzen, d.w.z. .functies/objecten die in een ander bestand zijn geschreven. Het wordt ook gebruikt om python-bibliotheken / -pakketten te importeren die zijn geïnstalleerd met pip (python-pakketbeheerder), en die u vervolgens in uw code moet gebruiken.
Importfunctionaliteit is beschikbaar in andere talen, zoals typoscript, JavaScript, java, ruby, enz.
Een module is python is de code die in het bestand is geschreven, bijvoorbeeld (test.py). In uw bestand kunt u uw variabelen, functies of uw klasse laten definiëren. Het hele bestand wordt een module en kan in een ander bestand worden geïmporteerd om naar de code te verwijzen.
Met modulefunctionaliteit kun je je code opsplitsen in verschillende bestanden in plaats van alles in één bestand te schrijven. Later, met behulp van import, kun je de code in het bestand dat je nodig hebt raadplegen.
Python heeft ingebouwde modules, en ook externe bibliotheken/pakketten die zijn geïnstalleerd met behulp van een python-pakketbeheerder (pip), bijvoorbeeld panda's, NumPy, enz. worden modules genoemd.
U kunt slechts een klein deel van de module importeren, d.w.z. alleen de vereiste functies en variabelenamen uit de module in plaats van de volledige code te importeren.
Je kunt de modulenaam ook converteren naar een kortere vorm door er een aliasnaam aan te geven. De alias kan worden gedaan met behulp van het trefwoord.
Een pakket is een map waarin alle modules zijn gedefinieerd. Om een Python-interpreter het als een pakket te laten behandelen, moet uw directory het bestand __init.py bevatten. De init.py maakt de map als een pakket. Hier is de lay-out van het pakket waar we aan gaan werken.
Tijdens uitvoering, wanneer python naam importmodule tegenkomt , probeert de interpreter de module te lokaliseren. Het zoekt de module in de lijst met ingebouwde modules. Later werden de mappen gedefinieerd in sys.path.
Voor Absolute import moet u het volledige pad van uw module rechtstreeks vanuit de hoofdmap van het project toevoegen.
Bij relatieve import is de te importeren module relatief ten opzichte van de huidige locatie, dat is de locatie waar het importstatement aanwezig is.

Multithreading in Python met voorbeeld:leer GIL in Python Python Debugger:Verbeter moeiteloos uw foutopsporingsvaardigheden

Python