Python-import från en överordnad katalog: En snabbguide

Har du någonsin funnit dig själv i Python-filer och kämpat för att importera en modul från en överordnad katalog? I så fall är du i gott sällskap. Pythons importsystem kan ibland kännas som en vindlande labyrint, men oroa dig inte, vi är här för att hjälpa dig att navigera!

För att importera från en överordnad katalog i Python kan du använda sys- modulen. Genom att infoga den nödvändiga katalogen i sys.path-listan ger du tolken platsen för den önskade modulen. Efter att ha modifierat sys.path kan du importera målmodulen med hjälp av standardimportsatsen.

I den här artikeln kommer vi att utforska hur du kan importera från överordnade kataloger i Python. Dessutom kommer vi att titta på specifika användningsfall för import som hjälper dig att bättre förstå den underliggande strukturen för katalogerna.

Låt oss gå in i det!

Innehållsförteckning

• Hur man importerar i Python
  • Vad är Python Import System?
  • Demonstration av import från överordnad katalog
    • 1. Skapa nödvändiga kataloger och filer
    • 2. Lägga till Python-filer
    • 3. Redigera Python-filerna
    • 4. Köra koden
  • Hur man hanterar ImportError och ModuleNotFoundError i Python
• Python-katalogstruktur
  • Paketets struktur
  • Vad är init.py-filer?
• Python sökväg
  • 1. Vad är sys.path-listan i Python?
  • 2. Vad är PythonPath miljövariabler?
• Import av överordnade kataloger
  • 1. Relativ import
  • 2. Justera sys.path
• Hur man arbetar med moduler och paket
  • 1. Vad är namnutrymmen?
  • 2. Vad är variabler och definitioner?
  • 3. Vad är importutlåtanden?
• Slutgiltiga tankar

Hur man importerar i Python

Vi ska hoppa rakt in i dagens ämne: import i Python. De där enkla kodraderna i början av dina Python-skript som ofta börjar med import eller från ? Det är din biljett till att utnyttja kraften i Pythons omfattande bibliotek och moduler.

I det här avsnittet går vi igenom koden för import från överordnad katalog i Python. Vi kommer också att titta på potentiella fel som kan uppstå vid import av moduler från överordnad katalog.

Vad är Python Import System?

Python-importsystemet möjliggör effektiv återanvändning och organisation av kod. Det gör det lättare för dig att underhålla komplexa projekt.

För att importera en modul eller ett paket i Python kan du använda importsatsen . Moduler distribueras som paket, som är kataloger med en samling Python-filer.

För att importera en modul från den överordnade katalogen kan du använda modulen sys.path för att lägga till den överordnade katalogen till Pythons sökväg. Efter att ha lagt till den överordnade katalogen kan du importera modulen med hjälp av importsatsen .

Demonstration av import från överordnad katalog

För att ge dig en tydlig demonstration av import från överordnad katalog, låt oss gå igenom en rad steg för att hjälpa dig förstå hela processen.

1. Skapa nödvändiga kataloger och filer

Öppna först din filutforskare och navigera till önskad lokala enhet. Jag använder min lokala E-enhet, därför skapar jag en ny katalog som heter my_project .

Skapa en annan katalog med namnet module_dir inuti my_project .

Så nu borde du ha:

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

2. Lägga till Python-filer

Skapa sedan en ny .py- fil med namnet main.py i my_project -katalogen.

Efter det skapar du en annan Python-fil med namnet my_module.py i module_dir .

Din struktur ska nu se ut så här:

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

Om du använder Visual Studio Code bör din katalogstruktur se ut så här:

3. Redigera Python-filerna

Öppna din my_module.py och lägg till följande kod:

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

Gå sedan vidare och spara och stäng filen.

Öppna nu main.py och lägg till följande kod:

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 det här skriptet tar vi först reda på platsen för katalogen en nivå upp från skriptet vi kör (det är den överordnade katalogen). Sedan säger vi till Python att även titta i den här överordnade mappen när den behöver importera moduler.

