Python-tuonti päähakemistosta: Pikaopas

Oletko koskaan huomannut olevasi polviin asti Python-tiedostoissa, kun sinulla on vaikeuksia tuoda moduulia ylähakemistosta? Jos on, olet hyvässä seurassa. Pythonin tuontijärjestelmä voi joskus tuntua kiemurtelevalta sokkelolta, mutta älä huoli, me autamme sinua navigoinnissa!

Voit tuoda Pythonin ylähakemistosta sys- moduulin avulla. Lisäämällä vaaditun hakemiston sys.path-luetteloon annat tulkille halutun moduulin sijainnin. Kun olet muokannut sys.path-osoitetta, voit tuoda kohdemoduulin tavallisella tuontikäskyllä.

Tässä artikkelissa tutkimme, kuinka voit tuoda Pythonin ylätason hakemistoista. Lisäksi tarkastelemme tiettyjä tuonnin käyttötapauksia, jotka auttavat sinua ymmärtämään paremmin hakemistojen taustalla olevaa rakennetta.

Mennään asiaan!

Sisällysluettelo

• Kuinka tuoda Pythonissa
  • Mikä on Python-tuontijärjestelmä?
  • Päähakemistosta tuonnin esittely
    • 1. Luodaan tarvittavat hakemistot ja tiedostot
    • 2. Python-tiedostojen lisääminen
    • 3. Python-tiedostojen muokkaaminen
    • 4. Koodin suorittaminen
  • ImportError- ja ModuleNotFoundError-virheiden käsitteleminen Pythonissa
• Python-hakemistorakenne
  • Paketin rakenne
  • Mitä ovat init.py-tiedostot?
• Python-hakupolku
  • 1. Mikä on Pythonin sys.path-luettelo?
  • 2. Mitä ovat PythonPath-ympäristömuuttujat?
• Emohakemiston tuonti
  • 1. Suhteellinen tuonti
  • 2. Säädetään sys.path
• Kuinka työskennellä moduulien ja pakettien kanssa
  • 1. Mitä nimiavaruudet ovat?
  • 2. Mitä ovat muuttujat ja määritelmät?
  • 3. Mitä tuontilausunnot ovat?
• Lopulliset ajatukset

Kuinka tuoda Pythonissa

Siirrymme suoraan tämän päivän aiheeseen: tuonti Pythonissa. Ne yksinkertaiset koodirivit Python-skriptien alussa, jotka usein alkavat sanalla tuonti tai ? Nämä ovat lippusi Pythonin laajojen kirjastojen ja moduulien tehon hyödyntämiseen.

Tässä osiossa käydään läpi Pythonin ylähakemistosta tuonnin koodi. Tarkastelemme myös mahdollisia virheitä, joita voi syntyä tuotaessa moduuleja ylätason hakemistosta.

Mikä on Python-tuontijärjestelmä?

Python-tuontijärjestelmä mahdollistaa tehokkaan koodin uudelleenkäytön ja organisoinnin. Se helpottaa monimutkaisten projektien ylläpitoa.

Voit tuoda moduulin tai paketin Pythonissa käyttämällä tuontikäskyä . Moduulit jaetaan paketteina, jotka ovat hakemistoja, joissa on kokoelma Python-tiedostoja.

Jos haluat tuoda moduulin päähakemistosta, voit lisätä päähakemiston Pythonin polkuun sys.path- moduulilla. Kun olet lisännyt päähakemiston, voit tuoda moduulin tuontikäskyllä .

Päähakemistosta tuonnin esittely

Jotta saat selkeän esittelyn ylätason hakemistosta tuomisesta, käydään läpi useita vaiheita, jotka auttavat sinua ymmärtämään koko prosessin.

1. Luodaan tarvittavat hakemistot ja tiedostot

Avaa ensin tiedostonhallinta ja siirry haluamaasi paikalliseen asemaan. Käytän paikallista E-asemaani, joten luon uuden hakemiston nimeltä oma_projekti .

Luo oma_projektini sisällä toinen hakemisto nimeltä moduulin_hakemisto .

