Python-import fra en overordnet mappe: En hurtig vejledning

Har du nogensinde fundet dig selv i knæet i Python-filer og kæmper for at importere et modul fra en overordnet mappe? Hvis ja, er du i godt selskab. Pythons importsystem kan nogle gange føles som en snoet labyrint, men bare rolig, vi er her for at hjælpe dig med at navigere!

For at importere fra en overordnet mappe i Python kan du bruge sys- modulet. Ved at indsætte den nødvendige mappe i sys.path-listen giver du tolken placeringen af ​​det ønskede modul. Efter at have ændret sys.path, kan du importere målmodulet ved hjælp af standard importerklæringen.

I denne artikel vil vi undersøge, hvordan du kan importere fra overordnede mapper i Python. Desuden vil vi se på specifikke brugstilfælde af import, som vil hjælpe dig med bedre at forstå den underliggende struktur af mapperne.

Lad os komme ind i det!

Indholdsfortegnelse

• Sådan importeres i Python
  • Hvad er Python Import System?
  • Demonstration af import fra overordnet bibliotek
    • 1. Oprettelse af de nødvendige mapper og filer
    • 2. Tilføjelse af Python-filer
    • 3. Redigering af Python-filerne
    • 4. Kørsel af koden
  • Sådan håndteres ImportError og ModuleNotFoundError i Python
• Python-katalogstruktur
  • Pakkestruktur
  • Hvad er init.py-filer?
• Python søgesti
  • 1. Hvad er sys.path-listen i Python?
  • 2. Hvad er PythonPath miljøvariabler?
• Overordnet katalogimport
  • 1. Relativ import
  • 2. Justering af sys.path
• Sådan arbejder du med moduler og pakker
  • 1. Hvad er navnerum?
  • 2. Hvad er variabler og definitioner?
  • 3. Hvad er importerklæringer?
• Afsluttende tanker

Sådan importeres i Python

Vi vil springe direkte ind i dagens emne: import i Python. Disse enkle kodelinjer i begyndelsen af ​​dine Python-scripts, der ofte begynder med import eller fra ? Det er din billet til at udnytte kraften i Pythons omfattende biblioteker og moduler.

I dette afsnit gennemgår vi koden til import fra overordnet bibliotek i Python. Vi vil også se på potentielle fejl, der kan opstå ved import af moduler fra overordnet bibliotek.

Hvad er Python Import System?

Python-importsystemet tillader effektiv genbrug og organisering af kode. Det gør det nemmere for dig at vedligeholde komplekse projekter.

For at importere et modul eller en pakke i Python kan du bruge importerklæringen . Moduler distribueres som pakker, som er mapper med en samling af Python-filer.

For at importere et modul fra det overordnede bibliotek kan du bruge sys.path- modulet til at tilføje det overordnede bibliotek til Pythons sti. Efter tilføjelse af det overordnede bibliotek kan du importere modulet ved hjælp af import- sætningen.

Demonstration af import fra overordnet bibliotek

For at give dig en klar demonstration af import fra overordnet bibliotek, lad os gennemgå en række trin for at hjælpe dig med at forstå hele processen.

1. Oprettelse af de nødvendige mapper og filer

Åbn først din filstifinder og naviger til dit ønskede lokale drev. Jeg bruger mit lokale E-drev, derfor vil jeg oprette en ny mappe ved navn my_project .

Inde i mit_projekt skal du oprette en anden mappe ved navn module_dir .

Så nu skulle du have:

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

2. Tilføjelse af Python-filer

Opret derefter en ny .py- fil med navnet main.py i my_project- mappen.

Derefter skal du oprette en anden Python-fil ved navn my_module.py i module_dir .

Din struktur skulle nu se sådan ud:

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

Hvis du bruger Visual Studio Code , skal din mappestruktur se sådan ud:

3. Redigering af Python-filerne

Åbn din my_module.py og tilføj følgende kode:

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

Så gå videre og gem og luk filen.

Åbn nu main.py og tilføj 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 script er vi først ved at finde ud af placeringen af ​​biblioteket et niveau højere end det script, vi kører (det er den overordnede mappe). Så fortæller vi Python også at kigge i denne overordnede mappe, når den skal importere moduler.