Efter att ha gjort det importerar vi en modul som heter my_module som finns inuti en katalog som heter module_dir som finns i den här överordnade katalogen. Slutligen anropar vi en funktion som heter min_funktion från min_modul .

När du har lagt till ovanstående kod, spara och stäng filen.

4. Köra koden

För att köra den här koden, öppna önskad kodredigerares terminal och kör filen main.py. Om du använder Visual Studio Code bör utdata se ut så här:

Main.py kommer att importera funktionen från my_module.py , som visas i bilden ovan.

Det här exemplet visar i detalj hur filsystem och import från överordnad katalog fungerar i Python.

Hur man hanterar ImportError och ModuleNotFoundError i Python

Python kommer att skapa ett ImportError- undantag när modulen du försöker importera inte hittas under importprocessen.

ImportError är en underklass till ModuleNotFoundError- undantaget. Den höjs när den importerade modulen inte finns eller inte kan laddas.

Följande är exempel på scenarier när dessa kan inträffa:

• Modulen eller paketet finns inte i sys.path .

• Modulen eller paketnamnet är felstavat eller finns inte.

• Det finns ett problem med modulens kod som förhindrar att den importeras korrekt.

När du stöter på dessa fel kan du använda följande lösningar:

• Dubbelkontrollera stavningen och existensen av modulen eller paketet.

• Lägger till den nödvändiga katalogen till sys.path med append() eller insert() .

• Åtgärda eventuella problem i modulens kod som kan hindra dess import.

För att lära dig mer om att hantera fel i Python, kolla in följande video:

Efter att ha förstått hur import fungerar i Python är det också viktigt att du får lite bekantskap med Pythons katalogstruktur.

Katalogstruktur och import går hand i hand med varandra eftersom import kräver förståelse för katalogstrukturen, så låt oss gå igenom det i nästa avsnitt.

Python-katalogstruktur

Att förstå Python-katalogstrukturen är mer än att bara veta var du ska placera dina skript eller var du kan hitta det biblioteket du just har installerat.

Det är som att ha ett rent, välorganiserat skrivbord: du vet exakt var allt är, och din produktivitet kommer att skjuta i höjden, så låt oss gå igenom grunderna i det här avsnittet.

Paketets struktur

Katalogstrukturen för ett Python-projekt är avgörande för korrekt organisation. Om du strukturerar ditt paket på rätt sätt hjälper det dig att minimera risken för namnkonflikter. Dessutom kommer det också att göra det möjligt för dig att enkelt navigera genom ditt filsystem.

Följande är en typisk Python-projektkatalogstruktur:

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

I exemplet ovan är project rotkatalogen som innehåller två underpaket, paket1 och paket2 . Varje paket har sina .py- filer och en unik init.py- fil.

Vad är init.py-filer?

init.py- filer är viktiga för att definiera paketets beteende när det importeras. Dessa filer körs när deras överordnade paket importeras.

Init.py - filerna kan vara tomma eller innehålla initialiseringskod. De indikerar också för Python att mappen ska behandlas som ett paket.

För att importera en modul från en överordnad katalog kan du använda metoden sys.path . Du måste lägga till den överordnade katalogsökvägen till sys.path .

För att demonstrera detta, låt oss bygga vidare på vårt tidigare exempel. Vi hade följande katalogstruktur:

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

Låt oss nu lägga till filen init.py i katalogen my_module . Du kan lämna den här filen tom tills vidare. Dess närvaro indikerar för Python att denna katalog bör behandlas som ett paket.

Din katalogstruktur bör nu se ut så här:

Efter att ha lagt till filen init.py måste du göra ändringar i filen main.py för att instruera den att behandla mappen module_dir som ett paket. Din main.py -fil bör nu ha följande kod:

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 det här exemplet importerar main.py paketet module_dir och anropar sedan funktionen my_function() från my_module i det paketet.

Notera ändringen i anropet till my_function ; eftersom vi nu behandlar module_dir som ett paket, måste vi inkludera paketnamnet när vi anropar funktioner från moduler i paketet.

