Python importeren vanuit een bovenliggende map: een beknopte handleiding

Heb je ooit kniediep in Python-bestanden gezeten en moeite gehad om een ​​module uit een bovenliggende map te importeren? Als dat zo is, bent u in goed gezelschap. Het importsysteem van Python kan soms aanvoelen als een kronkelend doolhof, maar maak je geen zorgen, we zijn hier om je te helpen navigeren!

Om vanuit een bovenliggende map in Python te importeren, kunt u de sys- module gebruiken. Door de vereiste map in de sys.path-lijst in te voegen, geeft u de tolk de locatie van de gewenste module. Na het wijzigen van het sys.path, kunt u de doelmodule importeren met behulp van de standaard importopdracht.

In dit artikel zullen we onderzoeken hoe u vanuit bovenliggende mappen in Python kunt importeren. Verder zullen we kijken naar specifieke use-cases van importeren die u zullen helpen de onderliggende structuur van de mappen beter te begrijpen.

Laten we erop ingaan!

Inhoudsopgave

• Hoe te importeren in Python
  • Wat is het Python-importsysteem?
  • Demonstratie van importeren uit bovenliggende directory
    • 1. De benodigde mappen en bestanden maken
    • 2. Python-bestanden toevoegen
    • 3. De Python-bestanden bewerken
    • 4. De code uitvoeren
  • Hoe om te gaan met ImportError en ModuleNotFoundError in Python
• Python-directorystructuur
  • Pakketstructuur
  • Wat zijn init.py-bestanden?
• Python-zoekpad
  • 1. Wat is de sys.path-lijst in Python?
  • 2. Wat zijn PythonPath-omgevingsvariabelen?
• Bovenliggende directory-importen
  • 1. Relatieve invoer
  • 2. Systeempad aanpassen
• Werken met modules en pakketten
  • 1. Wat zijn naamruimten?
  • 2. Wat zijn variabelen en definities?
  • 3. Wat zijn invoerverklaringen?
• Laatste gedachten

Hoe te importeren in Python

We gaan meteen naar het onderwerp van vandaag: importeren in Python. Die simpele regels code aan het begin van je Python-scripts die vaak beginnen met importeren of vanuit ? Dat is jouw ticket om gebruik te maken van de kracht van de uitgebreide bibliotheken en modules van Python.

In deze sectie bespreken we de code voor het importeren uit de bovenliggende map in Python. We kijken ook naar mogelijke fouten die kunnen optreden bij het importeren van modules uit de bovenliggende directory.

Wat is het Python-importsysteem?

Het Python-importsysteem maakt efficiënt hergebruik en organisatie van code mogelijk. Het maakt het u gemakkelijker om complexe projecten te onderhouden.

Om een ​​module of pakket in Python te importeren, kunt u het importstatement gebruiken . Modules worden gedistribueerd als pakketten, dit zijn mappen met een verzameling Python-bestanden.

Om een ​​module uit de bovenliggende map te importeren, kunt u de module sys.path gebruiken om de bovenliggende map toe te voegen aan het pad van Python. Nadat u de bovenliggende map hebt toegevoegd, kunt u de module importeren met behulp van de importopdracht .

Demonstratie van importeren uit bovenliggende directory

Om u een duidelijke demonstratie te geven van het importeren vanuit de bovenliggende directory, gaan we een reeks stappen doornemen om u te helpen het hele proces te begrijpen.

1. De benodigde mappen en bestanden maken

Open eerst uw bestandsverkenner en navigeer naar uw gewenste lokale schijf. Ik gebruik mijn lokale E-schijf, daarom maak ik een nieuwe map met de naam my_project .

Maak binnen mijn_project een andere map met de naam module_dir .

Dus je zou nu moeten hebben:

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

2. Python-bestanden toevoegen

Maak vervolgens een nieuw .py- bestand met de naam main.py in de map my_project .

Maak daarna nog een Python-bestand met de naam my_module.py in module_dir .

Je structuur zou er nu zo uit moeten zien:

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

Als u Visual Studio Code gebruikt , zou uw directorystructuur er als volgt uit moeten zien:

3. De Python-bestanden bewerken

Open uw my_module.py en voeg de volgende code toe:

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

