Import Python Dari Direktori Induk: Panduan Ringkas

Pernah mendapati diri anda setinggi lutut dalam fail Python, bergelut untuk mengimport modul daripada direktori induk? Jika ya, anda berada dalam syarikat yang baik. Sistem import Python kadangkala boleh berasa seperti labirin yang berliku-liku, tetapi jangan risau, kami di sini untuk membantu anda menavigasi!

Untuk mengimport daripada direktori induk dalam Python, anda boleh menggunakan modul sys . Dengan memasukkan direktori yang diperlukan ke dalam senarai sys.path, anda memberikan penterjemah lokasi modul yang dikehendaki. Selepas mengubah suai sys.path, anda boleh mengimport modul sasaran menggunakan pernyataan import standard.

Dalam artikel ini, kami akan meneroka cara anda boleh mengimport daripada direktori induk dalam Python. Selain itu, kami akan melihat kes penggunaan khusus pengimportan yang akan membantu anda memahami dengan lebih baik struktur asas direktori.

Mari kita masuk ke dalamnya!

Isi kandungan

• Bagaimana untuk Mengimport dalam Python
  • Apakah Sistem Import Python?
  • Demonstrasi Mengimport daripada Direktori Induk
    • 1. Mencipta direktori dan fail yang diperlukan
    • 2. Menambah fail Python
    • 3. Mengedit fail Python
    • 4. Menjalankan Kod
  • Cara Mengendalikan ImportError dan ModuleNotFoundError dalam Python
• Struktur Direktori Python
  • Struktur Pakej
  • Apakah Fail init.py?
• Laluan Carian Python
  • 1. Apakah sys.path List dalam Python?
  • 2. Apakah Pembolehubah Persekitaran PythonPath?
• Import Direktori Induk
  • 1. Import Relatif
  • 2. Melaraskan sys.path
• Cara Bekerja Dengan Modul dan Pakej
  • 1. Apakah Ruang Nama?
  • 2. Apakah Pembolehubah dan Definisi?
  • 3. Apakah Penyata Import?
• Fikiran Akhir

Bagaimana untuk Mengimport dalam Python

Kami akan melompat terus ke topik hari ini: mengimport dalam Python. Baris kod ringkas pada permulaan skrip Python anda yang selalunya bermula dengan import atau dari ? Itu adalah tiket anda untuk memanfaatkan kuasa perpustakaan dan modul Python yang luas.

Dalam bahagian ini, kami akan menyemak kod untuk mengimport daripada direktori induk dalam Python. Kami juga akan melihat kemungkinan ralat yang boleh timbul apabila mengimport modul daripada direktori induk.

Apakah Sistem Import Python?

Sistem import Python membolehkan penggunaan semula dan organisasi kod yang cekap. Ia memudahkan anda untuk mengekalkan projek yang kompleks.

Untuk mengimport modul atau pakej dalam Python, anda boleh menggunakan pernyataan import . Modul diedarkan sebagai pakej, yang merupakan direktori dengan koleksi fail Python.

Untuk mengimport modul daripada direktori induk, anda boleh menggunakan modul sys.path untuk menambah direktori induk pada laluan Python. Selepas menambah direktori induk, anda boleh mengimport modul menggunakan pernyataan import .

Demonstrasi Mengimport daripada Direktori Induk

Untuk memberi anda demonstrasi yang jelas tentang pengimportan daripada direktori induk, mari kita semak beberapa langkah untuk membantu anda memahami keseluruhan proses.

1. Mencipta direktori dan fail yang diperlukan

Mula-mula, buka penjelajah fail anda dan navigasi ke pemacu setempat yang anda inginkan. Saya menggunakan pemacu E tempatan saya, oleh itu, saya akan mencipta direktori baharu bernama my_project .

Di dalam my_project , buat direktori lain bernama module_dir .

Jadi, anda kini sepatutnya mempunyai:

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

2. Menambah fail Python

Seterusnya, cipta fail .py baharu bernama main.py dalam direktori my_project .

Selepas itu, buat fail Python lain bernama my_module.py dalam module_dir .

Struktur anda kini sepatutnya kelihatan seperti ini:

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

Jika anda menggunakan Visual Studio Code , struktur direktori anda sepatutnya kelihatan seperti berikut:

3. Mengedit fail Python

Buka my_module.py anda dan tambah kod berikut:

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