Efter at have gjort det, importerer vi et modul ved navn my_module , der er inde i en mappe kaldet modul_dir , der er placeret i denne overordnede mappe. Til sidst kalder vi en funktion ved navn min_funktion fra mit_modul .

Når du har tilføjet ovenstående kode, skal du gemme og lukke filen.

4. Kørsel af koden

For at køre denne kode skal du åbne din ønskede kodeeditors terminal og køre filen main.py. Hvis du bruger Visual Studio Code, skal outputtet se ud som følgende:

Main.py vil importere funktionen fra my_module.py , som vist på billedet ovenfor .

Dette eksempel viser i detaljer, hvordan filsystem og import fra overordnet bibliotek fungerer i Python.

Sådan håndteres ImportError og ModuleNotFoundError i Python

Python vil rejse en ImportError- undtagelse, når modulet, du forsøger at importere, ikke findes under importprocessen.

ImportError er en underklasse af ModuleNotFoundError- undtagelsen. Det hæves, når det importerede modul ikke eksisterer eller ikke kan indlæses.

Følgende er eksempler på scenarier, hvor disse kan forekomme:

• Modulet eller pakken er ikke i sys.path .

• Modulet eller pakkenavnet er stavet forkert eller eksisterer ikke.

• Der er et problem med modulets kode, der forhindrer det i at blive korrekt importeret.

Når du støder på disse fejl, kan du bruge følgende løsninger:

• Dobbelttjek stavningen og eksistensen af ​​modulet eller pakken.

• Tilføjelse af den nødvendige mappe til sys.path ved hjælp af append() eller insert() .

• Løsning af eventuelle problemer i modulets kode, der kan hindre dets import.

For at lære mere om håndtering af fejl i Python, se følgende video:

Efter at have forstået, hvordan import fungerer i Python, er det også vigtigt, at du opnår en vis fortrolighed med Pythons mappestruktur.

Katalogstruktur og import går hånd i hånd med hinanden, da import kræver en forståelse af biblioteksstrukturen, så lad os gennemgå det i næste afsnit.

Python-katalogstruktur

At forstå Python-biblioteksstrukturen er mere end blot at vide, hvor du skal placere dine scripts, eller hvor du kan finde det bibliotek, du lige har installeret.

Det er som at have et rent, velorganiseret skrivebord: du ved præcis, hvor alt er, og din produktivitet vil stige i vejret, så lad os gennemgå det grundlæggende i dette afsnit.

Pakkestruktur

Biblioteksstrukturen i et Python-projekt er afgørende for korrekt organisation. Hvis du strukturerer din pakke korrekt, hjælper det dig med at minimere risikoen for navnekonflikter. Desuden vil det også give dig mulighed for nemt at navigere gennem dit filsystem.

Følgende er en typisk Python-projektmappestruktur:

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

I eksemplet ovenfor er projekt rodmappen, der indeholder to underpakker, pakke1 og pakke2 . Hver pakke har sine .py- filer og en unik init.py- fil.

Hvad er init.py-filer?

init.py- filer er vigtige for at definere pakkens adfærd, når den importeres. Disse filer udføres, når deres overordnede pakke importeres.

Init.py - filerne kan være tomme eller indeholde initialiseringskode. De angiver også over for Python, at mappen skal behandles som en pakke.

For at importere et modul fra en overordnet mappe kan du bruge sys.path- metoden. Du skal tilføje den overordnede mappesti til sys.path .

For at demonstrere dette, lad os bygge videre på vores tidligere eksempel. Vi havde følgende mappestruktur:

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

Lad os nu tilføje filen init.py til mappen my_module . Du kan lade denne fil være tom indtil videre. Dens tilstedeværelse indikerer for Python, at denne mappe skal behandles som en pakke.

Din mappestruktur skulle nu se sådan ud:

Efter at have tilføjet filen init.py , skal du foretage ændringer i din main.py- fil for at instruere den i at behandle module_dir- mappen som en pakke. Din main.py- fil skulle nu have 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 eksempel importerer main.py pakken module_dir og kalder derefter funktionen my_function() fra my_module i den pakke.

