Programlama terimlerinde, "bilgi aktarımı" (information passing), bir programın farklı bölümleri arasında bilgi aktarılmasını ifade eder. Bu, genellikle fonksiyonlara argüman olarak verilerin geçirilmesi ve/veya fonksiyonların geri dönüş değerlerini almak şeklinde gerçekleşir. Bilgi aktarımı, bir programın farklı bölümlerinin birbirleriyle iletişim kurabilmesi ve işbirliği yapabilmesi için kritiktir.

Python'da, bilgi aktarımı genellikle fonksiyonlara ve metodlara argümanlar gönderilerek ve bu fonksiyonların ve metodların geri dönüş değerlerini alarak gerçekleştirilir.

Örneğin, bir fonksiyonun bir dizi alıp dizi elemanlarının ortalamasını hesapladığını düşünelim:

def average(numbers):
    return sum(numbers) / len(numbers)

Bu average fonksiyonu, bir dizi alır (numbers) ve bu dizinin ortalamasını hesaplar ve döndürür. Bu durumda, "numbers" dizisi fonksiyona argüman olarak geçilir ve bu fonksiyonun döndürdüğü değer alınabilir:

Bu örnekte, nums dizisi average fonksiyonuna geçilmiş (bilgi aktarımı) ve average fonksiyonunun geri dönüş değeri avg değişkeninde saklanmıştır (yine bilgi aktarımı).

Bir diğer önemli bilgi aktarımı konusu da, değişkenlerin değerlerinin fonksiyonlarda nasıl değiştirildiği ve bu değişikliklerin fonksiyon dışında ne ölçüde görünür olduğudur. Python'da basit veri türleri (int, float, bool, str) değerlerine göre aktarılır (pass-by-value), yani fonksiyonda yapılan değişiklikler fonksiyon dışında görünmez. Ancak listeler, sözlükler gibi bileşik veri türleri referanslarına göre aktarılır (pass-by-reference), yani bu tür bir veri türü üzerinde yapılan değişiklikler, fonksiyon çağrısının dışında da görünür hale gelebilir. 

Değerine Göre Aktarım (Pass by Value): Bu durumda, değişkenin değeri fonksiyona kopyalanır. Bu, Python'daki basit veri türleri için geçerlidir (örneğin, int, float, bool ve str). Bu tür veri türleri için, fonksiyon içinde yapılan herhangi bir değişiklik, fonksiyon çağrısının dışında görünmez. İşte bir örnek:

def update_number(n):
    n += 10
    print(f"Number inside function: {n}")

num = 5
update_number(num)
print(f"Number outside function: {num}")

Bu kodu çalıştırdığınızda, çıktı şu şekilde olacaktır:

Number inside function: 15
Number outside function: 5

Gördüğünüz gibi, fonksiyon içinde n'in değerini değiştirdik, ancak bu değişiklik num'un değerini etkilemedi.

Referansına Göre Aktarım (Pass by Reference): Bu durumda, değişkenin referansı (yani, değişkenin bellekteki konumu) fonksiyona geçirilir. Python'daki listeler, sözlükler, kümeler ve diğer mutable (değiştirilebilir) veri türleri için bu geçerlidir. Bu tür bir veri türü üzerinde yapılan değişiklikler, fonksiyon çağrısının dışında da görünür hale gelebilir. İşte bir örnek:

def update_list(lst):
    lst.append("new item")
    print(f"List inside function: {lst}")

my_list = ["item1", "item2"]
update_list(my_list)
print(f"List outside function: {my_list}")

Bu kodu çalıştırdığınızda, çıktı şu şekilde olacaktır:

List inside function: ['item1', 'item2', 'new item']
List outside function: ['item1', 'item2', 'new item']

Gördüğünüz gibi, fonksiyon içinde lst'ye bir öğe ekledik ve bu değişiklik my_list'in dışında da görünür hale geldi.

Bunlar, Python'da bilgi aktarımının ana mekanizmalarıdır. Ancak bu, Python'ın veri türlerinin ve bellek yönetiminin daha geniş bir konusudur. Bu kavramlar, özellikle büyük ve karmaşık programları anlamak ve debug etmek için önemlidir.

Python'da, veri türlerini ikiye ayırabiliriz: mutable ve immutable.

Immutable (değiştirilemez) veri türleri, bir kez oluşturulduktan sonra değiştirilemezler. Bu türler arasında int, float, bool, str ve tuple bulunur.