Joten sinulla pitäisi nyt olla:

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

2. Python-tiedostojen lisääminen

Luo seuraavaksi uusi .py- tiedosto nimeltä main.py projektini hakemistoon .

Luo sen jälkeen toinen Python-tiedosto nimeltä my_module.py kansioon module_dir .

Rakenteenne pitäisi nyt näyttää tältä:

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

Jos käytät Visual Studio Codea , hakemistorakenteen pitäisi näyttää seuraavalta:

3. Python-tiedostojen muokkaaminen

Avaa my_module.py ja lisää seuraava koodi:

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

Siirry sitten eteenpäin ja tallenna ja sulje tiedosto.

Avaa nyt main.py ja lisää seuraava koodi:

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

Tässä komentosarjassa selvitämme ensin hakemiston sijainnin, joka on yksi taso ylempänä käynnissä olevasta skriptistä (se on päähakemisto). Sitten pyydämme Pythonia etsimään myös tästä yläkansiosta, kun sen on tuotava moduuleja.

Tämän jälkeen tuomme moduulin nimeltä my_module , joka on hakemistossa nimeltä module_dir ja joka sijaitsee tässä päähakemistossa. Lopuksi kutsumme funktiota nimeltä my_function from my_module .

Kun olet lisännyt yllä olevan koodin, tallenna ja sulje tiedosto.

4. Koodin suorittaminen

Suorita tämä koodi avaamalla haluamasi koodieditorin pääte ja suorittamalla main.py- tiedosto. Jos käytät Visual Studio Codea, lähdön pitäisi näyttää tältä:

Main.py tuo funktion osoitteesta my_module.py , kuten yllä olevassa kuvassa näkyy.

Tämä esimerkki näyttää yksityiskohtaisesti, kuinka tiedostojärjestelmä ja tuonti päähakemistosta toimivat Pythonissa.

ImportError- ja ModuleNotFoundError-virheiden käsitteleminen Pythonissa

Python herättää ImportError- poikkeuksen, kun moduulia, jota yrität tuoda, ei löydy tuontiprosessin aikana.

ImportError on ModuleNotFoundError- poikkeuksen alaluokka . Se nostetaan, kun tuotua moduulia ei ole olemassa tai sitä ei voida ladata.

Seuraavassa on esimerkkejä skenaarioista, joissa näitä voi tapahtua:

• Moduuli tai paketti ei ole sys.polussa .

• Moduulin tai paketin nimi on kirjoitettu väärin tai sitä ei ole olemassa.

• Moduulin koodissa on ongelma, joka estää sen oikean tuonnin.

Kun kohtaat näitä virheitä, voit käyttää seuraavia ratkaisuja:

• Tarkista oikeinkirjoitus ja moduulin tai paketin olemassaolo.

• Tarvittavan hakemiston lisääminen sys.path- tiedostoon append () - tai insert()-komennolla .

• Korjataan kaikki ongelmat moduulin koodissa, jotka voivat estää sen tuontia.

Saat lisätietoja Pythonin virheiden käsittelystä katsomalla seuraavaa videota:

Kun olet ymmärtänyt, kuinka tuonti toimii Pythonissa, on myös tärkeää perehtyä Pythonin hakemistorakenteeseen.

Hakemistorakenne ja tuonti kulkevat käsi kädessä toistensa kanssa, sillä tuonti edellyttää hakemistorakenteen ymmärtämistä, joten käydään sitä läpi seuraavassa osiossa.

Python-hakemistorakenne

Python-hakemistorakenteen ymmärtäminen on enemmän kuin vain sen tietämistä, mihin skriptit asetetaan tai mistä juuri asentamasi kirjasto löytyy.

Se on kuin puhdas, hyvin järjestetty työpöytä: tiedät tarkalleen missä kaikki on, ja tuottavuutesi nousee pilviin, joten käydään läpi perusasiat tässä osiossa.

Paketin rakenne

Python-projektin hakemistorakenne on välttämätön oikean organisoinnin kannalta. Jos rakentelet paketin oikein, se auttaa minimoimaan nimiristiriitojen mahdollisuuden. Lisäksi sen avulla voit helposti selata tiedostojärjestelmääsi.

