Python-import fra en overordnet katalog: En hurtigveiledning

Har du noen gang funnet deg selv til kne i Python-filer, og sliter med å importere en modul fra en overordnet katalog? I så fall er du i godt selskap. Pythons importsystem kan noen ganger føles som en svingete labyrint, men ikke bekymre deg, vi er her for å hjelpe deg med å navigere!

For å importere fra en overordnet katalog i Python, kan du bruke sys- modulen. Ved å sette inn den nødvendige katalogen i sys.path-listen, gir du tolken plasseringen til ønsket modul. Etter å ha modifisert sys.path, kan du importere målmodulen ved å bruke standard importsetning.

I denne artikkelen skal vi utforske hvordan du kan importere fra overordnede kataloger i Python. Videre vil vi se på spesifikke brukstilfeller for import som vil hjelpe deg å bedre forstå den underliggende strukturen til katalogene.

La oss komme inn i det!

Innholdsfortegnelse

• Hvordan importere i Python
  • Hva er Python Import System?
  • Demonstrasjon av import fra overordnet katalog
    • 1. Opprette nødvendige kataloger og filer
    • 2. Legge til Python-filer
    • 3. Redigere Python-filene
    • 4. Kjøre koden
  • Hvordan håndtere ImportError og ModuleNotFoundError i Python
• Python-katalogstruktur
  • Pakkestruktur
  • Hva er init.py-filer?
• Python-søkesti
  • 1. Hva er sys.path-listen i Python?
  • 2. Hva er PythonPath miljøvariabler?
• Overordnet katalogimport
  • 1. Relativ import
  • 2. Justere sys.path
• Hvordan jobbe med moduler og pakker
  • 1. Hva er navnerom?
  • 2. Hva er variabler og definisjoner?
  • 3. Hva er importerklæringer?
• Siste tanker

Hvordan importere i Python

Vi skal hoppe rett inn i dagens emne: import i Python. De enkle kodelinjene i begynnelsen av Python-skriptene dine som ofte begynner med import eller fra ? Dette er din billett til å utnytte kraften til Pythons omfattende biblioteker og moduler.

I denne delen vil vi gå over koden for import fra overordnet katalog i Python. Vi vil også se på potensielle feil som kan oppstå ved import av moduler fra overordnet katalog.

Hva er Python Import System?

Python-importsystemet tillater effektiv gjenbruk og organisering av kode. Det gjør det lettere for deg å vedlikeholde komplekse prosjekter.

For å importere en modul eller pakke i Python kan du bruke importsetningen . Moduler distribueres som pakker, som er kataloger med en samling av Python-filer.

For å importere en modul fra den overordnede katalogen, kan du bruke sys.path- modulen til å legge til den overordnede katalogen til Pythons bane. Etter å ha lagt til den overordnede katalogen, kan du importere modulen ved å bruke importsetningen .

Demonstrasjon av import fra overordnet katalog

For å gi deg en tydelig demonstrasjon av import fra overordnet katalog, la oss gå gjennom en rekke trinn for å hjelpe deg å forstå hele prosessen.

1. Opprette nødvendige kataloger og filer

Først åpner du filutforskeren og navigerer til ønsket lokale stasjon. Jeg bruker min lokale E-stasjon, derfor vil jeg opprette en ny katalog kalt my_project .

Inne i mitt_prosjekt oppretter du en annen katalog kalt module_dir .

Så du bør nå ha:

E:
|-- /my_project
    |-- /module_dir

2. Legge til Python-filer

Deretter oppretter du en ny .py- fil med navnet main.py i my_project- katalogen.

Etter det oppretter du en annen Python-fil kalt my_module.py i module_dir .

Strukturen din skal nå se slik ut:

E:
|-- /my_project
    |-- main.py
    |-- /module_dir
        |-- my_module.py

Hvis du bruker Visual Studio Code , skal katalogstrukturen se slik ut:

3. Redigere Python-filene

Åpne my_module.py og legg til følgende kode:

def my_function():
    print("Hello from my_module!")

Så fortsett og lagre og lukk filen.

Åpne nå main.py og legg til følgende kode:

import sys
import os

# Get the parent directory
parent_dir = os.path.dirname(os.path.realpath(__file__))

# Add the parent directory to sys.path
sys.path.append(parent_dir)

# Import the module from the parent directory
from module_dir import my_module

# Use a function from my_module
my_module.my_function()

