Import Pythona z katalogu nadrzędnego: krótki przewodnik

Czy kiedykolwiek znalazłeś się po kolana w plikach Pythona, próbując zaimportować moduł z katalogu nadrzędnego? Jeśli tak, jesteś w dobrym towarzystwie. System importu w Pythonie może czasami wydawać się krętym labiryntem, ale nie martw się, jesteśmy tutaj, aby pomóc Ci w nawigacji!

Aby zaimportować z katalogu nadrzędnego w Pythonie, możesz użyć modułu sys . Wstawiając wymagany katalog do listy sys.path, przekazujesz interpreterowi lokalizację żądanego modułu. Po zmodyfikowaniu pliku sys.path można zaimportować moduł docelowy przy użyciu standardowej instrukcji importu.

W tym artykule przyjrzymy się, jak można importować z katalogów nadrzędnych w Pythonie. Ponadto przyjrzymy się konkretnym przypadkom użycia importowania, które pomogą ci lepiej zrozumieć podstawową strukturę katalogów.

Wejdźmy w to!

Spis treści

• Jak importować w Pythonie
  • Co to jest system importu Pythona?
  • Demonstracja importowania z katalogu nadrzędnego
    • 1. Tworzenie niezbędnych katalogów i plików
    • 2. Dodawanie plików Pythona
    • 3. Edycja plików Pythona
    • 4. Uruchomienie kodu
  • Jak obsłużyć ImportError i ModuleNotFoundError w Pythonie
• Struktura katalogów Pythona
  • Struktura pakietu
  • Co to są pliki init.py?
• Ścieżka wyszukiwania Pythona
  • 1. Czym jest lista sys.path w Pythonie?
  • 2. Czym są zmienne środowiskowe PythonPath?
• Importy katalogów nadrzędnych
  • 1. Import względny
  • 2. Dostosowanie ścieżki sys
• Jak pracować z modułami i pakietami
  • 1. Czym są przestrzenie nazw?
  • 2. Czym są zmienne i definicje?
  • 3. Co to są deklaracje importowe?
• Końcowe przemyślenia

Jak importować w Pythonie

Przejdziemy od razu do dzisiejszego tematu: importowania w Pythonie. Te proste wiersze kodu na początku skryptów Pythona, które często zaczynają się od importu lub from ? To Twoja przepustka do wykorzystania mocy obszernych bibliotek i modułów Pythona.

W tej sekcji omówimy kod do importowania z katalogu nadrzędnego w Pythonie. Przyjrzymy się również potencjalnym błędom, które mogą wystąpić podczas importowania modułów z katalogu nadrzędnego.

Co to jest system importu Pythona?

System importu Pythona umożliwia wydajne ponowne wykorzystanie i organizację kodu. Ułatwia to obsługę złożonych projektów.

Aby zaimportować moduł lub pakiet w Pythonie, możesz użyć instrukcji import . Moduły są dystrybuowane jako pakiety, które są katalogami z kolekcją plików Pythona.

Aby zaimportować moduł z katalogu nadrzędnego, możesz użyć modułu sys.path , aby dodać katalog nadrzędny do ścieżki Pythona. Po dodaniu katalogu nadrzędnego można zaimportować moduł za pomocą instrukcji import .

Demonstracja importowania z katalogu nadrzędnego

Aby dać ci jasną demonstrację importowania z katalogu nadrzędnego, przejrzyjmy serię kroków, które pomogą ci zrozumieć cały proces.

1. Tworzenie niezbędnych katalogów i plików

Najpierw otwórz eksplorator plików i przejdź do żądanego dysku lokalnego. Używam mojego lokalnego dysku E, dlatego utworzę nowy katalog o nazwie my_project .

Wewnątrz my_project utwórz kolejny katalog o nazwie module_dir .

Więc powinieneś mieć teraz:

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

2. Dodawanie plików Pythona

Następnie utwórz nowy plik .py o nazwie main.py w katalogu my_project .

Następnie utwórz kolejny plik Pythona o nazwie my_module.py w module_dir .

Twoja struktura powinna teraz wyglądać tak:

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

Jeśli używasz Visual Studio Code , Twoja struktura katalogów powinna wyglądać następująco:

3. Edycja plików Pythona

Otwórz swój my_module.py i dodaj następujący kod:

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

Następnie śmiało zapisz i zamknij plik.

Teraz otwórz main.py i dodaj następujący 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()

W tym skrypcie najpierw ustalamy lokalizację katalogu o jeden poziom wyżej od uruchomionego skryptu (to jest katalog nadrzędny). Następnie mówimy Pythonowi, aby również zajrzał do tego folderu nadrzędnego, gdy będzie musiał zaimportować moduły.