Utgången kommer att likna den föregående. Den enda ändringen vi gjorde var att behandla module_dir som ett paket med inkludering av filen init.py.

Python sökväg

Har du någonsin undrat hur Python vet var man hittar modulerna du försöker importera? Eller kanske du har stött på ett irriterande "ModuleNotFoundError" och inte kunde ta reda på varför?

I det här avsnittet kommer vi att ta itu med dessa mysterier direkt och fördjupa oss i konceptet med Python-sökvägen.

Python-sökvägen, även känd som sys.path , är Pythons lilla färdplan för att hitta alla moduler du behöver. Som en flitig scout använder Python den här sökvägen för att leta igenom din dator efter moduler när du använder importsatsen.

Att förstå hur det fungerar kan rädda dig från huvudvärk och hjälpa dig att felsöka när saker går snett, så låt oss gå igenom några grunder!

1. Vad är sys.path-listan i Python?

Sys.path - listan är en avgörande komponent vid import av moduler i en katalog. Det är en lista med strängar som representerar modulens sökväg.

Varje sträng i raden letar efter moduler ( *.py -filer) eller paket (mappar som innehåller init.py- filer).

Följande exempel visar hur du visar din nuvarande sys.path- lista:

import sys

for path in sys.path:
    print(path)

Efter att ha kört ovanstående kod kommer du att se en utdata som följande:

Du kan också lägga till nya kataloger till sys.path -listan så att Python hittar dina anpassade moduler.

Till exempel:

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

2. Vad är PythonPath miljövariabler?

Ett annat sätt att hantera modulens sökväg är att använda miljövariabeln PYTHONPATH .

PYTHON PATH är en sträng som innehåller en av kataloger som läggs till standard sys.path -listan. Det betyder att du kan lägga till kataloger till PYTHONPATH. Detta gör att Python kan söka efter moduler i dessa kataloger vid import.

Att ställa in miljövariabeln PYTHONPATH beror på ditt operativsystem:

• Unix-baserade system (Linux, macOS) : Du kan använda exportkommandot i din terminal eller lägga till följande rad i din skalkonfigurationsfil ( .bashrc , .zshrc eller liknande):

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

• Windows OS : Gå till Systemegenskaper > Miljövariabler och under Användarvariabler klickar du på Ny för att skapa en ny variabel med namnet: "PYTHONPATH" och värdet som en lista över katalogsökvägar separerade med semikolon (;).

  C:pathtomoduledirectory1;C:pathtomoduledirectory2
  

När sökvägsvariabeln är inställd kan du köra ditt Python-skript. Den kommer att söka efter importerade moduler i dessa kataloger såväl som standardmodulerna i sys.path .

När du organiserar din kod i filer och mappar kommer du ofta att stöta på relativ import och justering av sys.path .

I nästa avsnitt kommer vi att utforska båda och se hur de passar in i ramverket för Python-import.

Import av överordnade kataloger

Du kan organisera kod i olika mappar och filer för att förbättra både läsbarheten och underhållbarheten. Det kan dock vara lite knepigt att importera moduler från överordnade kataloger.

I det här avsnittet kommer vi att diskutera två metoder för att uppnå detta:

1. Relativ import

2. Justerar sys.path

1. Relativ import

Relativ import låter dig importera moduler baserat på deras relativa position i kataloghierarkin.

Du kan använda punktnotationen ( . ) för att referera till den aktuella katalogen eller dubbelpunktsnotationen ( .. ) för att referera till den överordnade katalogen.

Anta att du har en katalogstruktur som följande:

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

Inuti module_b.py kan du använda relativ import för att komma åt module_a.py :

from .. import module_a

Dubbelpunkten hänvisar till den överordnade katalogen. Det är viktigt att notera att relativ import endast fungerar om den överordnade katalogen är ett paket (har en init.py- fil).

2. Justera sys.path

Du kan också importera moduler från en överordnad katalog genom att ändra sys.path .