I dette skriptet finner vi først ut plasseringen av katalogen ett nivå opp fra skriptet vi kjører (det er den overordnede katalogen). Deretter ber vi Python også se i denne overordnede mappen når den trenger å importere moduler.

Etter å ha gjort det, importerer vi en modul kalt my_module som er inne i en katalog kalt module_dir som ligger i denne overordnede katalogen. Til slutt kaller vi en funksjon kalt min_funksjon fra min_modul .

Etter å ha lagt til koden ovenfor, lagre og lukk filen.

4. Kjøre koden

For å kjøre denne koden, åpne ønsket koderedigeringsterminal og kjør filen main.py. Hvis du bruker Visual Studio Code, skal utdataene se slik ut:

Main.py vil importere funksjonen fra my_module.py , som vist i bildet ovenfor.

Dette eksemplet viser i detalj hvordan filsystem og import fra overordnet katalog fungerer i Python.

Hvordan håndtere ImportError og ModuleNotFoundError i Python

Python vil opprette et ImportError- unntak når modulen du prøver å importere ikke blir funnet under importprosessen.

ImportError er en underklasse av ModuleNotFoundError- unntaket. Den heves når den importerte modulen ikke eksisterer eller ikke kan lastes.

Følgende er eksempler på scenarier når disse kan forekomme:

• Modulen eller pakken er ikke i sys.path .

• Modulen eller pakkenavnet er feilstavet eller eksisterer ikke.

• Det er et problem med modulens kode som forhindrer at den blir riktig importert.

Når du støter på disse feilene, kan du bruke følgende løsninger:

• Dobbeltsjekke stavemåten og eksistensen av modulen eller pakken.

• Legger til den nødvendige katalogen til sys.path ved hjelp av append() eller insert() .

• Å fikse eventuelle problemer i modulens kode som kan hindre importen av den.

For å lære mer om håndtering av feil i Python, sjekk følgende video:

Etter å ha forstått hvordan import fungerer i Python, er det også viktig at du får litt kjennskap til Pythons katalogstruktur.

Katalogstruktur og import går hånd i hånd med hverandre ettersom import krever en forståelse av katalogstrukturen, så la oss gå over det i neste avsnitt.

Python-katalogstruktur

Å forstå Python-katalogstrukturen er mer enn bare å vite hvor du skal plassere skriptene dine eller hvor du finner det biblioteket du nettopp installerte.

Det er som å ha et rent, godt organisert skrivebord: du vet nøyaktig hvor alt er, og produktiviteten din vil skyte i været, så la oss gå gjennom det grunnleggende i denne delen.

Pakkestruktur

Katalogstrukturen til et Python-prosjekt er avgjørende for riktig organisering. Hvis du strukturerer pakken din riktig, vil det hjelpe deg med å minimere sjansen for navnekonflikter. Videre vil det også gjøre det mulig for deg å enkelt navigere gjennom filsystemet ditt.

Følgende er en typisk Python-prosjektkatalogstruktur:

project/
?
??? package1/
?   ??? __init__.py
?   ??? module1.py
?   ??? module2.py
?
??? package2/
?   ??? __init__.py
?   ??? module3.py
?   ??? module4.py
?
??? main.py

I eksemplet ovenfor er prosjekt rotkatalogen som inneholder to underpakker, pakke1 og pakke2 . Hver pakke har sine .py- filer og en unik init.py- fil.

Hva er init.py-filer?

init.py- filer er viktige for å definere pakkens oppførsel når den importeres. Disse filene kjøres når deres overordnede pakke importeres.

Init.py - filene kan være tomme eller inneholde initialiseringskode. De indikerer også overfor Python at mappen skal behandles som en pakke.

For å importere en modul fra en overordnet katalog, kan du bruke sys.path -metoden. Du må legge til den overordnede katalogbanen til sys.path .

For å demonstrere dette, la oss bygge videre på vårt forrige eksempel. Vi hadde følgende katalogstruktur:

E:
|-- /my_project
    |-- main.py
    |-- /module_dir
        |-- my_module.py

La oss nå legge til filen init.py i my_module- katalogen. Du kan la denne filen stå tom for nå. Dens tilstedeværelse indikerer for Python at denne katalogen bør behandles som en pakke.

Katalogstrukturen din skal nå se slik ut:

Etter å ha lagt til filen init.py , må du gjøre endringer i main.py- filen din for å instruere den om å behandle module_dir- mappen som en pakke. Main.py- filen din skal nå ha følgende kode:

import sys
import os

# Get the parent directory
parent_dir = os.path.dirname(os.path.realpath(__file__))