Bemærk ændringen i opkaldet til my_function ; fordi vi nu behandler module_dir som en pakke, er vi nødt til at inkludere pakkenavnet, når vi kalder funktioner fra moduler i pakken.

Outputtet vil ligne den forrige. Den eneste ændring, vi lavede, var at behandle module_dir som en pakke med inklusion af filen init.py.

Python søgesti

Har du nogensinde spekuleret på, hvordan Python ved, hvor man kan finde de moduler, du prøver at importere? Eller måske har du stødt på en irriterende 'ModuleNotFoundError' og ikke kunne finde ud af hvorfor?

I dette afsnit skal vi tackle disse mysterier direkte og dykke ned i konceptet med Python-søgestien.

Python-søgestien, også kendt som sys.path , er Pythons lille køreplan til at finde alle de moduler, du har brug for. Som en flittig spejder bruger Python denne sti til at gennemsøge din computer for moduler, hver gang du bruger importerklæringen.

At forstå, hvordan det fungerer, kan spare dig for hovedpine og hjælpe dig med at fejlfinde, når tingene går skævt, så lad os gennemgå nogle grundlæggende ting!

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

Sys.path - listen er en afgørende komponent ved import af moduler i en mappe. Det er en liste over strenge, der repræsenterer modulets søgesti.

Hver streng i søgningen leder efter moduler ( *.py- filer) eller pakker (mapper, der indeholder init.py- filer).

Følgende eksempel viser dig, hvordan du får vist din nuværende sys.path- liste:

import sys

for path in sys.path:
    print(path)

Efter at have kørt ovenstående kode, vil du se et output som følgende:

Du kan også tilføje nye mapper til sys.path- listen, så Python finder dine brugerdefinerede moduler.

For eksempel:

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

2. Hvad er PythonPath miljøvariabler?

En anden måde, du kan administrere modulets søgesti på, er ved at bruge miljøvariablen PYTHONPATH .

PYTHON PATH er en streng, der indeholder en af ​​mapper, der er tilføjet til standard sys.path- listen. Det betyder, at du kan tilføje mapper til PYTHONPATH. Dette giver Python mulighed for at søge efter moduler i disse mapper ved import.

Indstilling af miljøvariablen PYTHONPATH afhænger af dit operativsystem:

• Unix-baserede systemer (Linux, macOS) : Du kan bruge eksportkommandoen i din terminal eller tilføje følgende linje til din shell-konfigurationsfil ( .bashrc , .zshrc eller lignende):

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

• Windows OS : Gå til Systemegenskaber > Miljøvariabler , og under Brugervariable , klik på Ny for at oprette en ny variabel med navnet: "PYTHONPATH" og værdien som en liste over biblioteksstier adskilt af et semikolon (;).

  C:pathtomoduledirectory1;C:pathtomoduledirectory2
  

Når stivariablen er indstillet, kan du køre dit Python-script. Den vil søge efter importerede moduler i disse mapper såvel som standardmodulerne i sys.path .

Når du organiserer din kode i filer og mapper, vil du ofte støde på relativ import og justering af sys.path .

I næste afsnit vil vi udforske begge dele og se, hvordan de passer ind i rammerne for Python-import.

Overordnet katalogimport

Du kan organisere kode i forskellige mapper og filer for at forbedre både læsbarhed og vedligeholdelse. Det kan dog være en smule vanskeligt at importere moduler fra overordnede mapper.

I dette afsnit vil vi diskutere to tilgange til at opnå dette:

1. Relativ import

2. Justering af sys.path

1. Relativ import

Relativ import giver dig mulighed for at importere moduler baseret på deres relative placering i bibliotekshierarkiet.

Du kan bruge prik ( . ) notation til at henvise til den aktuelle mappe eller dobbelt prik ( .. ) notation til at henvise til overordnet mappe.

Antag, at du har en mappestruktur som følgende:

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

Inde i module_b.py kan du bruge relative importer til at få adgang til module_a.py :

from .. import module_a