Seuraava on tyypillinen Python-projektihakemistorakenne:

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

Yllä olevassa esimerkissä projekti on juurihakemisto, joka sisältää kaksi alipakettia, paketti1 ja paketti2 . Jokaisessa paketissa on .py- tiedostonsa ja yksilöllinen init.py- tiedosto.

Mitä ovat init.py-tiedostot?

init.py- tiedostot ovat tärkeitä määritettäessä paketin toimintaa tuonnin yhteydessä. Nämä tiedostot suoritetaan, kun niiden emopaketti tuodaan.

Init.py - tiedostot voivat olla tyhjiä tai sisältää alustuskoodin. Ne osoittavat myös Pythonille, että kansiota tulee käsitellä pakettina.

Voit tuoda moduulin ylätason hakemistosta käyttämällä sys.path -menetelmää. Sinun on liitettävä ylähakemiston polku sys.path -tiedostoon .

Tämän osoittamiseksi rakennamme edellistä esimerkkiämme. Meillä oli seuraava hakemistorakenne:

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

Lisätään nyt tiedosto init.py my_module - hakemistoon. Voit jättää tämän tiedoston tyhjäksi toistaiseksi. Sen läsnäolo osoittaa Pythonille, että tätä hakemistoa tulee käsitellä pakettina.

Hakemistosi rakenteen pitäisi nyt näyttää tältä:

Kun olet lisännyt init.py- tiedoston, sinun on tehtävä main.py- tiedostoosi muutoksia, jotta se käsittelee module_dir- kansiota pakettina. Main.py- tiedostossasi pitäisi nyt olla seuraava koodi:

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

Tässä esimerkissä main.py tuo paketin module_dir ja kutsuu sitten funktiota my_function() paketista my_module.

Huomaa muutos my_function -funktion kutsussa ; Koska käsittelemme nyt module_dir- hakemistoa pakettina, meidän on sisällytettävä paketin nimi, kun kutsumme toimintoja paketin moduuleista.

Tulos on samanlainen kuin edellinen. Ainoa muutos, jonka teimme, oli käsitellä module_dir- hakemistoa pakettina, joka sisälsi init.py- tiedoston.

Python-hakupolku

Oletko koskaan miettinyt, kuinka Python tietää, mistä löytää moduulit, joita yrität tuoda? Tai ehkä olet havainnut ärsyttävän ModuleNotFoundError-virheen etkä ole ymmärtänyt syytä?

Tässä osiossa käsittelemme näitä mysteereitä suoraan ja syvennymme Python-hakupolun käsitteeseen.

Python-hakupolku, joka tunnetaan myös nimellä sys.path , on Pythonin pieni etenemissuunnitelma kaikkien tarvitsemiesi moduulien löytämiseen. Kuten ahkera tiedustelija, Python käyttää tätä polkua etsiäkseen tietokoneeltasi moduuleja aina, kun käytät tuontikäskyä.

Sen toiminnan ymmärtäminen voi säästää päänsäryltä ja auttaa vianmäärityksessä, kun asiat menevät pieleen, joten käydään läpi joitakin perusasioita!

1. Mikä on Pythonin sys.path-luettelo?

Sys.path - luettelo on tärkeä komponentti, kun moduuleja tuodaan hakemistoon. Se on luettelo merkkijonoista, jotka edustavat moduulin hakupolkua.

Jokainen merkkijono etsii moduuleja ( *.py- tiedostot) tai paketteja ( init.py- tiedostoja sisältävät kansiot).

Seuraava esimerkki näyttää, kuinka voit tarkastella nykyistä sys.path- luetteloasi:

import sys

for path in sys.path:
    print(path)

Kun olet suorittanut yllä olevan koodin, näet seuraavanlaisen tulosteen:

Voit myös lisätä uusia hakemistoja sys.path- luetteloon, jotta Python löytää mukautetut moduulit.

Esimerkiksi:

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

2. Mitä ovat PythonPath-ympäristömuuttujat?

