Import Python dintr-un director părinte: un ghid rapid

V-ați găsit vreodată până la genunchi în fișierele Python, luptându-vă să importați un modul dintr-un director părinte? Dacă da, ești într-o companie bună. Sistemul de import al lui Python poate simți uneori un labirint întortocheat, dar nu vă faceți griji, suntem aici pentru a vă ajuta să navigați!

Pentru a importa dintr-un director părinte în Python, puteți utiliza modulul sys . Prin inserarea directorului necesar în lista sys.path, oferiți interpretului locația modulului dorit. După modificarea sys.path, puteți importa modulul țintă folosind instrucțiunea standard de import.

În acest articol, vom explora modul în care puteți importa din directoarele părinte în Python. În plus, vom analiza cazurile de utilizare specifice ale importului, care vă vor ajuta să înțelegeți mai bine structura de bază a directoarelor.

Să intrăm în ea!

Cuprins

• Cum se importă în Python
  • Ce este Python Import System?
  • Demonstrație de import din directorul părinte
    • 1. Crearea directoarelor și fișierelor necesare
    • 2. Adăugarea fișierelor Python
    • 3. Editarea fișierelor Python
    • 4. Rularea codului
  • Cum să gestionați ImportError și ModuleNotFoundError în Python
• Structura directorului Python
  • Structura pachetului
  • Ce sunt fișierele init.py?
• Calea de căutare Python
  • 1. Ce este lista sys.path în Python?
  • 2. Ce sunt variabilele de mediu PythonPath?
• Importuri din directorul părinte
  • 1. Importuri relative
  • 2. Ajustarea sys.path
• Cum să lucrați cu module și pachete
  • 1. Ce sunt spațiile de nume?
  • 2. Ce sunt variabilele și definițiile?
  • 3. Ce sunt declarațiile de import?
• Gânduri finale

Cum se importă în Python

Vom trece direct la subiectul de astăzi: importul în Python. Acele linii simple de cod de la începutul scripturilor dvs. Python care încep adesea cu import sau din ? Acestea sunt biletul tău pentru a profita de puterea bibliotecilor și modulelor extinse ale Python.

În această secțiune, vom trece peste codul pentru importul din directorul părinte în Python. De asemenea, vom analiza potențialele erori care pot apărea la importul modulelor din directorul părinte.

Ce este Python Import System?

Sistemul de import Python permite reutilizarea și organizarea eficientă a codului. Vă este mai ușor să mențineți proiecte complexe.

Pentru a importa un modul sau un pachet în Python, puteți utiliza instrucțiunea import . Modulele sunt distribuite ca pachete, care sunt directoare cu o colecție de fișiere Python.

Pentru a importa un modul din directorul părinte, puteți utiliza modulul sys.path pentru a adăuga directorul părinte la calea lui Python. După adăugarea directorului părinte, puteți importa modulul folosind instrucțiunea de import .

Demonstrație de import din directorul părinte

Pentru a vă oferi o demonstrație clară a importului din directorul părinte, să trecem peste o serie de pași pentru a vă ajuta să înțelegeți întregul proces.

1. Crearea directoarelor și fișierelor necesare

Mai întâi, deschideți exploratorul de fișiere și navigați la unitatea locală dorită. Folosesc unitatea mea E locală, prin urmare, voi crea un director nou numit my_project .

În interiorul my_project , creați un alt director numit module_dir .

Deci, acum ar trebui să aveți:

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

2. Adăugarea fișierelor Python

Apoi, creați un nou fișier .py numit main.py în directorul my_project .

După aceea, creați un alt fișier Python numit my_module.py în module_dir .

Structura dvs. ar trebui să arate acum astfel:

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

Dacă utilizați Visual Studio Code , structura dvs. de directoare ar trebui să arate astfel:

3. Editarea fișierelor Python

Deschideți my_module.py și adăugați următorul cod:

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

Apoi mergeți mai departe și salvați și închideți fișierul.

Acum, deschideți main.py și adăugați următorul cod:

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

În acest script, aflăm mai întâi locația directorului cu un nivel mai sus față de scriptul pe care îl rulăm (acesta este directorul părinte). Apoi, îi spunem lui Python să caute și în acest folder părinte atunci când trebuie să importe module.

După ce facem asta, importăm un modul numit my_module care se află într-un director numit module_dir situat în acest director părinte. În cele din urmă, apelăm o funcție numită my_function din my_module .

După adăugarea codului de mai sus, salvați și închideți fișierul.

4. Rularea codului

