Python importálás szülőkönyvtárból: Gyors útmutató

Előfordult már, hogy térdig a Python-fájlokban találta magát, és nehezen tudott importálni egy modult a szülőkönyvtárból? Ha igen, jó társaságban vagy. A Python importrendszere néha kanyargós labirintusnak tűnhet, de ne aggódj, azért vagyunk itt, hogy segítsünk a navigálásban!

A Python szülőkönyvtárából való importáláshoz használhatja a sys modult. A szükséges könyvtár beszúrásával a sys.path listába, megadja az értelmezőnek a kívánt modul helyét. A sys.path módosítása után a célmodult a szabványos importálási utasítással importálhatja.

Ebben a cikkben megvizsgáljuk, hogyan importálhat a Python szülőkönyvtáraiból. Ezenkívül megvizsgáljuk az importálás konkrét felhasználási eseteit, amelyek segítenek jobban megérteni a könyvtárak mögöttes szerkezetét.

Menjünk bele!

Tartalomjegyzék

• Hogyan importáljunk Pythonban
  • Mi az a Python importrendszer?
  • A szülőkönyvtárból történő importálás bemutatása
    • 1. A szükséges könyvtárak és fájlok létrehozása
    • 2. Python fájlok hozzáadása
    • 3. Python fájlok szerkesztése
    • 4. A kód futtatása
  • Az ImportError és a ModuleNotFoundError kezelése a Pythonban
• Python címtárstruktúra
  • Csomag felépítése
  • Mik azok az init.py fájlok?
• Python keresési útvonal
  • 1. Mi az a sys.path lista a Pythonban?
  • 2. Mik azok a PythonPath környezeti változók?
• Szülőcímtár importálása
  • 1. Relatív import
  • 2. A sys.path beállítása
• Hogyan kell dolgozni modulokkal és csomagokkal
  • 1. Mik azok a névterek?
  • 2. Mik azok a változók és definíciók?
  • 3. Mik azok az import nyilatkozatok?
• Végső gondolatok

Hogyan importáljunk Pythonban

Egyenesen a mai témához fogunk ugrani: az importáláshoz Pythonban. Azok az egyszerű kódsorok a Python-szkriptek elején, amelyek gyakran az importtal vagy a ? Ezek a belépőjegyek a Python kiterjedt könyvtárainak és moduljainak kihasználásához.

Ebben a részben áttekintjük a Python szülőkönyvtárából történő importálás kódját. Megvizsgáljuk azokat a lehetséges hibákat is, amelyek modulok szülőkönyvtárból történő importálásakor fordulhatnak elő.

Mi az a Python importrendszer?

A Python importrendszer lehetővé teszi a kódok hatékony újrafelhasználását és rendszerezését. Ez megkönnyíti az összetett projektek karbantartását.

Modul vagy csomag Pythonban történő importálásához használhatja az import utasítást. A modulok csomagokként vannak elosztva, amelyek Python-fájlok gyűjteményét tartalmazó könyvtárak.

Modul importálásához a szülőkönyvtárból a sys.path modul segítségével hozzáadhatja a szülőkönyvtárat a Python elérési útjához. A szülőkönyvtár hozzáadása után az import utasítással importálhatja a modult .

A szülőkönyvtárból történő importálás bemutatása

A szülőkönyvtárból történő importálás egyértelmű bemutatása érdekében nézzünk át egy sor lépést, amelyek segítenek megérteni a teljes folyamatot.

1. A szükséges könyvtárak és fájlok létrehozása

Először nyissa meg a fájlkezelőt, és keresse meg a kívánt helyi meghajtót. A helyi E-meghajtómat használom, ezért létrehozok egy új könyvtárat, melynek neve my_project .

A saját_projektben hozzon létre egy másik könyvtárat modul_dir néven .

Tehát most rendelkeznie kell:

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

2. Python fájlok hozzáadása

Ezután hozzon létre egy új .py fájlt main.py néven a my_project könyvtárban .

Ezután hozzon létre egy másik Python-fájlt my_module.py néven a modul_könyvtárban .

A szerkezetének most így kell kinéznie:

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

Ha Visual Studio Code-ot használ , akkor a könyvtárszerkezetnek a következőképpen kell kinéznie:

3. Python fájlok szerkesztése

Nyissa meg a my_module.py fájlt , és adja hozzá a következő kódot:

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

Ezután mentse el és zárja be a fájlt.

Most nyissa meg a main.py-t , és adja hozzá a következő kódot:

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

Ebben a szkriptben először kitaláljuk a könyvtár helyét egy szinttel feljebb a futtatott szkripthez képest (ez a szülőkönyvtár). Ezután azt mondjuk a Pythonnak, hogy keressen ebben a szülőmappában is, amikor modulokat kell importálnia.