Ga dan door en sla het bestand op en sluit het.

Open nu main.py en voeg de volgende code toe:

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

In dit script zoeken we eerst de locatie uit van de map die één niveau hoger ligt dan het script dat we uitvoeren (dat is de bovenliggende map). Vervolgens vertellen we Python om ook in deze bovenliggende map te kijken wanneer het modules moet importeren.

Nadat we dat hebben gedaan, importeren we een module met de naam my_module die zich in een map met de naam module_dir in deze bovenliggende map bevindt. Ten slotte roepen we een functie met de naam my_function aan vanuit my_module .

Nadat u de bovenstaande code hebt toegevoegd, slaat u het bestand op en sluit u het.

4. De code uitvoeren

Om deze code uit te voeren, opent u de terminal van de gewenste code-editor en voert u het bestand main.py uit. Als u Visual Studio Code gebruikt, zou de uitvoer er als volgt uit moeten zien:

De main.py importeert de functie uit my_module.py , zoals weergegeven in de bovenstaande afbeelding.

Dit voorbeeld laat in detail zien hoe het bestandssysteem en het importeren vanuit de bovenliggende map werkt in Python.

Hoe om te gaan met ImportError en ModuleNotFoundError in Python

Python genereert een ImportError- uitzondering wanneer de module die u probeert te importeren niet wordt gevonden tijdens het importproces.

ImportError is een subklasse van de uitzondering ModuleNotFoundError . Het wordt gegenereerd wanneer de geïmporteerde module niet bestaat of niet kan worden geladen.

Hieronder volgen voorbeelden van scenario's waarin deze zich kunnen voordoen:

• De module of het pakket bevindt zich niet in het sys.path .

• De naam van de module of het pakket is verkeerd gespeld of bestaat niet.

• Er is een probleem met de code van de module, waardoor deze niet correct kan worden geïmporteerd.

Wanneer u deze fouten tegenkomt, kunt u de volgende oplossingen gebruiken:

• Dubbele controle van de spelling en het bestaan ​​van de module of het pakket.

• De benodigde map toevoegen aan sys.path met behulp van append() of insert() .

• Oplossen van eventuele problemen in de code van de module die de import kunnen belemmeren.

Bekijk de volgende video voor meer informatie over het afhandelen van fouten in Python:

Nadat u begrijpt hoe importeren in Python werkt, is het ook belangrijk dat u vertrouwd raakt met de directorystructuur van Python.

Directorystructuur en importeren gaan hand in hand met elkaar, aangezien importeren een begrip van de directorystructuur vereist, dus laten we dat in de volgende sectie bespreken.

Python-directorystructuur

Het begrijpen van de directorystructuur van Python is meer dan alleen weten waar je je scripts moet plaatsen of waar je die bibliotheek kunt vinden die je zojuist hebt geïnstalleerd.

Het is alsof u een schoon, goed georganiseerd bureau heeft: u weet precies waar alles is en uw productiviteit schiet omhoog, dus laten we de basis in dit gedeelte bespreken.

Pakketstructuur

De directorystructuur van een Python-project is essentieel voor een correcte organisatie. Als u uw pakket op de juiste manier structureert, helpt het u de kans op naamconflicten te minimaliseren. Bovendien kunt u hiermee gemakkelijk door uw bestandssysteem navigeren.

Het volgende is een typische directorystructuur van een Python-project:

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

In het bovenstaande voorbeeld is project de hoofdmap die twee subpakketten bevat, pakket1 en pakket2 . Elk pakket heeft zijn .py- bestanden en een uniek init.py- bestand.

Wat zijn init.py-bestanden?

init.py- bestanden zijn belangrijk voor het definiëren van het gedrag van het pakket wanneer het wordt geïmporteerd. Deze bestanden worden uitgevoerd wanneer hun bovenliggende pakket wordt geïmporteerd.

De init.py- bestanden kunnen leeg zijn of initialisatiecode bevatten. Ze geven Python ook aan dat de map als een pakket moet worden behandeld.

Om een ​​module uit een bovenliggende map te importeren , kunt u de methode sys.path gebruiken . U moet het pad naar de bovenliggende map toevoegen aan sys.path .