Toinen tapa hallita moduulin hakupolkua on käyttää PYTHONPATH- ympäristömuuttujaa.

PYTHON PATH on merkkijono, joka sisältää hakemistoja, jotka liitetään oletusarvoiseen sys.path -luetteloon. Tämä tarkoittaa, että voit lisätä hakemistoja PYTHONPATHiin. Tämän ansiosta Python voi etsiä moduuleja näistä hakemistoista tuonnin yhteydessä.

PYTHONPATH- ympäristömuuttujan asettaminen riippuu käyttöjärjestelmästäsi:

• Unix-pohjaiset järjestelmät (Linux, macOS) : Voit käyttää terminaalissasi vientikomentoa tai lisätä seuraavan rivin shell-määritystiedostoon ( .bashrc , .zshrc tai vastaava):

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

• Windows-käyttöjärjestelmä : Siirry kohtaan Järjestelmän ominaisuudet > Ympäristömuuttujat ja napsauta Käyttäjämuuttujat -kohdassa Uusi luodaksesi uuden muuttujan, jonka nimi on "PYTHONPATH" ja arvo hakemistopolkujen luettelona puolipisteellä (;) erotettuna.

  C:pathtomoduledirectory1;C:pathtomoduledirectory2
  

Kun polkumuuttuja on asetettu, voit suorittaa Python-skriptin. Se etsii tuodut moduulit näistä hakemistoista sekä oletusmoduulit sys.path : sta .

Kun järjestät koodisi tiedostoihin ja kansioihin, törmäät usein suhteellisiin tuontiin ja sys.path -tiedoston säätämiseen .

Seuraavassa osiossa tutkimme molempia ja katsomme, kuinka ne sopivat Python-tuontikehykseen.

Emohakemiston tuonti

Voit järjestää koodin eri kansioihin ja tiedostoihin parantaaksesi luettavuutta ja ylläpidettävyyttä. Moduulien tuonti päähakemistoista voi kuitenkin olla hieman hankalaa.

Tässä osiossa keskustelemme kahdesta lähestymistavasta tämän saavuttamiseksi:

1. Suhteellinen tuonti

2. Säädetään sys.path

1. Suhteellinen tuonti

Suhteellisen tuonnin avulla voit tuoda moduuleja niiden suhteellisen sijainnin perusteella hakemistohierarkiassa.

Voit käyttää pisteen ( . ) merkintää viittaamaan nykyiseen hakemistoon tai kaksoispisteen ( .. ) merkintää viittaamaan päähakemistoon.

Oletetaan, että sinulla on seuraavanlainen hakemistorakenne:

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

Module_b.py:n sisällä voit käyttää suhteellisia tuontija päästäksesi module_a.py:hen :

from .. import module_a

Kaksoispiste viittaa päähakemistoon. On tärkeää huomata, että suhteellinen tuonti toimii vain, jos päähakemisto on paketti (jossa on init.py -tiedosto).

2. Säädetään sys.path

Voit myös tuoda moduuleja ylätason hakemistosta muokkaamalla sys.path .

Ennen tuontikäskyä voit liittää sys.path -hakemistoon päähakemistopolun . Ensin sinun on tuotava sys- moduuli. Sitten käytät os- moduulia saadaksesi päähakemistopolun.

Oletetaan, että sinulla on seuraavanlainen hakemistorakenne:

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

Kohdassa module_b.py voit liittää päähakemiston polun sys.path- tiedostoon seuraavasti:

import os
import sys

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

import module_a

Python etsii nyt hakemistoa module_a.py ylätason hakemistosta, kun se tuodaan module_b.py -hakemistoon .

Voit käyttää joko suhteellista tuontitapaa tai sys.path -lähestymistapaa moduulien tuomiseen ylätason hakemistosta.

Kuinka työskennellä moduulien ja pakettien kanssa

Pythonissa moduulit ja paketit ovat tapa järjestää ja käyttää koodia uudelleen. Voit käyttää niitä monimutkaisten projektien jakamiseen hallittaviin osiin.