Pentru a rula acest cod, deschideți terminalul editorului de cod dorit și rulați fișierul main.py. Dacă utilizați Visual Studio Code, rezultatul ar trebui să arate astfel:

Main.py va importa funcția din my_module.py , așa cum se arată în imaginea de mai sus.

Acest exemplu arată în detaliu cum funcționează sistemul de fișiere și importul din directorul părinte în Python.

Cum să gestionați ImportError și ModuleNotFoundError în Python

Python va genera o excepție ImportError atunci când modulul pe care încercați să îl importați nu este găsit în timpul procesului de import.

ImportError este o subclasă a excepției ModuleNotFoundError . Este ridicat atunci când modulul importat nu există sau nu poate fi încărcat.

Următoarele sunt exemple de scenarii în care acestea pot apărea:

• Modulul sau pachetul nu se află în sys.path .

• Modulul sau numele pachetului este scris greșit sau nu există.

• Există o problemă cu codul modulului, care împiedică importarea corectă a acestuia.

Când întâmpinați aceste erori, puteți utiliza următoarele soluții:

• Verificarea de două ori a ortografiei și a existenței modulului sau pachetului.

• Adăugarea directorului necesar la sys.path folosind append() sau insert() .

• Remedierea oricăror probleme din codul modulului care ar putea împiedica importul acestuia.

Pentru a afla mai multe despre gestionarea erorilor în Python, consultați următorul videoclip:

După ce ați înțeles cum funcționează importul în Python, este, de asemenea, important să vă familiarizați cu structura directoarelor Python.

Structura directorului și importul merg mână în mână, deoarece importul necesită o înțelegere a structurii directoarelor, așa că să trecem peste asta în secțiunea următoare.

Structura directorului Python

Înțelegerea structurii directoarelor Python înseamnă mai mult decât să știi unde să pui scripturile sau unde să găsești biblioteca pe care tocmai ai instalat-o.

Este ca și cum ai avea un birou curat și bine organizat: vei ști exact unde este totul, iar productivitatea ta va crește vertiginos, așa că hai să trecem peste elementele de bază în această secțiune.

Structura pachetului

Structura de directoare a unui proiect Python este esențială pentru organizarea corectă. Dacă vă structurați pachetul în mod corespunzător, vă va ajuta să minimizați șansa de conflicte de denumire. În plus, vă va permite să navigați cu ușurință prin sistemul de fișiere.

Următoarea este o structură tipică de director de proiect Python:

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

În exemplul de mai sus, proiect este directorul rădăcină care conține două sub-pachete, pachet1 și pachet2 . Fiecare pachet are fișierele sale .py și un fișier unic init.py.

Ce sunt fișierele init.py?

Fișierele init.py sunt importante pentru definirea comportamentului pachetului atunci când este importat. Aceste fișiere sunt executate atunci când pachetul lor părinte este importat.

Fișierele init.py pot fi goale sau pot conține cod de inițializare. De asemenea, ele indică lui Python că folderul ar trebui tratat ca un pachet.

Pentru a importa un modul dintr-un director părinte, puteți utiliza metoda sys.path . Va trebui să atașați calea directorului părinte la sys.path .

Pentru a demonstra acest lucru, să construim pe exemplul nostru anterior. Am avut următoarea structură de directoare:

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

Acum, să adăugăm fișierul init.py în directorul my_module . Puteți lăsa acest fișier gol deocamdată. Prezența lui indică lui Python că acest director ar trebui tratat ca un pachet.

Structura dvs. de directoare ar trebui acum să arate astfel:

După adăugarea fișierului init.py , trebuie să faceți modificări în fișierul main.py pentru a-i cere să trateze folderul module_dir ca un pachet. Fișierul dvs. main.py ar trebui să aibă acum următorul cod:

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

În acest exemplu, main.py importă pachetul module_dir și apoi apelează funcția my_function() din my_module din acel pachet.

Observați modificarea apelului la my_function ; deoarece acum tratăm module_dir ca un pachet, trebuie să includem numele pachetului atunci când apelăm funcții din module din pachet.

Ieșirea va fi similară cu cea anterioară. Singura modificare pe care am făcut-o a fost să tratăm module_dir ca un pachet cu includerea fișierului init.py.

Calea de căutare Python

V-ați întrebat vreodată cum știe Python unde să găsească modulele pe care încercați să le importați? Sau poate ați întâlnit un „ModuleNotFoundError” enervant și nu v-ați dat seama de ce?

În această secțiune, vom aborda aceste mistere direct și vom aborda conceptul căii de căutare Python.

