Python’un Benzersiz Özellikleri Nelerdir? — Bölüm 2

Python benzersiz özellikler serisinin 2. Bölümü.

Created with Bing AI

For English:

What are the quirks of the Python? - Part 2

Nesne yönelimli programlama (OOP) mimarisi günümüzde yaygın olarak kullanılan bir uygulama tasarım modelidir. Programları, özelliklerin ve yöntemlerin belirli nesnelere bağlanacağı şekilde yapılandırmanıza olanak tanır. OOP, gerçek dünyadaki varlıkları, ilişkili verilere ve belirli etkinlikleri gerçekleştirme yeteneğine sahip yazılım nesneleri olarak temsil eder. Python kapsamları (scopes) ve ad alanlarının (namespaces) yanı sıra küresel(global), yerel(local) ve yerleşik (builtin)türler de tartışılacaktır. İteratörler (iterators) ve oluşturucular (generators) dahil olmak üzere döngü nesneleri incelenecektir. Yineleme aracı modülü Python’da sıralı döngünün nasıl hızlandırılacağını göstermek için kullanılacaktır.

Ad Alanı ve Kapsam

Bir fonksiyon, bir değişkene, bir değerle aynı şekilde atanabilir.

person_name = “John”

def my_function():
 print(“hello function”)
hello_function = my_function

Ad alanı (Namespace)

Ad alanı, tüm program adlarının benzersiz olmasını ve çakışma olmadan kullanılmasını sağlamaya yönelik bir yöntemdir. Ad alanı, anahtarların adları temsil ettiği ve değerlerin gerçek öğeyi yansıttığı basit bir sözlük yapısıdır. Programdaki adlar ve nesneler arasındaki ilişkiyi yönetir; bu, tüm adların benzersiz olduğu, birbirinden bağımsız olarak var olabileceği ve belirli bir hiyerarşide düzenlendiği anlamına gelir.

Ad alanının arka planda nasıl depolandığına bir örnek:

namespace_example = {"name_first":object_1, "name_second":object_2}

Python aşağıdaki ad alanlarını kullanır:

1. Global ad alanları: Program içindeki içe aktarılan modül tanımlarını temel alır. Her modülün kendi ad alanı vardır. Program bitene kadar kullanılabilir.
2. Yerel (local) ad alanları: Bunlar bir fonksiyon içindeki yerel adları temel alır. Bir programdaki her fonksiyon çağrılır veya ad alanı oluşturulur. Fonksiyon geri dönene kadar kullanılabilir durumda kalır.
3. Dış (outermost) ad alanları: Yerleşik fonksiyonlara ve istisna adlarına göre oluşturulur. Ad alanı, yorumlayıcı başlatılana kadar oluşturulur ve siz çıkana kadar korunur.

Kapsam (Scope)

Kapsam, bir programın ön ek (prefix) olmadan adlandırılabilen bölümlerini ifade eder. Genel olarak Python’daki kapsam, belirli addan nesneye eşlemeler oluşturmak için ad alanlarını aradığımız hiyerarşik düzeyi belirtir. Python’daki değişken kapsam, bellekteki nesnelere yapılan referansları veya işaretçileri (pointers) ifade eder. = sembolüne sahip bir değişkeni bir örneğe atadığınızda, değişkeni bu örneğe bağlarsınız (veya eşlersiniz). Tek bir örneğe birden fazla değişken bağlanabilir. Genel olarak Python, tüm bu eşlemeleri izlemek için ad alanlarını kullanır. Değişken adlarını nesnelerle eşleyen kaplardır. Bunları isim-nesne eşleştirmelerini içeren sözlükler olarak düşünebilirsiniz. Bu, nesnelere atadığınız adları kullanarak erişmenizi sağlar.

Kapsamlar dört türe ayrılır: Yerel ayarlar, fonksiyonlar , modüller ve yerleşikler.

1. Yerel kapsam (en içteki kapsam — innermost), geçerli fonksiyondaki tüm yerel adları tanımlar.
2. En dıştaki (outermost) kapsam, uygulamadaki tüm yerleşik adların bir listesini tanımlar.
3. Modül kapsamı geçerli modül için genel adları tanımlar.
4. Çevreleyen (enclosing) fonksiyonların kapsamı, en yakın kapsamdan bir ad belirtir ve dışarıya doğru uzanır.

# Outermost scope - built-in names
import math

# Module scope - global names within the module
global_var = 10