Den dobbelte prik henviser til den overordnede mappe. Det er vigtigt at bemærke, at relativ import kun virker, hvis det overordnede bibliotek er en pakke (har en init.py- fil).

2. Justering af sys.path

Du kan også importere moduler fra en overordnet mappe ved at ændre sys.path .

Før importerklæringen kan du tilføje den overordnede mappesti til sys.path . Først skal du importere sys- modulet. Derefter bruger du os -modulet til at få den overordnede mappesti.

Antag, at du har en mappestruktur som følgende:

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

I module_b.py kan du tilføje den overordnede mappesti til sys.path på denne måde:

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 vil Python lede efter module_a.py i den overordnede mappe, når den importeres i module_b.py .

Du kan bruge enten den relative importtilgang eller sys.path- tilgangen til at importere moduler fra en overordnet mappe.

Sådan arbejder du med moduler og pakker

I Python er moduler og pakker en måde at organisere og genbruge kode på. Du kan bruge dem til at dele komplekse projekter op i håndterbare dele.

Dette afsnit vil diskutere, hvordan man arbejder med moduler og pakker i . Vi vil også inkludere nøglebegreber som:

1. Navneområder

2. Variabler og definitioner

3. Importerklæringer

1. Hvad er navnerum?

Navneområder i Python er en måde at sikre, at navnene på variabler, funktioner og klasser ikke er i konflikt mellem forskellige moduler.

Der er forskellige niveauer af navnerum i Python, såsom:

• Globalt navneområde: Refererer til hele modulets navneområde.

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

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

2. Hvad er variabler og definitioner?

I et Python-script kan du definere variabler, og klasser. Disse definitioner gemmes i scriptets navneområde.

Ved at importere scriptet som en pakke kan du få adgang til og genbruge dets definitioner i andre dele af dit projekt.

Det følgende er et eksempel på, hvordan man definerer en variabel og en funktion i samme navneområde:

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

Dette modul har en variabel min_variabel og en funktion min_funktion .

For at køre denne kode kan du oprette en ny fil med navnet my_variable.py og placere koden der som vist nedenfor:

Nu kan du importere denne fil og bruge den i et andet script som vist nedenfor:

Når du har kørt filen main.py , får du et output, der ligner følgende:

3. Hvad er importerklæringer?

Du kan importere filer, moduler eller pakker i Python med importerklæringen

Nogle almindelige importmetoder er:

• import modulnavn : Denne metode importerer et modul, hvilket gør alle dets definitioner tilgængelige med notationen modulnavn.definition_navn .

import mymodule

result = mymodule.my_function(3)

• fra modulnavn import some_definition : Denne metode importerer en specifik definition fra et modul, så du kan bruge den direkte uden modulpræfikset.

from mymodule import my_function

result = my_function(3)

• fra modulnavn import * : Denne metode importerer alle definitioner fra et modul, men det anbefales ikke, da det kan føre til navnekonflikter.

Afsluttende tanker

At forstå, hvordan man importerer fra en overordnet mappe i Python er vigtig for at opretholde en organiseret kodebase.

Denne viden giver dig mulighed for at designe dine projekter på en mere modulær måde. Det øger også genbrugbarheden af ​​din kode. Ved at strukturere din kode i separate moduler og pakker kan du undgå at gentage kode og gøre det nemmere at vedligeholde og opdatere.

Evnen til at bruge import- og fra -sætninger er mest værdifuld, når du arbejder på større projekter, hvor funktionaliteter er opdelt på tværs af forskellige mapper.

Ved at vide, hvordan man korrekt justerer Pythons sti til at importere moduler, kan du få adgang til funktioner defineret i én mappe, mens du arbejder i en anden.

Husk, at nøglen til at mestre Python - eller et hvilket som helst programmeringssprog - ligger i konsekvent praksis og umættelig nysgerrighed. Så fortsæt med at udforske, fortsæt med at eksperimentere og fortsæt med at udfordre dig selv.

Med denne hurtige guide bør du være godt klædt på til at håndtere alle import-puslespil, som Python kaster efter dig. Men stop ikke her. Der er et helt univers af Python-teknikker og tricks, der venter på at blive opdaget!