Calea de căutare Python, cunoscută și ca sys.path , este mica foaie de parcurs a Python pentru a găsi toate modulele de care aveți nevoie. Ca un cercetător sârguincios, Python folosește această cale pentru a-ți cerceta computerul după module ori de câte ori folosești instrucțiunea de import.

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.

Înainte de instrucțiunea de import , puteți adăuga calea directorului părinte la sys.path . Mai întâi, trebuie să importați modulul sys . Apoi, utilizați modulul os pentru a obține calea directorului părinte.

Să presupunem că aveți o structură de directoare ca următoarea:

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

În module_b.py , puteți adăuga calea directorului părinte la sys.path astfel:

import os
import sys

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

import module_a

Acum, Python va căuta module_a.py în directorul părinte atunci când îl va importa în module_b.py .

Puteți utiliza fie abordarea de import relativ, fie abordarea sys.path pentru a importa module dintr-un director părinte.

Cum să lucrați cu module și pachete

În Python, modulele și pachetele sunt o modalitate de a organiza și reutiliza codul. Le puteți folosi pentru a împărți proiecte complexe în părți gestionabile.

Această secțiune va discuta cum să lucrați cu module și pachete în Python . De asemenea, vom include concepte cheie precum:

1. Spații de nume

2. Variabile și definiții

3. Declarații de import

1. Ce sunt spațiile de nume?

Spațiile de nume din Python sunt o modalitate de a vă asigura că numele variabilelor, funcțiilor și claselor nu intră în conflict între diferite module.

Există diferite niveluri de spații de nume în Python, cum ar fi:

• Spațiu de nume global: Se referă la spațiul de nume al întregului modul.

• Spațiu de nume local: Se referă la spațiul de nume dintr-o funcție sau clasă.

Puteți obține un nume într-un anumit spațiu de nume cu notația namespace[name] .

2. Ce sunt variabilele și definițiile?

Într-un script Python, puteți defini variabile, funcții și clase. Aceste definiții sunt stocate în spațiul de nume al scriptului.

Importând scriptul ca pachet, puteți accesa și reutiliza definițiile acestuia în alte părți ale proiectului.

Următorul este un exemplu de definire a unei variabile și a unei funcții în același spațiu de nume:

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

Acest modul are o variabilă my_variable și o funcție my_function .

Pentru a rula acest cod, puteți crea un fișier nou numit my_variable.py și puneți codul acolo, așa cum se arată mai jos:

Acum, puteți importa acest fișier și îl puteți utiliza într-un alt script, așa cum se arată mai jos:

După rularea fișierului main.py , veți obține o ieșire similară cu următoarea:

3. Ce sunt declarațiile de import?

Puteți importa fișiere, module sau pachete în Python cu instrucțiunea de import

Câteva metode comune de import sunt:

• import module_name : Această metodă importă un modul, făcând toate definițiile sale accesibile cu notația module_name.definition_name .

import mymodule

result = mymodule.my_function(3)

• from module_name import some_definition : Această metodă importă o definiție specifică dintr-un modul, permițându-vă să o utilizați direct fără prefixul modulului.

from mymodule import my_function

result = my_function(3)

• from module_name import * : Această metodă importă toate definițiile dintr-un modul, dar nu este recomandată deoarece poate duce la conflicte de denumire.

Gânduri finale

Înțelegerea modului de importare dintr-un director părinte în Python este importantă în menținerea unei baze de cod organizate.

Aceste cunoștințe vă permit să vă proiectați proiectele într-un mod mai modular. De asemenea, crește reutilizabilitatea codului dvs. Structurând codul în module și pachete separate, puteți evita repetarea codului și faceți mai ușor de întreținut și actualizat.

Abilitatea de a utiliza instrucțiunile de import și de la este cea mai valoroasă atunci când lucrați la proiecte mai mari în care funcționalitățile sunt împărțite în directoare diferite.

Știind cum să ajustați corect calea lui Python pentru a importa module, puteți accesa funcționalitățile definite într-un director în timp ce lucrați în altul.

Amintiți-vă, cheia pentru a stăpâni Python - sau orice limbaj de programare - constă în practica consecventă și curiozitatea nesățioasă. Deci, continua să explorezi, continuă să experimentezi și continuă să te provoci.

Cu acest ghid rapid, ar trebui să fii bine echipat pentru a gestiona orice puzzle-uri de import pe care Python ți le aruncă. Dar nu te opri aici. Există un întreg univers de tehnici și trucuri Python care așteaptă să fie descoperite!