def outer_function():
    outer_var = 20
    
    def inner_function():
        # Local scope - local names within the function
        local_var = 30
        print("Inner function local_var:", local_var)
        print("Inner function outer_var:", outer_var)  # Accessing outer function's variable
        
    inner_function()
    print("Outer function outer_var:", outer_var)
    # print("Outer function local_var:", local_var)  # This would cause an error because local_var is not defined in the outer function scope

print("Module scope global_var:", global_var)
outer_function()
print("Module scope global_var:", global_var)
print("Module scope math.sqrt:", math.sqrt(16))  # Accessing built-in name

Python’da Nonlocal ve Global Anahtar Kelimeleri

Python’da nonlocal ve global anahtar sözcükleri iç içe kapsama sahip değişkenleri bildirmek için kullanılır. İşte ne demek istedikleri:

1. nonlocal anahtar kelimesi:

• İç içe geçmiş fonksiyonlar boyunca kullanılır.
• En yakın kapsam kapsamındaki, genel olmayan bir değişkeni değiştirmenize olanak sağlar.
• İç içe geçmiş bir fonksiyon içinde yerel olmayanı kullandığınızda, bu, başvurulan veya atanan değişkenin dış (çevreleyen) kapsamda olduğu anlamına gelir.
• Bu, özellikle yerel veya genel kapsamda olmayan bir değişkeni değiştirmeniz gerektiğinde faydalıdır.

2. global anahtar kelimesi:

• Bir fonksiyon içindeki bir değişkenin genel kapsamda (geçerli fonksiyonun dışında) olduğunu belirtmek için kullanılır.
• Global kapsamda tanımlanan bir değişkeni bir fonksiyonun içinden düzenleyebilirsiniz.
• Bir fonksiyon içinde global kullandığınızda, bu, aynı adda yeni bir yerel değişken oluşturmak yerine, başvurulan veya atanan değişkenin genel kapsamda olduğu anlamına gelir.
• Bu anahtar kelime, bir fonksiyon içinden global bir değişkeni değiştirmek istediğinizde kullanışlıdır, ancak genel olarak, mümkünse global değişkenlerden kaçınmak en iyi uygulama olarak kabul edilir, çünkü bunlar öngörülemeyen yan etkilere neden olabilir ve kodun akıl yürütmesini zorlaştırabilir.

Yerel olmayan ve genel anahtar kelimeleri kullanmanın basit bir örneğini burada bulabilirsiniz:

# Global variable
global_var = 10

def outer_function():
    # Enclosing function variable
    outer_var = 20
    
    def inner_function():
        nonlocal outer_var
        global global_var
        
        outer_var = 30  # Modifying the variable from the outer function's scope
        global_var = 40  # Modifying the global variable
        print("Inner function modified outer_var:", outer_var)
        print("Inner function modified global_var:", global_var)
    
    inner_function()
    print("Outer function outer_var after inner_function:", outer_var)

# Before calling outer_function
print("Global variable before outer_function:", global_var)

outer_function()

# After calling outer_function
print("Global variable after outer_function:", global_var)

Sınıflar ve Miras (Classes and Inheritence)

Nesne yönelimli programlama (OOP), özellikleri ve yöntemleri ayrı ayrı tanımlanmış nesneler halinde gruplayarak programları yapılandırmanıza olanak tanıyan bir programlama tasarım modelidir. OOP tamamen programların kodu yeniden kullanma kapasitesini geliştirirken aynı zamanda kodun oluşturulmasını ve anlaşılmasını kolaylaştırmakla ilgilidir. OOP’nin kapsüllenmesi, geliştiricilerin kodu bir kara kutu gibi ele almasına olanak tanır. Kalıtım gibi OOP öğelerinin kullanılması, program geliştirme ve test süresini önemli ölçüde azaltırken mevcut kodun fonksiyonelliğin genişletmeyi kolaylaştırır.

Python nesne yönelimli bir programlama dilidir, yani veri ve fonksiyonelliği birleştiren nesneler etrafında tasarlanmıştır. Python her şeyi özellikler (nitelikler) ve yöntemlerle tamamlanmış bir nesne olarak ele alır. OOP’un en temel fikirlerinden biri sınıflar ve nesneler arasındaki ayrımdır.

