Ana Dizinden Python İçe Aktarma: Hızlı Kılavuz

Hiç kendinizi bir üst dizinden bir modülü içe aktarmaya çalışırken diz boyu Python dosyalarında buldunuz mu? Eğer öyleyse, iyi bir şirkettesiniz. Python'un içe aktarma sistemi bazen dolambaçlı bir labirent gibi gelebilir, ama merak etmeyin, gezinmenize yardımcı olmak için buradayız!

Python'da bir üst dizinden içe aktarmak için sys modülünü kullanabilirsiniz . Gerekli dizini sys.path listesine ekleyerek, tercümana istenen modülün konumunu sağlarsınız. Sys.path'i değiştirdikten sonra, standart import deyimini kullanarak hedef modülü içe aktarabilirsiniz.

Bu yazıda, Python'da ana dizinlerden nasıl içe aktarabileceğinizi keşfedeceğiz. Ayrıca, dizinlerin temel yapısını daha iyi anlamanıza yardımcı olacak içe aktarmanın belirli kullanım durumlarına bakacağız.

Hadi başlayalım!

İçindekiler

• Python'da Nasıl İçe Aktarılır
  • Python İçe Aktarma Sistemi nedir?
  • Üst Dizinden İçe Aktarmanın Gösterimi
    • 1. Gerekli dizin ve dosyaların oluşturulması
    • 2. Python dosyaları ekleme
    • 3. Python dosyalarını düzenleme
    • 4. Kodu Çalıştırma
  • Python'da ImportError ve ModuleNotFoundError Nasıl İşlenir?
• Python Dizin Yapısı
  • Paket Yapısı
  • init.py Dosyaları Nedir?
• Python Arama Yolu
  • 1. Python'daki sys.path Listesi nedir?
  • 2. PythonPath Ortam Değişkenleri nelerdir?
• Üst Dizin İçe Aktarmaları
  • 1. Bağıl İthalat
  • 2. sys.path'i ayarlama
• Modüller ve Paketlerle Nasıl Çalışılır?
  • 1. Ad Alanları Nedir?
  • 2. Değişkenler ve Tanımlar Nelerdir?
  • 3. İthalat Beyanları Nedir?
• Son düşünceler

Python'da Nasıl İçe Aktarılır

Doğrudan bugünün konusuna geçeceğiz: Python'da içe aktarma. Python betiklerinizin başındaki, genellikle import veya from ile başlayan bu basit kod satırları ? Bunlar, Python'un kapsamlı kitaplıklarının ve modüllerinin gücünden yararlanma biletinizdir.

Bu bölümde, Python'da üst dizinden içe aktarma kodunu inceleyeceğiz. Ana dizinden modülleri içe aktarırken ortaya çıkabilecek olası hatalara da bakacağız.

Python İçe Aktarma Sistemi nedir?

Python içe aktarma sistemi, kodun verimli bir şekilde yeniden kullanılmasına ve düzenlenmesine olanak tanır. Karmaşık projeleri sürdürmenizi kolaylaştırır.

Python'da bir modülü veya paketi içe aktarmak için import deyimini kullanabilirsiniz . Modüller, bir Python dosyaları koleksiyonuna sahip dizinler olan paketler olarak dağıtılır.

Üst dizinden bir modülü içe aktarmak için, ana dizini Python'un yoluna eklemek için sys.path modülünü kullanabilirsiniz . Üst dizini ekledikten sonra, import deyimini kullanarak modülü içe aktarabilirsiniz .

Üst Dizinden İçe Aktarmanın Gösterimi

Ana dizinden içe aktarmanın açık bir gösterimini yapmak için, tüm süreci anlamanıza yardımcı olacak bir dizi adımı gözden geçirelim.

1. Gerekli dizin ve dosyaların oluşturulması

İlk olarak, dosya gezgininizi açın ve istediğiniz yerel sürücüye gidin. Yerel E sürücümü kullanıyorum, bu nedenle my_project adında yeni bir dizin oluşturacağım .

my_project içinde , module_dir adlı başka bir dizin oluşturun .