Laten we, om dit te demonstreren, voortbouwen op ons vorige voorbeeld. We hadden de volgende mappenstructuur:

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

Laten we nu het bestand init.py toevoegen aan de map my_module . U kunt dit bestand voorlopig leeg laten. De aanwezigheid ervan geeft aan Python aan dat deze map als een pakket moet worden behandeld.

Uw mappenstructuur zou er nu als volgt uit moeten zien:

Nadat u het bestand init.py hebt toegevoegd , moet u wijzigingen aanbrengen in uw bestand main.py om het opdracht te geven de map module_dir als een pakket te behandelen . Uw main.py- bestand zou nu de volgende code moeten hebben:

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

In dit voorbeeld importeert main.py het pakket module_dir en roept vervolgens de functie my_function() aan vanuit my_module binnen dat pakket.

Let op de wijziging in de aanroep van de my_function ; omdat we module_dir nu behandelen als een pakket, moeten we de pakketnaam opnemen als we functies aanroepen vanuit modules binnen het pakket.

The output will be similar to the previous one. The only change we made was to treat module_dir as a package with the inclusion of init.py file.

Python Search Path

Ever wondered how Python knows where to find the modules you’re trying to import? Or maybe you’ve encountered an annoying ‘ModuleNotFoundError’ and couldn’t figure out why?

In this section, we’re going to tackle these mysteries head-on and delve into the concept of the Python search path.

The Python search path, also known as sys.path, is Python’s little roadmap to finding all the modules you need. Like a diligent scout, Python uses this path to scour your computer for modules whenever you use the import statement.

Understanding how it works can save you from headaches and help you troubleshoot when things go awry, so let’s go over some basics!

1. What is the sys.path List in Python?

The sys.path list is a crucial component when importing modules in a directory. It’s a list of strings that represents the module search path.

Each string in the list is a directory location where Python looks for modules (*.py files) or packages (folders containing init.py files).

The following example shows you how to view your current sys.path list:

import sys

for path in sys.path:
    print(path)

After running the above code, you’ll see an output like the following:

You can also add new directories to the sys.path list so that Python finds your custom modules.

For instance:

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

2. What are PythonPath Environment Variables?

Another way you can manage the module search path is by using the PYTHONPATH environment variable.

PYTHON PATH is a string containing a list of directories that is appended to the default sys.path list. This means you can add directories to PYTHONPATH. This allows Python to search for modules in those directories when importing.

Setting the PYTHONPATH environment variable depends on your operating system:

• Unix-based systems (Linux, macOS): You can use the export command in your terminal or add the following line to your shell configuration file (.bashrc, .zshrc or similar):

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

• Windows OS: Go to System Properties > Environment Variables, and under User variables, click New to create a new variable with the name: “PYTHONPATH” and the value as a list of directory paths separated by a semi-colon (;).

  C:pathtomoduledirectory1;C:pathtomoduledirectory2
  

Once the path variable is set, you can run your Python script. It will search for imported modules in those directories as well as the default ones in sys.path.

When organizing your code into files and folders, you’ll frequently come across relative imports and adjusting sys.path.

In the next section, we’ll explore both and see how they fit into the framework for Python imports.

Parent Directory Imports

You can organize code into different folders and files to improve both readability and maintainability. However, importing modules from parent directories can be a bit tricky.

In this section, we’ll discuss two approaches to achieve this:

1. Relative Imports

2. Adjusting sys.path

1. Relative Imports

Relative imports allow you to import modules based on their relative position in the directory hierarchy.

You can use the dot (.) notation to refer to the current directory or double dot (..) notation to refer to the parent directory.

Suppose you have a directory structure like the following:

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

Inside module_b.py, you can use relative imports to access module_a.py:

from .. import module_a

The double dot refers to the parent directory. It is important to note that relative imports only work if the parent directory is a package (has an init.py file).

2. Adjusting sys.path

You can also import modules from a parent directory by modifying the sys.path.

Vóór de importinstructie kunt u het pad naar de bovenliggende map toevoegen aan het sys.path . Eerst moet u de sys- module importeren. Vervolgens gebruikt u de os- module om het bovenliggende mappad op te halen.

Stel dat u een mappenstructuur hebt zoals de volgende:

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