Tässä osiossa käsitellään moduulien ja pakettien käyttöä . Otamme mukaan myös tärkeitä käsitteitä, kuten:

1. Nimiavaruudet

2. Muuttujat ja määritelmät

3. Tuo lausunnot

1. Mitä nimiavaruudet ovat?

Pythonin nimitilat ovat tapa varmistaa, että muuttujien, funktioiden ja luokkien nimet eivät ole ristiriidassa eri moduulien välillä.

Pythonissa on erilaisia ​​nimiavaruuksia, kuten:

• Yleinen nimiavaruus: Viittaa koko moduulin nimiavaruuteen.

• Paikallinen nimiavaruus: Viittaa nimiavaruuteen funktion tai luokan sisällä.

Voit hankkia nimen tietyssä nimiavaruudessa nimiavaruuden [nimi] -merkinnällä.

2. Mitä ovat muuttujat ja määritelmät?

Python-skriptissä voit määrittää muuttujia, , ja luokkia. Nämä määritelmät tallennetaan skriptin nimiavaruuteen.

Tuomalla komentosarjan pakettina voit käyttää ja käyttää sen määritelmiä projektin muissa osissa.

Seuraavassa on esimerkki muuttujan ja funktion määrittämisestä samassa nimiavaruudessa:

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

Tässä moduulissa on muuttuja my_variable ja funktio my_function .

Voit suorittaa tämän koodin luomalla uuden tiedoston nimeltä my_variable.py ja sijoittamalla koodin siihen alla olevan kuvan mukaisesti:

Nyt voit tuoda tämän tiedoston ja käyttää sitä toisessa skriptissä alla olevan kuvan mukaisesti:

Main.py -tiedoston suorittamisen jälkeen saat seuraavanlaisen tulosteen:

3. Mitä tuontilausunnot ovat?

Voit tuoda tiedostoja, moduuleja tai paketteja Pythonissa tuontikäskyn avulla

Joitakin yleisiä tuontitapoja ovat:

• tuonti moduulin_nimi : Tämä menetelmä tuo moduulin, jolloin kaikki sen määritelmät ovat käytettävissä moduulin_nimi.määritelmän_nimi- merkinnällä .

import mymodule

result = mymodule.my_function(3)

• kohteesta moduulin_nimi tuonti jokin_määritelmä : Tämä menetelmä tuo tietyn määritelmän moduulista, jolloin voit käyttää sitä suoraan ilman moduulin etuliitettä.

from mymodule import my_function

result = my_function(3)

• moduulin_nimi tuonti * : Tämä menetelmä tuo kaikki määritelmät moduulista, mutta sitä ei suositella, koska se voi johtaa nimeämisristiriioihin.

Lopulliset ajatukset

Pythonin ylähakemistosta tuomisen ymmärtäminen on tärkeää järjestetyn koodikannan ylläpitämisessä.

Tämän tiedon avulla voit suunnitella projekteja modulaarisella tavalla. Se myös lisää koodisi uudelleenkäytettävyyttä. Järjestämällä koodisi erillisiksi moduuleiksi ja paketeiksi voit välttää koodin toistamisen ja helpottaa sen ylläpitoa ja päivittämistä.

Tuonti- ja lausekkeiden käyttötaito on arvokkainta silloin, kun työskentelet isommissa projekteissa, joissa toiminnot on jaettu eri hakemistoihin.

Kun osaat säätää Pythonin polkua moduulien tuontia varten, voit käyttää yhdessä hakemistossa määritettyjä toimintoja työskennellessäsi toisessa.

Muista, että avain Pythonin – tai minkä tahansa ohjelmointikielen – hallitsemiseen piilee johdonmukaisessa harjoittelussa ja kyltymättömässä uteliaisuudessa. Joten jatka tutkimista, kokeilemista ja haasta itsesi.

Tämän pikaoppaan avulla sinun pitäisi olla hyvin varusteltu käsittelemään kaikkia Pythonin sinulle heittämiä tuontipulmia. Mutta älä lopeta tähän. Siellä on kokonainen universumi Python-tekniikoita ja temppuja, jotka odottavat löytämistään!