Innan importsatsen kan du lägga till den överordnade katalogsökvägen till sys.path . Först måste du importera sys- modulen. Sedan använder du OS- modulen för att få den överordnade katalogsökvägen.

Anta att du har en katalogstruktur som följande:

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

I module_b.py kan du lägga till den överordnade katalogsökvägen till sys.path så här:

import os
import sys

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

import module_a

Nu kommer Python att leta efter module_a.py i den överordnade katalogen när den importeras i module_b.py .

Du kan använda antingen den relativa importmetoden eller sys.path -metoden för att importera moduler från en överordnad katalog.

Hur man arbetar med moduler och paket

I Python är moduler och paket ett sätt att organisera och återanvända kod. Du kan använda dem för att dela upp komplexa projekt i hanterbara delar.

Det här avsnittet kommer att diskutera hur man arbetar med moduler och paket i . Vi kommer också att ta med nyckelbegrepp som:

1. Namnutrymmen

2. Variabler och definitioner

3. Importutdrag

1. Vad är namnutrymmen?

Namnutrymmen i Python är ett sätt att säkerställa att namnen på variabler, funktioner och klasser inte kommer i konflikt mellan olika moduler.

Det finns olika nivåer av namnutrymmen i Python, till exempel:

• Globalt namnområde: Avser namnområdet för hela modulen.

• Lokalt namnområde: Avser namnområdet inom en funktion eller klass.

Du kan få ett namn i ett visst namnområde med notationen namnområde[namn] .

2. Vad är variabler och definitioner?

I ett Python-skript kan du definiera variabler, och klasser. Dessa definitioner lagras i skriptets namnutrymme.

Genom att importera skriptet som ett paket kan du komma åt och återanvända dess definitioner i andra delar av ditt projekt.

Följande är ett exempel på hur man definierar en variabel och en funktion i samma namnområde:

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

Denna modul har en variabel min_variabel och en funktion min_funktion .

För att köra den här koden kan du skapa en ny fil med namnet my_variable.py och lägga koden där som visas nedan:

Nu kan du importera den här filen och använda den i ett annat skript som visas nedan:

Efter att ha kört filen main.py får du en utdata som liknar följande :

3. Vad är importutlåtanden?

Du kan importera filer , moduler eller paket i Python med importsatsen

Några vanliga importmetoder är:

• import modulnamn : Denna metod importerar en modul, vilket gör alla dess definitioner tillgängliga med notationen modulnamn.definitionsnamn .

import mymodule

result = mymodule.my_function(3)

• from module_name import some_definition : Denna metod importerar en specifik definition från en modul, så att du kan använda den direkt utan modulprefixet.

from mymodule import my_function

result = my_function(3)

• from modulnamn import * : Denna metod importerar alla definitioner från en modul, men det rekommenderas inte eftersom det kan leda till namnkonflikter.

Slutgiltiga tankar

Att förstå hur man importerar från en överordnad katalog i Python är viktigt för att upprätthålla en organiserad kodbas.

Denna kunskap gör att du kan designa dina projekt på ett mer modulärt sätt. Det ökar också återanvändbarheten av din kod. Genom att strukturera din kod i separata moduler och paket kan du undvika att upprepa kod och göra det lättare att underhålla och uppdatera.

Förmågan att använda import- och från -satser är mest värdefull när du arbetar med större projekt där funktioner är uppdelade över olika kataloger.

Genom att veta hur man korrekt justerar Pythons sökväg för att importera moduler kan du komma åt funktioner som definieras i en katalog medan du arbetar i en annan.

Kom ihåg att nyckeln till att bemästra Python - eller vilket programmeringsspråk som helst - ligger i konsekvent övning och omättlig nyfikenhet. Så fortsätt att utforska, fortsätt experimentera och fortsätt utmana dig själv.

Med den här snabbguiden bör du vara väl rustad att hantera alla importpussel som Python kastar på dig. Men sluta inte här. Det finns ett helt universum av Python-tekniker och trick som väntar på att bli upptäckt!