In module_b.py kunt u het pad naar de bovenliggende map als volgt toevoegen aan sys.path :

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 zal Python zoeken naar module_a.py in de bovenliggende map bij het importeren in module_b.py .

U kunt de relatieve importbenadering of de sys.path- benadering gebruiken om modules uit een bovenliggende map te importeren.

Werken met modules en pakketten

In Python zijn modules en pakketten een manier om code te organiseren en opnieuw te gebruiken. U kunt ze gebruiken om complexe projecten op te splitsen in behapbare delen.

In deze sectie wordt besproken hoe u met modules en pakketten in Python kunt werken . We zullen ook sleutelconcepten opnemen, zoals:

1. Naamruimten

2. Variabelen en definities

3. Afschriften importeren

1. Wat zijn naamruimten?

Naamruimten in Python zijn een manier om ervoor te zorgen dat de namen van variabelen, functies en klassen niet conflicteren tussen verschillende modules.

Er zijn verschillende niveaus van naamruimten in Python, zoals:

• Globale naamruimte: Verwijst naar de naamruimte van de gehele module.

• Lokale naamruimte: verwijst naar de naamruimte binnen een functie of klasse.

U kunt een naam in een bepaalde naamruimte verkrijgen met de notatie naamruimte[naam] .

2. Wat zijn variabelen en definities?

In een Python-script kunt u variabelen, functies en klassen definiëren. Deze definities worden opgeslagen in de naamruimte van het script.

Door het script als een pakket te importeren, hebt u toegang tot de definities en kunt u deze opnieuw gebruiken in andere delen van uw project.

Het volgende is een voorbeeld van het definiëren van een variabele en een functie in dezelfde naamruimte:

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

Deze module heeft een variabele mijn_variabele en een functie mijn_functie .

Om deze code uit te voeren, kunt u een nieuw bestand maken met de naam my_variable.py en de code daar plaatsen zoals hieronder weergegeven:

Nu kunt u dit bestand importeren en in een ander script gebruiken, zoals hieronder weergegeven:

Nadat u het main.py- bestand hebt uitgevoerd, krijgt u een uitvoer die lijkt op het volgende:

3. Wat zijn invoerverklaringen?

U kunt bestanden, modules of pakketten in Python importeren met het importstatement

Enkele veelgebruikte importmethoden zijn:

• import module_name : Deze methode importeert een module en maakt al zijn definities toegankelijk met de notatie module_name.definition_name .

import mymodule

result = mymodule.my_function(3)

• from module_name import some_definition : Deze methode importeert een specifieke definitie van een module, zodat u deze direct kunt gebruiken zonder het modulevoorvoegsel.

from mymodule import my_function

result = my_function(3)

• from module_name import * : Deze methode importeert alle definities van een module, maar wordt niet aanbevolen omdat dit kan leiden tot naamgevingsconflicten.

Laatste gedachten

Begrijpen hoe te importeren vanuit een bovenliggende map in Python is belangrijk bij het onderhouden van een georganiseerde codebase.

Met deze kennis kunt u uw projecten meer modulair vormgeven. Het vergroot ook de herbruikbaarheid van uw code. Door uw code te structureren in afzonderlijke modules en pakketten, kunt u herhaling van code voorkomen en het gemakkelijker maken om te onderhouden en bij te werken.

De vaardigheid om import- en from -statements te gebruiken is het meest waardevol wanneer u aan grotere projecten werkt waarbij functionaliteiten over verschillende mappen zijn verdeeld.

Door te weten hoe je het pad van Python om modules te importeren correct aanpast, heb je toegang tot functionaliteiten die in de ene map zijn gedefinieerd terwijl je in een andere werkt.

Onthoud dat de sleutel tot het beheersen van Python - of welke programmeertaal dan ook - ligt in consistent oefenen en onverzadigbare nieuwsgierigheid. Dus blijf ontdekken, blijf experimenteren en blijf jezelf uitdagen.

Met deze korte handleiding zou je goed uitgerust moeten zijn om alle importpuzzels die Python je voorschotelt aan te kunnen. Maar stop hier niet. Er wacht een heel universum van Python-technieken en -trucs om ontdekt te worden!