Yani, şimdi sahip olmalısınız:

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

2. Python dosyaları ekleme

Ardından, my_project dizininde main.py adlı yeni bir .py dosyası oluşturun .

Bundan sonra, module_dir içinde my_module.py adlı başka bir Python dosyası oluşturun .

Yapınız şimdi şöyle görünmelidir:

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

Visual Studio Code kullanıyorsanız , dizin yapınız aşağıdaki gibi görünmelidir:

3. Python dosyalarını düzenleme

my_module.py dosyanızı açın ve aşağıdaki kodu ekleyin:

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

Ardından devam edin ve dosyayı kaydedip kapatın.

Şimdi main.py'yi açın ve aşağıdaki kodu ekleyin:

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

Bu betikte, ilk önce, çalıştırdığımız betikten bir üst düzeydeki dizinin konumunu buluyoruz (bu, ana dizindir). Ardından Python'a, modülleri içe aktarması gerektiğinde bu ana klasöre de bakmasını söylüyoruz.

Bunu yaptıktan sonra, bu üst dizinde yer alan module_dir adlı dizinin içine my_module adlı bir modülü import ediyoruz . Son olarak, my_module'den my_function adlı bir işlevi çağırıyoruz .

Yukarıdaki kodu ekledikten sonra dosyayı kaydedip kapatın.

4. Kodu Çalıştırma

Bu kodu çalıştırmak için istediğiniz kod düzenleyicinin terminalini açın ve main.py dosyasını çalıştırın. Visual Studio Code kullanıyorsanız, çıktı aşağıdaki gibi görünmelidir:

main.py , yukarıdaki resimde gösterildiği gibi my_module.py işlevinden içe aktaracaktır .

Bu örnek, dosya sisteminin ve üst dizinden içe aktarmanın Python'da nasıl çalıştığını ayrıntılı olarak gösterir.

Python'da ImportError ve ModuleNotFoundError Nasıl İşlenir?

Python , içe aktarma işlemi sırasında içe aktarmaya çalıştığınız modül bulunamadığında bir ImportError istisnası oluşturur .

ImportError , ModuleNotFoundError istisnasının bir alt sınıfıdır . İçe aktarılan modül olmadığında veya yüklenemediğinde ortaya çıkar.

Aşağıda, bunların meydana gelebileceği senaryo örnekleri verilmiştir:

• Modül veya paket sys.path içinde değil .

• Modül veya paket adı yanlış yazılmış veya mevcut değil.

• Modülün kodunda, düzgün şekilde içe aktarılmasını engelleyen bir sorun var.

Bu hatalarla karşılaştığınızda aşağıdaki çözümleri kullanabilirsiniz:

• Modül veya paketin yazımını ve varlığını iki kez kontrol etme.

• append() veya insert() kullanarak gerekli dizini sys.path'e ekleme .

• Modülün kodunda içe aktarılmasını engelleyebilecek sorunları düzeltme.

Python'da hata işleme hakkında daha fazla bilgi edinmek için aşağıdaki videoyu izleyin:

Python'da içe aktarmanın nasıl çalıştığını anladıktan sonra, Python'un dizin yapısına biraz aşina olmanız da önemlidir.

Dizin yapısı ve içe aktarma birbiriyle el ele gider çünkü içe aktarma, dizin yapısının anlaşılmasını gerektirir, bu yüzden bir sonraki bölümde bunun üzerinden geçelim.

Python Dizin Yapısı

Python dizin yapısını anlamak, betiklerinizi nereye koyacağınızı veya az önce kurduğunuz kitaplığı nerede bulacağınızı bilmekten daha fazlasıdır.

Temiz, iyi organize edilmiş bir masaya sahip olmak gibi: her şeyin tam olarak nerede olduğunu bileceksiniz ve üretkenliğiniz hızla artacak, bu yüzden bu bölümdeki temel konuların üzerinden geçelim.

Paket Yapısı

Bir Python projesinin dizin yapısı, doğru organizasyon için esastır. Paketinizi düzgün bir şekilde yapılandırırsanız, adlandırma çakışmalarını en aza indirmenize yardımcı olur. Ayrıca, dosya sisteminizde kolayca gezinmenizi de sağlar.