# Add the parent directory to sys.path
sys.path.append(parent_dir)

# Import my_module from the package module_dir
import module_dir

# Call my_function from my_module
my_module.my_function()

I dette eksemplet importerer main.py pakken module_dir , og kaller deretter funksjonen min_funksjon() fra min_modul i den pakken.

Legg merke til endringen i kallet til my_function ; fordi vi nå behandler module_dir som en pakke, må vi inkludere pakkenavnet når vi kaller funksjoner fra moduler i pakken.

Utgangen vil være lik den forrige. Den eneste endringen vi gjorde var å behandle module_dir som en pakke med inkludering av filen init.py.

Python-søkesti

Har du noen gang lurt på hvordan Python vet hvor du finner modulene du prøver å importere? Eller kanskje du har støtt på en irriterende 'ModuleNotFoundError' og ikke kunne finne ut hvorfor?

I denne delen skal vi takle disse mysteriene direkte og fordype oss i konseptet med Python-søkebanen.

Python-søkebanen, også kjent som sys.path , er Pythons lille veikart for å finne alle modulene du trenger. Som en flittig speider bruker Python denne banen til å lete etter moduler på datamaskinen din hver gang du bruker importsetningen.

Å forstå hvordan det fungerer kan spare deg for hodepine og hjelpe deg med å feilsøke når ting går galt, så la oss gå gjennom litt grunnleggende!

1. Hva er sys.path-listen i Python?

Sys.path - listen er en avgjørende komponent ved import av moduler i en katalog. Det er en liste over strenger som representerer modulsøkebanen.

Hver streng i søket ser etter moduler ( *.py -filer) eller pakker (mapper som inneholder init.py -filer).

Følgende eksempel viser deg hvordan du viser din nåværende sys.path- liste:

import sys

for path in sys.path:
    print(path)

Etter å ha kjørt koden ovenfor, vil du se en utgang som følgende:

Du kan også legge til nye kataloger til sys.path- listen slik at Python finner de tilpassede modulene dine.

For eksempel:

import sys
sys.path.append('/path/to/new/module/directory')

2. Hva er PythonPath miljøvariabler?

En annen måte du kan administrere modulsøkebanen på er ved å bruke miljøvariabelen PYTHONPATH .

PYTHON PATH er en streng som inneholder en av kataloger som er lagt til standard sys.path- listen. Dette betyr at du kan legge til kataloger til PYTHONPATH. Dette lar Python søke etter moduler i disse katalogene ved import.

Innstilling av miljøvariabelen PYTHONPATH avhenger av operativsystemet ditt:

• Unix-baserte systemer (Linux, macOS) : Du kan bruke eksportkommandoen i terminalen eller legge til følgende linje i skallkonfigurasjonsfilen ( .bashrc , .zshrc eller lignende):

  export PYTHONPATH="/path/to/module/directory1:/path/to/module/directory2"

• Windows OS : Gå til Systemegenskaper > Miljøvariabler , og under Brukervariabler , klikk Ny for å lage en ny variabel med navnet: "PYTHONPATH" og verdien som en liste over katalogstier atskilt med semikolon (;).

  C:pathtomoduledirectory1;C:pathtomoduledirectory2
  

Når banevariabelen er angitt, kan du kjøre Python-skriptet ditt. Den vil søke etter importerte moduler i disse katalogene så vel som standardmodulene i sys.path .

Når du organiserer koden din i filer og mapper, vil du ofte komme over relativ import og justering av sys.path .

I neste avsnitt skal vi utforske begge og se hvordan de passer inn i rammeverket for Python-import.

Overordnet katalogimport

Du kan organisere kode i forskjellige mapper og filer for å forbedre både lesbarhet og vedlikehold. Imidlertid kan det være litt vanskelig å importere moduler fra overordnede kataloger.

I denne delen vil vi diskutere to tilnærminger for å oppnå dette:

1. Relativ import

2. Justerer sys.path

1. Relativ import

Relativ import lar deg importere moduler basert på deres relative plassering i kataloghierarkiet.

Du kan bruke punktnotasjonen ( . ) for å referere til gjeldende katalog eller dobbelpunktnotasjonen ( .. ) for å referere til overordnet katalog.

Anta at du har en katalogstruktur som følgende:

parent_directory/
?
??? module_a.py
?
??? sibling_directory/
    ??? module_b.py

Inne i module_b.py kan du bruke relativ import for å få tilgang til module_a.py :

from .. import module_a