Ezt követően importálunk egy my_module nevű modult , amely a szülőkönyvtárban található modul_dir nevű könyvtárban található. Végül meghívunk egy my_function nevű függvényt a my_module- ból .

A fenti kód hozzáadása után mentse el és zárja be a fájlt.

4. A kód futtatása

A kód futtatásához nyissa meg a kívánt kódszerkesztő terminálját, és futtassa a main.py fájlt. Ha Visual Studio Code-ot használ, a kimenetnek a következőképpen kell kinéznie:

A main.py a fenti képen látható módon importálja a függvényt a my_module.py fájlból.

Ez a példa részletesen bemutatja, hogyan működik a fájlrendszer és a szülőkönyvtárból történő importálás a Pythonban.

Az ImportError és a ModuleNotFoundError kezelése a Pythonban

A Python ImportError kivételt állít fel , ha az importálni kívánt modul nem található az importálási folyamat során.

Az ImportError a ModuleNotFoundError kivétel alosztálya . Akkor jelenik meg, ha az importált modul nem létezik, vagy nem tölthető be.

Az alábbi példák azokra a forgatókönyvekre, amikor ezek előfordulhatnak:

• A modul vagy csomag nem található a sys.path útvonalon .

• A modul vagy a csomag neve hibásan van írva, vagy nem létezik.

• Probléma van a modul kódjával, ami megakadályozza a megfelelő importálást.

Ha ezekkel a hibákkal találkozik, a következő megoldásokat használhatja:

• A modul vagy csomag helyesírásának és meglétének kétszeri ellenőrzése.

• A szükséges könyvtár hozzáadása a sys.path fájlhoz az append() vagy insert() segítségével .

• A modul importálását akadályozó hibák kijavítása.

Ha többet szeretne megtudni a Python hibáinak kezeléséről, tekintse meg a következő videót:

Miután megértette, hogyan működik az importálás a Pythonban, az is fontos, hogy ismerkedjen a Python könyvtárszerkezetével.

A címtárstruktúra és az importálás kéz a kézben járnak egymással, mivel az importálás megköveteli a címtárstruktúra megértését, ezért nézzük meg ezt a következő részben.

Python címtárstruktúra

A Python címtárszerkezet megértése több, mint annak ismerete, hogy hova kell elhelyezni a szkripteket, vagy hol található az éppen telepített könyvtár.

Olyan ez, mint egy tiszta, jól szervezett íróasztal: pontosan tudni fogja, hol van minden, és a termelékenysége az egekbe fog szökni, ezért ebben a részben tekintsük át az alapokat.

Csomag felépítése

A Python-projektek címtárszerkezete elengedhetetlen a megfelelő szervezéshez. Ha megfelelően strukturálja a csomagot, az segít minimalizálni az elnevezési ütközések lehetőségét. Ezenkívül lehetővé teszi, hogy könnyedén navigáljon a fájlrendszerben.

A következő egy tipikus Python-projekt könyvtárszerkezet:

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

A fenti példában a project a gyökérkönyvtár, amely két alcsomagot, a package1- et és a package2-t tartalmaz . Minden csomag rendelkezik .py fájlokkal és egyedi init.py fájllal.

Mik azok az init.py fájlok?

Az init.py fájlok fontosak a csomag viselkedésének meghatározásához az importálás során. Ezek a fájlok a szülőcsomagjuk importálásakor futnak le.

Az init.py fájlok lehetnek üresek, vagy tartalmazhatnak inicializálási kódot. Azt is jelzik a Pythonnak, hogy a mappát csomagként kell kezelni.

Modul importálásához szülőkönyvtárból használhatja a sys.path metódust . A szülőkönyvtár elérési útját hozzá kell fűznie a sys.path fájlhoz .

Ennek demonstrálására építsünk az előző példánkra. A következő könyvtárszerkezettel rendelkeztünk:

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

Most adjuk hozzá az init.py fájlt a my_module könyvtárhoz. Ezt a fájlt egyelőre üresen hagyhatja. Jelenléte azt jelzi a Python számára, hogy ezt a könyvtárat csomagként kell kezelni.

A könyvtárszerkezet most a következőképpen néz ki:

Az init.py fájl hozzáadása után módosítania kell a main.py fájlt, hogy utasítsa azt, hogy a module_dir mappát csomagként kezelje . A main.py fájlnak a következő kóddal kell rendelkeznie:

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

Ebben a példában a main.py importálja a module_dir csomagot, majd meghívja a my_function() függvényt a my_module-ból a csomagon belül.