Aşağıda, tipik bir Python proje dizini yapısı gösterilmektedir:

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

Yukarıdaki örnekte proje , paket1 ve paket2 olmak üzere iki alt paket içeren kök dizindir . Her paketin kendi .py dosyaları ve benzersiz bir init.py dosyası vardır.

init.py Dosyaları Nedir?

init.py dosyaları, paketin içe aktarıldığı zamanki davranışını tanımlamak için önemlidir. Bu dosyalar, üst paketleri içe aktarıldığında yürütülür.

init.py dosyaları boş olabilir veya başlatma kodu içerebilir. Ayrıca Python'a, klasörün bir paket olarak ele alınması gerektiğini belirtirler.

Üst dizinden bir modülü içe aktarmak için sys.path yöntemini kullanabilirsiniz . Ana dizin yolunu sys.path dosyasına eklemeniz gerekir .

Bunu göstermek için önceki örneğimizi geliştirelim. Aşağıdaki dizin yapısına sahiptik:

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

Şimdi init.py dosyasını my_module dizinine ekleyelim . Bu dosyayı şimdilik boş bırakabilirsiniz. Varlığı, Python'a bu dizinin bir paket olarak ele alınması gerektiğini gösterir.

Dizin yapınız şimdi aşağıdaki gibi görünmelidir:

init.py dosyasını ekledikten sonra , module_dir klasörünü bir paket olarak ele alması talimatını vermek için main.py dosyanızda değişiklikler yapmalısınız . main.py dosyanız şimdi aşağıdaki kodu içermelidir:

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

Bu örnekte main.py , module_dir paketini içe aktarır ve ardından bu paket içindeki my_module'den my_function() işlevini çağırır.

my_function çağrısındaki değişikliğe dikkat edin ; şimdi module_dir'i bir paket olarak ele aldığımız için , paket içindeki modüllerden işlevleri çağırırken paket adını dahil etmeliyiz.

Çıktı öncekine benzer olacaktır. Yaptığımız tek değişiklik, module_dir'i init.py dosyasının dahil olduğu bir paket olarak ele almaktı .

Python Arama Yolu

Python'un içe aktarmaya çalıştığınız modülleri nerede bulacağını nasıl bildiğini hiç merak ettiniz mi? Ya da can sıkıcı bir 'ModuleNotFoundError' ile karşılaştınız ve nedenini bulamıyor musunuz?

Bu bölümde, bu gizemlerin üstesinden geleceğiz ve Python arama yolu kavramını derinlemesine inceleyeceğiz.

Sys.path olarak da bilinen Python arama yolu , ihtiyacınız olan tüm modülleri bulmak için Python'un küçük yol haritasıdır. Çalışkan bir izci gibi, Python da import deyimini her kullandığınızda bilgisayarınızda modüller bulmak için bu yolu kullanır.

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.

import ifadesinden önce , üst dizin yolunu sys.path dosyasına ekleyebilirsiniz . İlk olarak, sys modülünü içe aktarmanız gerekir . Ardından, ana dizin yolunu almak için os modülünü kullanırsınız .

Diyelim ki aşağıdaki gibi bir dizin yapınız var:

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

module_b.py içinde , ana dizin yolunu şu şekilde sys.path'e ekleyebilirsiniz :

import os
import sys

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

import module_a

Şimdi Python, onu module_b.py içine aktarırken ana dizinde module_a.py'yi arayacak .

Modülleri bir üst dizinden içe aktarmak için göreli içe aktarma yaklaşımını veya sys.path yaklaşımını kullanabilirsiniz .

Modüller ve Paketlerle Nasıl Çalışılır?

Python'da modüller ve paketler, kodu düzenlemenin ve yeniden kullanmanın bir yoludur. Karmaşık projeleri yönetilebilir parçalara bölmek için bunları kullanabilirsiniz.

Bu bölüm Python'da modüller ve paketlerle nasıl çalışılacağını tartışacaktır . Ayrıca aşağıdakiler gibi temel kavramları da dahil edeceğiz:

1. Ad alanları

2. Değişkenler ve Tanımlar

3. İfadeleri İçe Aktar

1. Ad Alanları Nedir?

Python'daki ad alanları, değişkenlerin, işlevlerin ve sınıfların adlarının farklı modüller arasında çakışmamasını sağlamanın bir yoludur.

Python'da farklı düzeylerde ad alanları vardır, örneğin:

• Global Ad Alanı: Tüm modülün ad alanını ifade eder.

• Yerel Ad Alanı: Bir işlev veya sınıf içindeki ad alanını ifade eder.

İsim alanı[isim] gösterimi ile belirli bir isim alanında bir isim elde edebilirsiniz .

2. Değişkenler ve Tanımlar Nelerdir?

Bir Python betiğinde değişkenleri, işlevleri ve sınıfları tanımlayabilirsiniz . Bu tanımlar betiğin ad alanında saklanır.

Komut dosyasını bir paket olarak içe aktararak, tanımlarına erişebilir ve projenizin diğer bölümlerinde yeniden kullanabilirsiniz.

Aşağıda, aynı ad alanında bir değişkenin ve bir işlevin nasıl tanımlanacağına bir örnek verilmiştir:

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

Bu modül, bir my_variable değişkenine ve my_function işlevine sahiptir .

Bu kodu çalıştırmak için, my_variable.py adlı yeni bir dosya oluşturabilir ve kodu aşağıda gösterildiği gibi buraya koyabilirsiniz:

Şimdi, bu dosyayı içe aktarabilir ve aşağıda gösterildiği gibi başka bir komut dosyasında kullanabilirsiniz:

main.py dosyasını çalıştırdıktan sonra aşağıdakine benzer bir çıktı alırsınız:

3. İthalat Beyanları Nedir?

Dosyaları, modülleri veya paketleri Python'da import ifadesi ile içe aktarabilirsiniz.

Bazı yaygın içe aktarma yöntemleri şunlardır:

• import module_name : Bu yöntem, bir modülü içe aktararak tüm tanımlarını module_name.definition_name notasyonuyla erişilebilir hale getirir .

import mymodule

result = mymodule.my_function(3)

• from module_name import some_definition : Bu yöntem, bir modülden belirli bir tanımı içe aktararak onu modül ön eki olmadan doğrudan kullanmanıza izin verir.

from mymodule import my_function

result = my_function(3)

• from module_name import * : Bu yöntem, bir modüldeki tüm tanımları içe aktarır, ancak adlandırma çakışmalarına yol açabileceği için önerilmez.

Son düşünceler

Python'da bir üst dizinden nasıl içe aktarılacağını anlamak, düzenli bir kod tabanını korumak açısından önemlidir.

Bu bilgi, projelerinizi daha modüler bir şekilde tasarlamanıza olanak tanır. Ayrıca kodunuzun yeniden kullanılabilirliğini artırır. Kodunuzu ayrı modüller ve paketler halinde yapılandırarak, tekrar eden kodlardan kaçınabilir ve bakımı ve güncellemeyi kolaylaştırabilirsiniz.

import ve from deyimlerini kullanma becerisi, işlevlerin farklı dizinlere bölündüğü daha büyük projeler üzerinde çalışırken çok değerlidir.

Modülleri içe aktarmak için Python'un yolunu nasıl doğru şekilde ayarlayacağınızı bilerek, bir dizinde çalışırken diğerinde çalışırken tanımlanmış işlevlere erişebilirsiniz.

Unutmayın, Python'da - veya herhangi bir programlama dilinde - uzmanlaşmanın anahtarı, tutarlı uygulama ve doyumsuz merakta yatmaktadır. Bu yüzden keşfetmeye, denemeye ve kendinize meydan okumaya devam edin.

Bu hızlı kılavuzla, Python'un size fırlattığı içe aktarma bulmacalarının üstesinden gelmek için iyi donanımlı olmalısınız. Ama burada durma. Keşfedilmeyi bekleyen koca bir Python teknikleri ve püf noktaları evreni var!