Po wykonaniu tej czynności importujemy moduł o nazwie my_module znajdujący się w katalogu o nazwie module_dir znajdującym się w tym katalogu nadrzędnym. Na koniec wywołujemy funkcję o nazwie my_function z my_module .

Po dodaniu powyższego kodu zapisz i zamknij plik.

4. Uruchomienie kodu

Aby uruchomić ten kod, otwórz terminal żądanego edytora kodu i uruchom plik main.py. Jeśli używasz Visual Studio Code, dane wyjściowe powinny wyglądać następująco:

Main.py zaimportuje funkcję z my_module.py , jak pokazano na powyższym obrazku.

Ten przykład pokazuje szczegółowo, jak działa system plików i importowanie z katalogu nadrzędnego w Pythonie.

Jak obsłużyć ImportError i ModuleNotFoundError w Pythonie

Python zgłosi wyjątek ImportError , gdy moduł, który próbujesz zaimportować, nie zostanie znaleziony podczas procesu importowania.

ImportError jest podklasą wyjątku ModuleNotFoundError . Jest wywoływany, gdy zaimportowany moduł nie istnieje lub nie można go załadować.

Poniżej przedstawiono przykłady scenariuszy, w których mogą one wystąpić:

• Moduł lub pakiet nie znajduje się w sys.path .

• Nazwa modułu lub pakietu jest błędnie wpisana lub nie istnieje.

• Wystąpił problem z kodem modułu, uniemożliwiający jego prawidłowy import.

W przypadku napotkania tych błędów możesz skorzystać z następujących rozwiązań:

• Dwukrotne sprawdzenie pisowni i istnienia modułu lub pakietu.

• Dodanie niezbędnego katalogu do sys.path za pomocą append() lub insert() .

• Naprawa błędów w kodzie modułu, które mogą utrudniać jego import.

Aby dowiedzieć się więcej o obsłudze błędów w Pythonie, obejrzyj poniższy film:

Po zrozumieniu, jak działa importowanie w Pythonie, ważne jest również zapoznanie się ze strukturą katalogów Pythona.

Struktura katalogów i importowanie idą ze sobą w parze, ponieważ importowanie wymaga zrozumienia struktury katalogów, więc omówimy to w następnej sekcji.

Struktura katalogów Pythona

Zrozumienie struktury katalogów Pythona to coś więcej niż tylko wiedza, gdzie umieścić skrypty lub gdzie znaleźć właśnie zainstalowaną bibliotekę.

To tak, jakby mieć czyste, dobrze zorganizowane biurko: będziesz dokładnie wiedzieć, gdzie wszystko jest, a Twoja produktywność gwałtownie wzrośnie, więc omówimy podstawy w tej sekcji.

Struktura pakietu

Struktura katalogów projektu w Pythonie jest niezbędna do prawidłowej organizacji. Odpowiednia struktura pakietu pomoże zminimalizować ryzyko wystąpienia konfliktów nazw. Co więcej, umożliwi to również łatwą nawigację po systemie plików.

Poniżej przedstawiono typową strukturę katalogów projektu Pythona:

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

W powyższym przykładzie project jest katalogiem głównym zawierającym dwa podpakiety, package1 i package2 . Każdy pakiet ma swoje pliki .py i unikalny plik init.py.

Co to są pliki init.py?

init.py są ważne dla zdefiniowania zachowania pakietu podczas importowania. Pliki te są wykonywane podczas importowania ich pakietu nadrzędnego.

Pliki init.py mogą być puste lub zawierać kod inicjujący. Wskazują również Pythonowi, że folder powinien być traktowany jako pakiet.

Aby zaimportować moduł z katalogu nadrzędnego, można użyć metody sys.path . Musisz dołączyć ścieżkę katalogu nadrzędnego do sys.path .

Aby to zademonstrować, rozwińmy nasz poprzedni przykład. Mieliśmy następującą strukturę katalogów:

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

Teraz dodajmy plik init.py do katalogu my_module . Na razie możesz pozostawić ten plik pusty. Jego obecność wskazuje Pythonowi, że ten katalog powinien być traktowany jako pakiet.

Twoja struktura katalogów powinna teraz wyglądać następująco:

Po dodaniu pliku init.py musisz wprowadzić zmiany w pliku main.py , aby poinstruował go, aby traktował folder module_dir jako pakiet. Twój plik main.py powinien mieć teraz następujący 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()

W tym przykładzie main.py importuje pakiet module_dir , a następnie wywołuje funkcję my_function() z my_module w tym pakiecie.

Zwróć uwagę na zmianę w wywołaniu funkcji my_function ; ponieważ teraz traktujemy katalog_modułu jako pakiet, musimy dołączyć nazwę pakietu podczas wywoływania funkcji z modułów w pakiecie.

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.