Jegyezze meg a változást a my_function hívásában ; mivel a modul_dir-t most csomagként kezeljük , a csomag nevét a csomagon belüli modulokból történő függvények hívásakor szerepeltetnünk kell.

A kimenet hasonló lesz az előzőhöz. Az egyetlen változtatás az volt, hogy a module_dir-t az init.py fájlt tartalmazó csomagként kezeltük .

Python keresési útvonal

Gondolkozott már azon, hogy a Python honnan tudja, hol találja az importálni kívánt modulokat? Vagy talán találkozott egy bosszantó „ModuleNotFoundError” hibával, és nem tudta kideríteni, miért?

Ebben a részben ezekkel a rejtélyekkel foglalkozunk, és belemélyedünk a Python keresési útvonal koncepciójába.

A Python keresési útvonala, más néven sys.path , a Python kis útiterve az összes szükséges modul megtalálásához. Mint egy szorgalmas felderítő, a Python ezt az utat használja arra, hogy a számítógépen modulokat keressen, amikor az importálási utasítást használja.

Működésének megértése megóvhatja Önt a fejfájástól, és segíthet a hibaelhárításban, ha a dolgok rosszul sülnek el, ezért nézzünk át néhány alapvető dolgot!

1. Mi az a sys.path lista a Pythonban?

A sys.path lista kulcsfontosságú összetevő a modulok könyvtárba történő importálásakor. Ez a modul keresési útvonalát jelölő karakterláncok listája.

Minden egyes karakterlánc modulokat ( *.py fájlok) vagy csomagokat ( init.py fájlokat tartalmazó mappákat) keres.

A következő példa bemutatja, hogyan tekintheti meg az aktuális sys.path listát:

import sys

for path in sys.path:
    print(path)

A fenti kód futtatása után a következőhöz hasonló kimenetet fog látni:

Új könyvtárakat is hozzáadhat a sys.path listához, hogy a Python megtalálja az egyéni modulokat.

Például:

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

2. Mik azok a PythonPath környezeti változók?

A modul keresési útvonalának kezelésének másik módja a PYTHONPATH környezeti változó használata.

A PYTHON PATH egy olyan könyvtárat tartalmazó karakterlánc, amely hozzá van fűzve az alapértelmezett sys.path listához. Ez azt jelenti, hogy könyvtárakat adhat hozzá a PYTHONPATH-hoz. Ez lehetővé teszi a Pythonnak, hogy importáláskor modulokat keressen ezekben a könyvtárakban.

A PYTHONPATH környezeti változó beállítása az operációs rendszertől függ:

• Unix-alapú rendszerek (Linux, macOS) : Használhatja az export parancsot a termináljában, vagy hozzáadhatja a következő sort a shell konfigurációs fájljához ( .bashrc , .zshrc vagy hasonló):

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

• Windows operációs rendszer : Lépjen a Rendszertulajdonságok > Környezeti változók menüpontra, és a Felhasználói változók alatt kattintson az Új lehetőségre , hogy létrehozzon egy új változót a következő névvel: „PYTHONPATH”, és az értéket a könyvtárútvonalak listájaként pontosvesszővel (;) választva el.

  C:pathtomoduledirectory1;C:pathtomoduledirectory2
  

Miután beállította az elérési útváltozót, futtathatja a Python-szkriptet. Megkeresi az importált modulokat ezekben a könyvtárakban, valamint az alapértelmezett modulokat a sys.path könyvtárban .

Amikor a kódot fájlokba és mappákba rendezi, gyakran találkozhat relatív importálással és a sys.path módosításával .

A következő részben mindkettőt megvizsgáljuk, és megnézzük, hogyan illeszkednek a Python-importálási keretrendszerbe.

Szülőcímtár importálása

A kódokat különböző mappákba és fájlokba rendezheti az olvashatóság és a karbantarthatóság javítása érdekében. A modulok szülőkönyvtárakból történő importálása azonban kissé körülményes lehet.

Ebben a részben két megközelítést tárgyalunk ennek eléréséhez:

1. Relatív import

2. A sys.path beállítása

1. Relatív import

A relatív importálás lehetővé teszi a modulok importálását a címtárhierarchiában elfoglalt relatív pozíciójuk alapján.

Használhatja a pont ( . ) jelölést az aktuális könyvtárra, a duplapont ( .. ) jelölést pedig a szülőkönyvtárra.

Tegyük fel, hogy a következőhöz hasonló könyvtárszerkezettel rendelkezik:

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

A module_b.py fájlban relatív importálást használhat a module_a.py eléréséhez :

from .. import module_a

A dupla pont a szülőkönyvtárra utal. Fontos megjegyezni, hogy a relatív importálás csak akkor működik, ha a szülőkönyvtár egy csomag ( init.py fájllal rendelkezik).