Mutable (değiştirilebilir) veri türleri ise değiştirilebilirler, yani bir kez oluşturulduktan sonra bile içerikleri değiştirilebilir. Bu türler arasında list, set, dict ve çoğu kullanıcı tanımlı sınıflar bulunur.

"Mutable parametreler" (Mutable parameters), fonksiyonlara argüman olarak geçirilebilen ve fonksiyon içinde değiştirilebilen parametreleri ifade eder. Bu parametreler genellikle mutable veri türlerinden oluşur. Örneğin, bir listeyi bir fonksiyona argüman olarak geçirebilir ve bu fonksiyon içinde listenin elemanlarını değiştirebiliriz.

Bir örnek ile daha net bir şekilde anlatabiliriz:

def add_item(my_list, item):
    my_list.append(item)  # Listenin kendisi değiştiriliyor

fruits = ['apple', 'banana']
add_item(fruits, 'cherry')

print(fruits)  # ['apple', 'banana', 'cherry']

Bu örnekte, add_item fonksiyonu, my_list adlı bir liste ve item adlı bir öğe alır ve öğeyi listeye ekler. Çünkü listeler mutable bir veri tipidir, fonksiyonun dışındaki fruits listesi de değişir.

Ancak, mutable parametrelerin dikkatli kullanılması gerekiyor. Fonksiyonun, dışarıdan aldığı bir veriyi değiştirme yeteneği, bazen beklenmeyen sonuçlara yol açabilir. Bu nedenle, bir fonksiyonun bir parametreyi değiştirip değiştirmeyeceğini belirtmek genellikle iyi bir uygulamadır.

Varsayılan Değerler:

Python'da, fonksiyonlarınızın parametreleri için varsayılan değerler belirleyebilirsiniz. Bu, parametreye bir değer sağlanmadığında kullanılacak olan değeri belirtir.

Varsayılan parametre değerleri, fonksiyon tanımlaması sırasında belirlenir ve = operatörü kullanılarak parametrenin yanında belirtilir. İşte bir örnek:

def greet(name="Stranger"):
    print(f"Hello, {name}!")

greet("Alice")  # "Hello, Alice!" çıktısını verir
greet()  # "Hello, Stranger!" çıktısını verir

Bu örnekte, greet fonksiyonu bir name parametresi alır ve bu parametrenin varsayılan değeri "Stranger"'dir. Bu, greet() çağrısı sırasında bir name değeri sağlanmadığında kullanılır.

Varsayılan parametre değerleri, bir fonksiyonu daha esnek hale getirir ve kullanıcıların her zaman tüm parametreleri belirtmek zorunda kalmamasını sağlar. Ancak, mutable varsayılan değerlerle dikkatli olmanız gerekir, çünkü bu değerler fonksiyon çağrıları arasında durumlarını korurlar. Bu genellikle beklenmeyen davranışlara yol açabilir ve bu yüzden genellikle kaçınılması önerilir. Örneğin, bir liste veya sözlük gibi mutable bir değeri varsayılan parametre olarak kullanmak genellikle iyi bir fikir değildir.

Anahtar Kelime Parametreleri:

Python'da, fonksiyonları çağırırken parametrelerin isimlerini belirterek değer atayabiliriz. Bu tür parametrelere "anahtar kelime parametreleri" veya "keyword parameters" denir.

Keyword parametrelerin kullanımı, kodun okunabilirliğini artırır çünkü her parametrenin ne için kullanıldığını açıkça belirtir. Ayrıca, parametrelerin sırasının önemli olmadığı anlamına gelir, çünkü her parametre ismi ile birlikte belirtilir.

Örneğin, aşağıdaki fonksiyonu düşünelim:

def display_info(name, age):
    print(f"Name: {name}")
    print(f"Age: {age}")

Bu fonksiyonu keyword parametreler kullanarak iki şekilde çağırabiliriz:

display_info(name="Alice", age=25)
display_info(age=25, name="Alice")

Her iki çağrı da aynı çıktıyı üretir:

Name: Alice
Age: 25

Keyword parametreler, özellikle bir fonksiyonun birçok parametresi olduğunda veya parametrelerin ne anlama geldiğinin kodda açıkça belirtilmesini istediğimizde kullanışlıdır. Ayrıca, bir fonksiyonun varsayılan parametre değerlerini belirlemesine izin verir ve bu da fonksiyonun kullanımını daha esnek hale getirir.