Kemudian teruskan dan simpan dan tutup fail.

Sekarang, buka main.py dan tambah kod berikut:

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

Dalam skrip ini, kami mula-mula memikirkan lokasi direktori satu tahap ke atas daripada skrip yang kami jalankan (iaitu direktori induk). Kemudian, kami memberitahu Python untuk melihat juga dalam folder induk ini apabila ia perlu mengimport modul.

Selepas melakukan itu, kami mengimport modul bernama my_module yang berada di dalam direktori bernama module_dir yang terletak dalam direktori induk ini. Akhirnya, kami memanggil fungsi bernama my_function dari my_module .

Selepas menambah kod di atas, simpan dan tutup fail.

4. Menjalankan Kod

Untuk menjalankan kod ini, buka terminal editor kod yang anda inginkan dan jalankan fail main.py. Jika anda menggunakan Kod Visual Studio, output sepatutnya kelihatan seperti berikut:

Main.py akan mengimport fungsi dari my_module.py , seperti yang ditunjukkan dalam imej di atas.

Contoh ini menunjukkan secara terperinci bagaimana sistem fail dan pengimportan daripada direktori induk berfungsi dalam Python.

Cara Mengendalikan ImportError dan ModuleNotFoundError dalam Python

Python akan menimbulkan pengecualian ImportError apabila modul yang anda cuba import tidak ditemui semasa proses pengimportan.

ImportError ialah subkelas pengecualian ModuleNotFoundError . Ia dinaikkan apabila modul yang diimport tidak wujud atau tidak boleh dimuatkan.

The following are examples of scenarios when these may occur:

• The module or package is not in the sys.path.

• The module or package name is misspelled or does not exist.

• There is a problem with the module’s code, preventing it from being properly imported.

When encountering these errors, you could use the following solutions:

• Double-checking the spelling and existence of the module or package.

• Adding the necessary directory to sys.path using append() or insert().

• Fixing any issues in the module’s code that may be hindering its import.

To learn more about handling errors in Python, check the following video out:

After understanding how importing works in Python, it’s also important that you gain some familiarity with Python’s directory structure.

Directory structure and importing go hand-in-hand with each other as importing requires an understanding of the directory structure, so let’s go over that in the next section.

Python Directory Structure

Understanding the Python directory structure is more than just knowing where to put your scripts or where to find that library you just installed.

It’s like having a clean, well-organized desk: you’ll know exactly where everything is, and your productivity will skyrocket, so let’s go over the basics in this section.

Package Structure

The directory structure of a Python project is essential for correct organization. If you structure your package properly, it’ll help you minimize the chance of naming conflicts. Furthermore, it’ll also enable you to easily navigate through your filesystem.

The following is a typical Python project directory structure:

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

In the example above, project is the root directory containing two sub-packages, package1 and package2. Each package has its .py files and a unique init.py file.

What Are init.py Files?

init.py files are important for defining the package’s behavior when it’s imported. These files are executed when their parent package is imported.

The init.py files can be empty or contain initialization code. They also indicate to Python that the folder should be treated as a package.

To import a module from a parent directory, you can use the sys.path method. You’ll need to append the parent directory path to sys.path.

To demonstrate this, let’s build up on our previous example. We had the following directory structure:

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

Now, let’s add the init.py file to my_module directory. You can leave this file empty for now. Its presence indicates to Python that this directory should be treated as a package.

Your directory structure should now look like the following:

After adding the init.py file, you must make changes to your main.py file to instruct it to treat the module_dir folder as a package. Your main.py file should now have the following code:

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 this example, main.py imports the module_dir package, and then calls the function my_function() from my_module within that package.

Note the change in the call to the my_function; because we are now treating module_dir as a package, we have to include the package name when calling functions from modules within the package.

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.

Sebelum penyataan import , anda boleh menambahkan laluan direktori induk ke sys.path . Pertama, anda perlu mengimport modul sys . Kemudian, anda menggunakan modul os untuk mendapatkan laluan direktori induk.

Katakan anda mempunyai struktur direktori seperti berikut:

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

Dalam module_b.py , anda boleh menambahkan laluan direktori induk ke sys.path seperti ini:

import os
import sys

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

import module_a

Sekarang, Python akan mencari module_a.py dalam direktori induk apabila mengimportnya dalam module_b.py .