2. A sys.path beállítása

A modulokat szülőkönyvtárból is importálhatja a sys.path módosításával .

Az importálási utasítás előtt hozzáfűzheti a szülőkönyvtár elérési útját a sys.path . Először is importálnia kell a sys modult. Ezután az OS modul segítségével kapja meg a szülőkönyvtár elérési útját.

Tegyük fel, hogy a következőhöz hasonló könyvtárszerkezettel rendelkezik:

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

A module_b.py fájlban a szülőkönyvtár elérési útját hozzáfűzheti a sys.path fájlhoz a következőképpen:

import os
import sys

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

import module_a

Most a Python meg fogja keresni a module_a.py fájlt a szülőkönyvtárban, amikor importálja a module_b.py fájlba .

A relatív importálási megközelítést vagy a sys.path megközelítést használhatja a modulok szülőkönyvtárból történő importálásához.

Hogyan kell dolgozni modulokkal és csomagokkal

A Pythonban a modulok és csomagok a kód rendszerezésének és újrafelhasználásának módjai. Segítségükkel összetett projekteket oszthat fel kezelhető részekre.

Ez a rész azt tárgyalja, hogyan kell dolgozni a modulokkal és csomagokkal a . Olyan kulcsfogalmakat is tartalmazunk, mint például:

1. Névterek

2. Változók és definíciók

3. Nyilatkozatok importálása

1. Mik azok a névterek?

A Python névterei biztosítják, hogy a változók, függvények és osztályok nevei ne ütközzenek a különböző modulok között.

A Pythonban különböző szintű névterek léteznek, például:

• Globális névtér: A teljes modul névterére utal.

• Helyi névtér: Egy függvényen vagy osztályon belüli névtérre utal.

Egy adott névtérben a névtér[név] jelöléssel kaphat nevet .

2. Mik azok a változók és definíciók?

A Python-szkriptben változókat, , és osztályokat definiálhat. Ezek a definíciók a szkript névterében tárolódnak.

A parancsfájl csomagként történő importálásával elérheti és újra felhasználhatja a definícióit a projekt más részein.

A következő példa egy változó és egy függvény definiálására szolgál ugyanabban a névtérben:

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

Ennek a modulnak van egy változója a my_variable és a my_function függvénye .

A kód futtatásához hozzon létre egy új fájlt my_variable.py néven , és helyezze el a kódot az alábbiak szerint:

Most importálhatja ezt a fájlt, és használhatja egy másik szkriptben az alábbiak szerint:

A main.py fájl futtatása után a következőhöz hasonló kimenetet kap:

3. Mik azok az import nyilatkozatok?

Az import utasítással fájlokat, modulokat vagy csomagokat importálhat Pythonban

Néhány általános importálási módszer:

• import modul_neve : Ez a metódus egy modult importál, és minden definícióját elérhetővé teszi a modul_neve.definíció_neve jelöléssel.

import mymodule

result = mymodule.my_function(3)

• from module_name import some_definition : Ez a metódus egy adott definíciót importál egy modulból, lehetővé téve annak közvetlen használatát a modul előtagja nélkül.

from mymodule import my_function

result = my_function(3)

• from module_name import * : Ez a módszer az összes definíciót importálja egy modulból, de nem ajánlott, mivel elnevezési ütközésekhez vezethet.

Végső gondolatok

A Python szülőkönyvtárából történő importálásának megértése fontos a szervezett kódbázis karbantartásához.

Ez a tudás lehetővé teszi a projektek modulárisabb tervezését. Ezenkívül növeli a kód újrafelhasználhatóságát. Ha a kódot külön modulokba és csomagokba strukturálja, elkerülheti a kód ismétlődését, és megkönnyítheti a karbantartást és frissítést.

Az importálás és az utasítások használatának készsége akkor a legértékesebb, ha nagyobb projekteken dolgozik, ahol a funkciók különböző könyvtárak között vannak felosztva.

Ha tudja, hogyan kell helyesen módosítani a Python elérési útját a modulok importálásához, elérheti az egyik könyvtárban meghatározott funkciókat, miközben egy másikban dolgozik.

Ne feledje, a Python – vagy bármely programozási nyelv – elsajátításának kulcsa a következetes gyakorlatban és a kielégíthetetlen kíváncsiságban rejlik. Tehát folytassa a felfedezést, kísérletezzen, és folytassa a kihívásokat.

Ezzel a gyors útmutatóval jól fel kell készülnie ahhoz, hogy kezelni tudja a Python által felvetett importrejtvényeket. De ne állj meg itt. Python technikák és trükkök egész univerzuma vár felfedezésre!