Importer modul inn Python med eksempler
Anna Blake
Hva er modulene i Python?
En modul er en fil med python-kode. Koden kan være i form av variabler, funksjoner eller klassedefinerte. Filnavnet blir modulnavnet.
For eksempel, hvis filnavnet ditt er guru99.py, vil modulnavnet være guru99. Med modulfunksjonalitet kan du bryte koden din i forskjellige filer i stedet for å skrive alt i én fil.
Hva er den Python importere modul?
En fil betraktes som en modul i python. For å bruke modulen, må du importere den ved hjelp av importen nøkkelord. Funksjonen eller variablene som finnes i filen kan brukes i en annen fil ved å importere modulen. Denne funksjonaliteten er tilgjengelig på andre språk, som typescript, JavaScript, java, ruby, etc.
Hvordan opprette og importere en modul i Python?
Nå skal vi lage en modul og importere den i en annen fil.
Her er flyten for å opprette og importere modulen som vist på skjermbildet:
Følg trinnene gitt for å lage en modul i python.
Mappestrukturen som brukes til å teste koden er som følger:
modtest/ test.py display.py
Trinn 1) Opprett en fil og navngi den test.py
Trinn 2) Lag en funksjon som heter display_message() inne i test.py
Def display_message():
return "Welcome to Guru99 Tutorials!"
Trinn 3) Opprett nå en annen fil display.py.
Trinn 4) Inside display.py importerer moduletest.py-filen, som vist nedenfor:
import test
Mens du importerer, trenger du ikke å nevne test.py, men bare navnet på filen.
Trinn 5) Deretter kan du kalle funksjonen display_message() fra test.py inne i display.py, du må bruke module_name.function_name.
For eksempel test.display_message().
Import test print(test.display_message())
Trinn 6) Når du kjører display.py, får du følgende Utgang:
Welcome to Guru99 Tutorials!
Importere en klasse i Python
Tidligere har vi sett en enkel modul med en funksjon. Her vil opprette en klasse og henvise klassen til en annen fil.
Mappestrukturen for å teste koden er som følger:
myproj/ Car.py display.py
Lag en fil kalt 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 er det attributter merkenavn, modell og manu_år. Funksjonene som er definert inne i klassen er car_details(), get_Car_brand(), get_Car_model().
La oss nå bruke filen Car.py som en modul i en annen fil kalt 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())
Utgang:
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 få tilgang til alle variablene og funksjonene fra Car.py ved å bruke bilmodulen.
Bruker fra til importmodul
Du kan bare importere en liten del av modulen, dvs. bare de nødvendige funksjonene og variabelnavnene fra modulen i stedet for å importere full kode.
Når du vil at bare spesifikke ting skal importeres, kan du bruke "fra" nøkkelord for å importere det du ønsker.
Så syntaksen er
from module import your function_name , variables,... etc.
Mappestrukturen som brukes til å teste koden er som følger:
modtest/ test.py display.py
I test.py er det 2 funksjoner som vist:
Filnavn: test.py
defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Nå vil du ha funksjonen display_message(). Funksjonen eller variabelen du importerer kan nås direkte som vist nedenfor:
Filnavn: display.py
from test import display_message print(display_message())
Utgang:
Welcome to Guru99 Tutorials!
Nå hvis du tilfeldigvis bruker funksjonen display_message1(), vil det gi en feilmelding om at funksjonen ikke er definert som vist nedenfor:
from test import display_message print(display_message1())
Utgang:
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 modulen
Import lar deg importere hele modulen ved å bruke import etterfulgt av modulnavn, dvs. filnavnet eller biblioteket som skal brukes.
Syntaks:
Import module
Eller ved å bruke
from module import *
Mappestrukturen som brukes til å teste koden er som følger:
modtest/ test.py display.py
Følgende er kodedetaljene inne i test.py
my_name = "Guru99" my_address = "Mumbai" defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Bruke importmodulen
Ved å bare bruke importer modulnavn, for å referere til variablene og funksjonene inne i modulen, må den prefikses med modulnavn.
Eksempel
Filnavn: display.py
Import test print(test.display_message()) print(test.display_message1()) print(test.my_name) print(test.my_address)
Modulnavntesten brukes til å referere til funksjonen og variablene inne i modultesten.
Utgang:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Bruker import *
La oss se et eksempel ved å bruke import *. Ved hjelp av import *, er funksjonene og variablene direkte tilgjengelige, som vist i eksemplet nedenfor:
from test import * print(display_message()) print(display_message1()) print(my_name) print(my_address)
Utgang:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
funksjonen dir( ).
dir() er en innebygd funksjon i python. dir() returnerer alle egenskapene og metodene, inkludert det gitte objektets innebygde egenskaper.
Så når dir() brukes på modulen, vil den gi deg variablene, funksjoner som finnes inne i modulen.
Her er et fungerende eksempel på dir() på en modul. Vi har en klasse kalt Car.py, la oss importere Car og tilordne til dir() for å se utdataene.
Mappestrukturen for å 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)
Utdataene gir oss navnet på klassen og alle funksjonene som er definert i Car.py.
Du kan også prøve å bruke dir() på en innebygd modul tilgjengelig i Python. La oss prøve det samme JSON modul som vist i eksempelet nedenfor. Den vil vise alle egenskapene og metodene som er tilgjengelige i JSON modul.
Import json json_details = dir(json) print(json_details)
Utgang:
['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']
Nettsidepakker
En pakke er en katalog med alle moduler definert i den. Å lage en Python tolk behandle den som en pakke, må katalogen din ha init.pyfile. Init.py lager katalogen som en pakke. Her er utformingen av pakken som vi skal jobbe med.
Navnet på pakken er pakken min. For å begynne å jobbe med pakken, lag en katalog kalt package/. Inne i katalogen oppretter du en tom fil kalt __init__.py. Lag ytterligere 3 filer module1.py, module2.py og module3.py og definer funksjonene som vist på skjermbildet. Her er detaljene for modul1.py, modul2.py og modul3.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")
Ocuco pakkeer klar til bruk. Ring nå pakken i hvilken som helst fil som vist nedenfor :test.py:
Her blir mypackage.module1 importert og gitt et aliasnavn som mod1. På samme måte kan du bruke andre moduler module2.py og module3.py fra pakken min.
import mypackage.module1 as mod1 print(mod1.mod1_func1()) print(mod1.mod1_func2()) print(mod1.mod1_func2())
Utgang:
Welcome to Module1 function1 None Welcome to Module1 function2 None Welcome to Module1 function2 None
Vi har nettopp demonstrert pakken med en enkel modul med funksjoner inni den. I henhold til prosjektet ditt kan du også pakke med underpakker. Undermapper/ med moduler med klasser definert.
Python Modulsøkesti
Under utførelse, når python kommer over importer modulnavn, prøver tolken å finne modulen. Den søker etter modulen i listen over innebygde moduler. Later i alt katalogene definert inne i sys.path.
For å oppsummere, gjør tolken følgende søk for å finne modulen:
- I din nåværende katalog.
- Inn i listen over innebygde moduler
- Inne i sys.path-katalogene
Du kan få detaljene til sys.path ved å importere sys-modulen og skrive ut sys.path. Det vil gi deg listen over kataloger som vist nedenfor:
importsys print(sys.path)
Utgang:
['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\ \Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\P ython37\\DLLs']
Du kan også endre banen og beholde katalogene i henhold til dine krav.
Bruker modulalias i importen
Du kan også konvertere modulnavnet til en kortere form ved å gi det et aliasnavn. Aliaset kan gjøres ved å bruke nøkkelordet.
Syntaks:
import filename as alias name
Mappestrukturen for å teste koden vil være som følger:
Mod test/ test.py display.py
Følgende er koden inne i test.py
my_name = "Guru99" my_address = "Mumbai" def display_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Nå vil bruke 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 som brukes for testmodulen er t . Så funksjonen og variablene fra test.py kan refereres ved å bruke aliaset t.
Utgang:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Absolutt og relativ import i Python
Du vet nå hvordan du importerer en fil som en modul i en annen fil. La oss nå se hvordan du administrerer filene som er tilgjengelige i mapper. Filene i mappene kan importeres enten ved å bruke absolutt eller relativ import.
Tenk på at du har din prosjektmappestruktur, som vist nedenfor:
Rotmappen er mitt prosjekt/. Den har to undermapper pakke1 og pakke2.
Mappen pakke1 har to moduler, modul1.py og modul2.py.
Mappen pakke2 har én klasse myclass.py, en underpakke subpkg med module3.py, og siste modul4.py.
- I module1.py er det en funksjon som hetermyfunc1.
- I module2.py er det en funksjon som heter myfunc2.
- I module3.py er det en funksjon kalt myfunc3.
- I module4.py er det en funksjon som heter myfunc4.
Bruk av absolutt import
For absolutt import må du legge til hele banen til modulen din rett fra prosjektets rotmapp.
La oss nå se hvordan du kan bruke absolutt import for å referere til funksjonene som finnes i hver av modulene.
For å jobbe med functionmyfunc1, må du importere som følger:
from package1.module1 import myfunc1 or from package1 import module1 module1.myfunc1()
For å jobbe med funksjonen myfunc3 må du importere som følger:
from package1.subpkg.module3 import myfunc3 or from package1.subpkg import module3 module3.myfunc3()
Fordeler og ulemper ved å bruke absolutt import
Her er fordelene ved å bruke absolutt import:
- Det blir enkelt å spore tilbake modulene for kodesjekk.
- Enkel å bruke og veldig grei.
- Hvis prosjektet flyttes til en annen bane, vil importen fortsatt være den samme.
Ulemper ved å bruke absolutt import
Her er ulempene ved å bruke absolutt import:
Ulemper:
- Importbanen kan bli veldig lang i tilfelle, modulene er nestet, og hvis navnet på modulene er langt.
Bruke relativ import
Med tanke på den samme mappestrukturen som er nevnt nedenfor, vil vi se hvordan du importerer den samme ved å bruke relativ import.
Ved relativ import er modulen som skal importeres relativt til gjeldende plassering som er plasseringen der importsetningen er til stede.
syntax
Ved relativ import må du legge til et punktum (.) før modulnavnet når du importerer med fra.
Det vil gå 2 perioder (..) før modulnavnet hvis modulen er på ett nivå opp fra gjeldende plassering.
Med henvisning til mappestrukturfiguren nevnt ovenfor, har vi følgende moduler med deres funksjon, som vi må referere til.
- I module1.py er det en funksjon som hetermyfunc1.
- I module2.py er det en funksjon som heter myfunc2.
- I module3.py er det en funksjon kalt myfunc3.
- I module4.py er det en funksjon som heter myfunc4.
For å jobbe med functionmyfunc1 må du importere som følger:
from .module1 import myfunc1
For å jobbe med funksjonen myfunc3, må du importere som følger:
from .subpkg.module3 import myfunc3
Fordeler med relativ import
Fordeler:
- Det er enkelt å jobbe med relativ import.
- Fra nåværende sted kan importen forkortes i forhold til absolutt import.
Ulemper ved relativ import
Ulemper:
- Ved å bruke relativ import er det vanskelig å spore tilbake hvor koden ligger
Sammendrag
- Importer inn Python hjelper deg med å referere til koden, dvs. .funksjoner/objekter som er skrevet i en annen fil. Den brukes også til å importere python-biblioteker/-pakker som er installert ved hjelp av pip(python-pakkebehandling), og du må deretter bruke i koden din.
- Importfunksjonalitet er tilgjengelig på andre språk som typescript, JavaScript, java, ruby, etc.
- En modul er python er koden skrevet inne i filen, for eksempel (test.py). Inne i filen din kan du ha variablene, funksjonene eller klassen definert. Hele filen blir en modul og kan importeres inn i en annen fil for å referere til koden.
- Med modulfunksjonalitet kan du bryte koden din i forskjellige filer i stedet for å skrive alt i én fil. Later, ved å bruke import, kan du referere til koden i filen du trenger.
- Python har sine innebygde moduler, og også eksterne biblioteker/pakker installert ved hjelp av en python-pakkebehandler (pip), f.eks. pandaer, NumPy, etc. refereres til som moduler.
- Du kan bare importere en liten del av modulen, dvs. bare de nødvendige funksjonene og variabelnavnene fra modulen i stedet for å importere full kode.
- Du kan også konvertere modulnavnet til en kortere form ved å gi det et aliasnavn. Aliaset kan gjøres ved å bruke nøkkelordet.
- En pakke er en katalog med alle moduler definert i den. Å lage en Python tolk behandle den som en pakke, må katalogen din ha __init.pyfile. Init.py lager katalogen som en pakke. Her er utformingen av pakken som vi skal jobbe med.
- Under utførelse, når python kommer over importer modulnavn, prøver tolken å finne modulen. Den søker etter modulen i listen over innebygde moduler. Later i alt katalogene definert inne i sys.path.
- For absolutt import må du legge til hele banen til modulen din rett fra prosjektets rotmapp.
- Ved relativ import er modulen som skal importeres relativt til gjeldende plassering som er plasseringen der importsetningen er til stede.