Sınıf, verileri ve fonksiyonları birbirine bağlamak için kullanılan bir yapı bileşenidir. Bir sınıf, yeni oluşturulan bir nesnenin “planı” görevi görür. Bir nesne bir sınıfın örneğidir. Nesnelerin üye değişkenleri vardır ve davranışlar bunlara bağlıdır. Yeni bir sınıf oluşturduğunuzda, yeni örnekler oluşturmak için kullanılabilecek yeni bir nesne türü yaratırsınız. Sınıflar, verileri ve fonksiyonları gruplandırmanıza olanak tanır.

class Person:
    """
    This class represents a person with a name and age.
    """

    def __init__(self, name, age):
        """
        Constructor for Person class.

        Parameters:
        name (str): The name of the person.
        age (int): The age of the person.
        """
        self.name = name
        self.age = age

    def greet(self):
        """
        Method to greet the person.
        """
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")


# Creating an instance of the Person class
person1 = Person("Alice", 30)

# Accessing instance variables
print("Name:", person1.name)
print("Age:", person1.age)

# Calling the greet method
person1.greet()

Görüldüğü gibi “self” anahtar sözcüğü her sınıf yönteminin başlangıç parametresini tanımlar. Her zaman kullanılan sınıfın geçerli örneğini ifade eder. Bizim durumumuzda “self” seçeneği, print_book_title() yönteminin nesne özelliklerine referans verecek bir araca sahip olmasını sağlar.

Yapıcı Yöntemi

Nesne yönelimli programlamada yapıcı, belirli bir nesne türünü başlatan bir sınıf veya yapının özel bir yöntemidir. Yapıcı, genellikle sınıfla aynı adı taşıyan ve bir nesnenin üyelerinin değerlerini varsayılan veya kullanıcı tanımlı değerlere ayarlamak için kullanılabilen bir örnek yöntemdir. Bir sınıf nesnesi başlatıldığında, onun yapıcı yöntemi çağrılır.

Python, yapıcı yöntemini “__init__” yedek adıyla tanımlar.

Sınıf Mirası (Class Inheritence)

Bilgisayar programlamada kalıtım, nesne yönelimli programlamanın (OOP) değerli bir yönüdür. Kalıtım, bilgisayar programcılarının başka bir sınıfın tüm yöntem ve özelliklerini miras alan sınıflar oluşturmasını sağlar. Mirasın uygulanması iki unsurdan oluşur.

1. Ana (parent) sınıf — Bu, miras alınan sınıftır; aynı zamanda temel veya üst sınıf sınıfı olarak da bilinir.
2. Alt (child) sınıf — Bu, genellikle alt sınıf veya türetilmiş sınıf olarak bilinen, başka bir sınıftan miras alan sınıftır.

Kalıtımın temel faydalarından biri, genel kodu temel sınıfta depolayarak ve çeşitli türetilmiş sınıfların ona erişmesine izin vererek yinelenen kod miktarını azaltmasıdır. Bu, geliştirilmiş kod yapısı ve gelecekteki iyileştirmeler açısından önemli bir avantajdır. İşte bazı genel sınıf kalıtım uygulama kodları.

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass  # Abstract method


class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"


class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"


class Cow(Animal):
    def speak(self):
        return f"{self.name} says Moo!"


# Creating instances of derived classes
dog = Dog("Buddy")
cat = Cat("Whiskers")
cow = Cow("Bessie")

# Polymorphism: calling speak() method on different objects
print(dog.speak())  # Output: Buddy says Woof!
print(cat.speak())  # Output: Whiskers says Meow!
print(cow.speak())  # Output: Bessie says Moo!

Gördüğünüz gibi Python’da herhangi bir yeni sınıf (BaseClassName), “object” genel sınıfından türetilir.

super() fonksiyonu, bu sınıfların tüm yöntemleri ve nitelikleri PersonClass temel sınıfından devralmasına olanak tanır. Bu fonksiyon, temsilci seçme yoluyla yöntemleri çağırabilen ve temel sınıf özelliklerini kullanabilen bir proxy nesnesi döndürür.

Yöntemi Geçersiz Kılma (Method Overriding)

Bir sınıf ayrıca herhangi bir temel sınıf yönteminde tamamen yeni bir uygulamayı tanımlayabilir. Yöntem geçersiz kılma, nesne yönelimli programlamada kullanılan bir kelimedir. Geçersiz kılma, bir sınıfın, temel sınıflarından biri tarafından verilen bir yöntemin uygulamasını değiştirme yeteneğidir. Geçersiz kılma, mirasın tüm potansiyelini kullanmasına izin verdiği için OOP’nin önemli bir yönüdür. Yöntem geçersiz kılma, bir sınıfın başka bir sınıfı klonlamasına olanak tanıyarak kodun bir kısmını yükseltirken veya değiştirirken kodun kopyalanmasını önler.