Przed instrukcją import można dołączyć ścieżkę katalogu nadrzędnego do sys.path . Najpierw musisz zaimportować moduł sys . Następnie używasz modułu os , aby uzyskać ścieżkę do katalogu nadrzędnego.

Załóżmy, że masz strukturę katalogów podobną do następującej:

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

W module_b.py możesz dołączyć ścieżkę katalogu nadrzędnego do sys.path w następujący sposób:

import os
import sys

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

import module_a

Teraz Python będzie szukał modułu module_a.py w katalogu nadrzędnym podczas importowania go w module_b.py .

Do importowania modułów z katalogu nadrzędnego można użyć metody importu względnego lub metody sys.path .

Jak pracować z modułami i pakietami

W Pythonie moduły i pakiety są sposobem na organizowanie i ponowne wykorzystywanie kodu. Można ich używać do dzielenia złożonych projektów na łatwe do zarządzania części.

W tej sekcji omówimy, jak pracować z modułami i pakietami w Pythonie . Będziemy również uwzględniać kluczowe pojęcia, takie jak:

1. Przestrzenie nazw

2. Zmienne i definicje

3. Importuj wyciągi

1. Czym są przestrzenie nazw?

Przestrzenie nazw w Pythonie zapewniają, że nazwy zmiennych, funkcji i klas nie powodują konfliktów między różnymi modułami.

Istnieją różne poziomy przestrzeni nazw w Pythonie, takie jak:

• Globalna przestrzeń nazw: odnosi się do przestrzeni nazw całego modułu.

• Lokalna przestrzeń nazw: odnosi się do przestrzeni nazw w obrębie funkcji lub klasy.

Możesz uzyskać nazwę w określonej przestrzeni nazw za pomocą notacji namespace[name] .

2. Czym są zmienne i definicje?

W skrypcie Pythona możesz definiować zmienne, funkcje i klasy. Te definicje są przechowywane w przestrzeni nazw skryptu.

Importując skrypt jako pakiet, możesz uzyskać dostęp do jego definicji i ponownie użyć ich w innych częściach projektu.

Poniżej znajduje się przykład definiowania zmiennej i funkcji w tej samej przestrzeni nazw:

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

Ten moduł ma zmienną my_variable i funkcję my_function .

Aby uruchomić ten kod, możesz utworzyć nowy plik o nazwie my_variable.py i umieścić tam kod, jak pokazano poniżej:

Teraz możesz zaimportować ten plik i użyć go w innym skrypcie, jak pokazano poniżej:

Po uruchomieniu pliku main.py otrzymasz wynik podobny do następującego:

3. Co to są deklaracje importowe?

Możesz importować pliki, moduły lub pakiety w Pythonie za pomocą instrukcji import

Niektóre popularne metody importu to:

• import nazwa_modułu : Ta metoda importuje moduł, udostępniając wszystkie jego definicje za pomocą notacji nazwa_modułu.nazwa_definicji .

import mymodule

result = mymodule.my_function(3)

• from nazwa_modułu import some_definition : Ta metoda importuje określoną definicję z modułu, umożliwiając jej bezpośrednie użycie bez prefiksu modułu.

from mymodule import my_function

result = my_function(3)

• from module_name import * : Ta metoda importuje wszystkie definicje z modułu, ale nie jest zalecana, ponieważ może prowadzić do konfliktów nazewnictwa.

Końcowe przemyślenia

Zrozumienie, jak importować z katalogu nadrzędnego w Pythonie, jest ważne dla utrzymania zorganizowanej bazy kodu.

Ta wiedza pozwala projektować projekty w bardziej modułowy sposób. Zwiększa to również możliwość ponownego wykorzystania kodu. Dzięki podzieleniu kodu na oddzielne moduły i pakiety można uniknąć powtarzania kodu i ułatwić jego konserwację i aktualizację.

Umiejętność korzystania z instrukcji import i from jest najbardziej cenna podczas pracy nad większymi projektami, w których funkcje są podzielone na różne katalogi.

Wiedząc, jak poprawnie dostosować ścieżkę Pythona do importowanych modułów, możesz uzyskać dostęp do funkcjonalności zdefiniowanych w jednym katalogu podczas pracy w innym.

Pamiętaj, że kluczem do opanowania Pythona — lub dowolnego innego języka programowania — jest konsekwentna praktyka i nienasycona ciekawość. Więc kontynuuj odkrywanie, eksperymentuj i stawiaj sobie wyzwania.

Dzięki temu krótkiemu przewodnikowi powinieneś być dobrze przygotowany do radzenia sobie z wszelkimi łamigłówkami importu, jakie stawia przed tobą Python. Ale nie poprzestawaj na tym. Cały wszechświat technik i sztuczek Pythona czeka na odkrycie!