Anda boleh menggunakan sama ada pendekatan import relatif atau pendekatan sys.path untuk mengimport modul daripada direktori induk.

Cara Bekerja Dengan Modul dan Pakej

Dalam Python, modul dan pakej ialah cara untuk mengatur dan menggunakan semula kod. Anda boleh menggunakannya untuk membahagikan projek yang kompleks kepada bahagian yang boleh diurus.

Bahagian ini akan membincangkan cara bekerja dengan modul dan pakej dalam Python . Kami juga akan memasukkan konsep utama seperti:

1. Ruang nama

2. Pembolehubah dan Definisi

3. Penyata Import

1. Apakah Ruang Nama?

Ruang nama dalam Python ialah satu cara untuk memastikan bahawa nama pembolehubah, fungsi dan kelas tidak bercanggah antara modul yang berbeza.

Terdapat pelbagai peringkat ruang nama dalam Python, seperti:

• Ruang Nama Global: Merujuk kepada ruang nama keseluruhan modul.

• Ruang Nama Tempatan: Merujuk kepada ruang nama dalam fungsi atau kelas.

Anda boleh mendapatkan nama dalam ruang nama tertentu dengan notasi ruang nama[nama] .

2. Apakah Pembolehubah dan Definisi?

Dalam skrip Python, anda boleh menentukan pembolehubah, fungsi dan kelas. Takrifan ini disimpan dalam ruang nama skrip.

Dengan mengimport skrip sebagai pakej, anda boleh mengakses dan menggunakan semula definisinya di bahagian lain projek anda.

Berikut ialah contoh cara untuk menentukan pembolehubah dan fungsi dalam ruang nama yang sama:

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

Modul ini mempunyai pembolehubah my_variable dan fungsi my_function .

Untuk menjalankan kod ini, anda boleh mencipta fail baharu bernama my_variable.py dan meletakkan kod di sana seperti yang ditunjukkan di bawah:

Sekarang, anda boleh mengimport fail ini dan menggunakannya dalam skrip lain seperti yang ditunjukkan di bawah:

Selepas menjalankan fail main.py , anda akan mendapat output yang serupa dengan yang berikut:

3. Apakah Penyata Import?

Anda boleh mengimport fail, modul atau pakej dalam Python dengan pernyataan import

Beberapa kaedah import biasa ialah:

• import module_name : Kaedah ini mengimport modul, menjadikan semua definisinya boleh diakses dengan notasi module_name.definition_name .

import mymodule

result = mymodule.my_function(3)

• from module_name import some_definition : Kaedah ini mengimport definisi khusus daripada modul, membolehkan anda menggunakannya secara langsung tanpa awalan modul.

from mymodule import my_function

result = my_function(3)

• from module_name import * : Kaedah ini mengimport semua definisi daripada modul, tetapi ia tidak disyorkan kerana ia boleh membawa kepada konflik penamaan.

Fikiran Akhir

Memahami cara mengimport daripada direktori induk dalam Python adalah penting dalam mengekalkan pangkalan kod yang teratur.

Pengetahuan ini membolehkan anda mereka bentuk projek anda dengan cara yang lebih modular. Ia juga meningkatkan kebolehgunaan semula kod anda. Dengan menstrukturkan kod anda ke dalam modul dan pakej yang berasingan, anda boleh mengelakkan kod berulang dan menjadikannya lebih mudah untuk diselenggara dan dikemas kini.

Kemahiran menggunakan penyata import dan daripada adalah paling berharga apabila anda mengusahakan projek yang lebih besar di mana fungsi dibahagikan kepada direktori yang berbeza.

Dengan mengetahui cara melaraskan laluan Python dengan betul untuk mengimport modul, anda boleh mengakses kefungsian yang ditakrifkan dalam satu direktori semasa bekerja dalam direktori lain.

Ingat, kunci untuk menguasai Python — atau mana-mana bahasa pengaturcaraan — terletak pada amalan yang konsisten dan rasa ingin tahu yang tidak pernah puas. Jadi, teruskan meneroka, teruskan percubaan, dan teruskan mencabar diri sendiri.

Dengan panduan ringkas ini, anda harus dilengkapi dengan baik untuk mengendalikan sebarang teka-teki import yang dilemparkan Python kepada anda. Tetapi jangan berhenti di sini. Terdapat seluruh alam semesta teknik dan helah Python menunggu untuk ditemui!