Yineleyiciler ve Oluşturucular (Iterators and Generators)

Yinelenebilir nesneler, bir döngü ifadesinde kullanılabilen herhangi bir Python nesnesidir. Python, listeler, tuple’lar, dizeler, sözlükler ve dosyalar dahil olmak üzere çeşitli yerleşik yineleyici nesneler içerir. Yineleyiciler temiz, iyi organize edilmiş kod üretirler.

Python’un “iter()” adında yerleşik bir yöntemi vardır. Bu fonksiyon yinelenebilir bir nesneyi kabul eder ve bir yineleyici döndürür. “Yinelenebilir nesnenin bir sonraki” yöntemi, öğeyi alır. Daha fazla öğe yoksa “StopIteration” istisnası (exception) ortaya çıkar.

# Define an iterable object (list)
my_list = [1, 2, 3, 4, 5]

# Get an iterator from the iterable using iter()
my_iterator = iter(my_list)

# Iterate over the elements using the iterator
while True:
    try:
        # Get the next element from the iterator using next()
        element = next(my_iterator)
        print(element)
    except StopIteration:
        # Stop iteration when all elements have been exhausted
        break

Yineleyiciler (Iterators)

Yineleyiciler, yineleyici protokol açıklamasını izleyen sınıflar olarak uygulanır. Yineleyici protokolü, __iter__() ve __next__() yöntemlerini uygulayan özel bir sınıftır.

• __iter__ yineleyici nesnenin kendisini döndürür.
• __next__ sonraki yineleme değerini döndürür.

class MyIterator:
    def __init__(self, max_num):
        self.max_num = max_num
        self.current_num = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current_num < self.max_num:
            self.current_num += 1
            return self.current_num
        else:
            raise StopIteration

# Creating an iterator object
my_iterator = MyIterator(5)

# Iterating over the iterator
for num in my_iterator:
    print(num)

Generators (Oluşturucular)

Oluşturucu , yineleyicileri kolayca oluşturmanıza olanak tanıyan bir nesnedir. Bir oluşturucu oluşturmak için __iter__() ve __next__() yöntemlerine sahip ısmarlama bir sınıfa gerek yoktur. Hiçbir şey döndürmeyen ve “yield” anahtar sözcüğünü kullanan basit bir fonksiyonla bir oluşturucu oluşturulabilir.

def my_generator(max_num):
    current_num = 0
    while current_num < max_num:
        yield current_num
        current_num += 1

# Creating a generator object
gen = my_generator(5)

# Iterating over the generator
for num in gen:
    print(num)

Döngü başladığında ve verim ifadesine ulaştığında, yerel değişken low’un değeri döndürülür ve oluşturucu sonlandırılır. Oluşturucu bir sonraki çağrıyı aldığında önceki değerden yeniden başlar ve değeri bir arttırır. Genel olarak, verim ifadesi, yerel değişkenin değerini düşük tutarken return ifadesini simüle eden fonksiyonun sonucunu döndürür.

Itertools Modülü

Python, hızlı döngü için verimli yineleyici rutinleri içeren bir “itertools” modülü içerir.

Sayı başlangıcıyla başlayan eşit aralıklı değerleri döndüren bir yineleyici oluşturmak için “count(start=0, step=1)” seçeneğini kullanın.

from itertools import count

# Creating a count generator starting from 3 with step 2
counter = count(start=3, step=2)

# Iterating over the count generator
for i in range(5):
    print(next(counter))

Öğeleri döndüren ve her birinin bir kopyasını kaydeden bir yineleyici oluşturmak için “cycle(iterable)” seçeneğini kullanın.

from itertools import cycle

# Define an iterable
my_list = [1, 2, 3]

# Create a cycle iterator from the iterable
cycler = cycle(my_list)

# Print the first 10 elements of the cycle
for _ in range(10):
    print(next(cycler))

“repeat(object[, times])”, öğeyi tekrar tekrar döndüren bir yineleyici oluşturur. Times parametresi sağlanmadığı sürece süresiz olarak çalışacaktır.

from itertools import repeat

# Create a repeat iterator with a specified object and number of times
repeater = repeat("Hello", times=3)

# Print the repeated object
for item in repeater:
    print(item)