Den doble prikken refererer til overordnet katalog. Det er viktig å merke seg at relativ import bare fungerer hvis den overordnede katalogen er en pakke (har en init.py- fil).

2. Justere sys.path

Du kan også importere moduler fra en overordnet katalog ved å endre sys.path .

Før importsetningen kan du legge til den overordnede katalogbanen til sys.path . Først må du importere sys- modulen. Deretter bruker du os -modulen for å få den overordnede katalogbanen.

Anta at du har en katalogstruktur som følgende:

project_root/
?
??? parent_directory/
?   ??? module_a.py
?
??? current_directory/
    ??? module_b.py

I module_b.py kan du legge til den overordnede katalogbanen til sys.path slik:

import os
import sys

parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(parent_dir)

import module_a

Nå vil Python se etter module_a.py i den overordnede katalogen når den importeres i module_b.py .

Du kan bruke enten den relative importtilnærmingen eller sys.path- tilnærmingen for å importere moduler fra en overordnet katalog.

Hvordan jobbe med moduler og pakker

I Python er moduler og pakker en måte å organisere og gjenbruke kode på. Du kan bruke dem til å dele opp komplekse prosjekter i håndterbare deler.

Denne delen vil diskutere hvordan du arbeider med moduler og pakker i . Vi vil også inkludere nøkkelbegreper som:

1. Navneområder

2. Variabler og definisjoner

3. Importerklæringer

1. Hva er navnerom?

Navneområder i Python er en måte å sikre at navnene på variabler, funksjoner og klasser ikke er i konflikt mellom ulike moduler.

Det er forskjellige nivåer av navnerom i Python, for eksempel:

• Globalt navneområde: Refererer til navneområdet til hele modulen.

• Lokalt navneområde: Refererer til navneområdet i en funksjon eller klasse.

Du kan få et navn i et bestemt navneområde med navneområdet[navn] -notasjonen.

2. Hva er variabler og definisjoner?

I et Python-skript kan du definere variabler, og klasser. Disse definisjonene er lagret i navnerommet til skriptet.

Ved å importere skriptet som en pakke, kan du få tilgang til og gjenbruke definisjonene i andre deler av prosjektet.

Følgende er et eksempel på hvordan du definerer en variabel og en funksjon i samme navneområde:

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

Denne modulen har en variabel min_variabel og en funksjon min_funksjon .

For å kjøre denne koden kan du opprette en ny fil med navnet my_variable.py og legge koden der som vist nedenfor:

Nå kan du importere denne filen og bruke den i et annet skript som vist nedenfor:

Etter å ha kjørt main.py- filen, får du en utdata som ligner på følgende:

3. Hva er importerklæringer?

Du kan importere filer, moduler eller pakker i Python med importsetningen

Noen vanlige importmetoder er:

• import modulnavn : Denne metoden importerer en modul, og gjør alle definisjonene tilgjengelige med notasjonen modulnavn.definisjonsnavn .

import mymodule

result = mymodule.my_function(3)

• from module_name import some_definition : Denne metoden importerer en spesifikk definisjon fra en modul, slik at du kan bruke den direkte uten modulprefikset.

from mymodule import my_function

result = my_function(3)

• fra modulnavn import * : Denne metoden importerer alle definisjoner fra en modul, men det anbefales ikke da det kan føre til navnekonflikter.

Siste tanker

Å forstå hvordan du importerer fra en overordnet katalog i Python er viktig for å opprettholde en organisert kodebase.

Denne kunnskapen lar deg designe prosjektene dine på en mer modulær måte. Det øker også gjenbrukbarheten til koden din. Ved å strukturere koden din i separate moduler og pakker kan du unngå å gjenta koden og gjøre det enklere å vedlikeholde og oppdatere.

Ferdigheten til å bruke import- og fra -setninger er mest verdifull når du jobber med større prosjekter der funksjonaliteten er delt på tvers av forskjellige kataloger.

Ved å vite hvordan du korrekt justerer Pythons bane for å importere moduler, kan du få tilgang til funksjonaliteter definert i en katalog mens du arbeider i en annen.

Husk at nøkkelen til å mestre Python - eller et hvilket som helst programmeringsspråk - ligger i konsekvent praksis og umettelig nysgjerrighet. Så fortsett å utforske, fortsett å eksperimentere og fortsett å utfordre deg selv.

Med denne hurtigguiden bør du være godt rustet til å håndtere alle importoppgaver Python kaster etter deg. Men ikke stopp her. Det er et helt univers av Python-teknikker og triks som venter på å bli oppdaget!