Python Programlama Dili

Bölüm 1

Başlangıç Bilgileri

1.11 - İşlemciler (Operators) ve İfadeler (Expressions)

1.11.1 - Atomlar

Python programlama dilinde atomlar ya bir tanıtıcı, ya bir literal, ya da bir kompozit veri tipi içinde, (Listeler, topluluklar, sözlükler, kümeler gibi) tanımlanmış verilerdir. İlk olarak literaller ve tanıtıcılar üzerinde duracağız. Bu iki öğeyi de tanıyoruz. İfadeler bundan biraz fazlasıdır. Bir ifadede birden fazla atom bulunur ve ifade sonucu belirli kurallara göre oluşur.

1.11.2 - Tek İşlenenli işlemciler

1.11.2.1 - Tekli Artı (Unary Plus) işlemcisi +

Tekli Artı işlemcisi tek işlenen gerektiren (tek işlenenli) (single operand) bir işlemcidir. İşlenen işlemciyi izler. Yani, ifadede sadece tekli artı işlemcisi ve sağ işlenen bulunur.Örnek olarak,

+5.6

ifadesinin hiçbir anlamı yoktur. Çünkü, sayısal literaller varsayılan olarak, artı değerindedir. Ek olarak önlerine bir artı daha konmasının bir anlamı yoktur. Sonuçta, tekli artı işlemcisinin bir işlevi olmadığından, kullanma alanı da yoktur.

1.11.2.2 - Tekli Eksi (Unary Minus) işlemcisi -

Bu işlemcinin bir anlamı vardır. Eğer işlenen pozitif bir büyüklük ise değerini negatife çevirir. Örnek olarak,

-5.6

ifadesinin sonucu -5.6 dir. Buraya 5.6 değerindeki ondalıklı sayısal literal (atom) artı olarak girmiş ve ifadede ekli eksi işlemcisi ile işlem yaparak, ifade sonucu -5.6 olmuştur.

1.11.3 - Çift İşlenenli İşlemciler

1.11.3.1 - Toplama İşlemcisi +

Sayısal veriler için toplama işlemi aynen aritmetik toplama gibidir. İşlem sonucu, tamsayı işlenenler için tamsayı, işlenenlerden birisi ondalıklı sayı ise, ondalıklı sayı, her iki işlenen ondalıklı sayı ise, sonuç da ondalıklı sayı olacaktır.

Toplama işemcisi, sayısal veriler dışındaki işlenenler ile uygulandığında, birleştirme (concatenation) işlemini gerçekleştirir. Örnek olarak,

"David" + "Meşulam"

işlemi, "David Meşulam" sonucunu verecektir.

Toplama işlemcisi işlenenler liste, topluluk (tuple), sözlük (dict) (dictionary nin kısaltılmışı), set tipleri için de birleştirme işlemini gerçekleştirir.

1.11.3.2 - Çıkartma İşlemcisi -

Çıkartma işlemcisi sadece sayısal işlenenlerin aritmetik çıkartma işlemlerini yapar. Çıkartma işlemi, özellikle büyük sayılar birbirinden çıkartıldığında, anlamlı ondalık sayısının düşmesinde önemli bir rol oynar.

1.11.3.3 - Çarpma İşlemcisi *

Çarpma işlemcisi sayısal işlenenlerin çarpma işlemlerini yapar. Tamsayı işlenenler ile çarpma sonucu tamsayıdır. İşlenenlerin biri veya her ikisi de ondalıklı sayı ise, çarpma işlemi sonucu ondalıklı sayıdır.

1.11.3.3 - Tamsayı Bölme İşlemcisi //

Tamsayı bölme işlemcisi, işlenenler tamsayı iseler, tamsayı tipinde sonuç verir. Eğer işlenenlerden birisi veya her ikisi ondalıklı sayı ise, sonucun ondalık kısmını keser ve tamsayı kısmını döndürür. Örnek olarak 3 // 2 işleminin sonucu 1 olarak geri döner.

1.11.3.4 - Bölme İşlemcisi /

Bölme işlemcisi daima ondalıklı sayı tipinde sonuç döndürür. Bölme işleminin, sonucun ondalık duyarlığınının (anlamlı ondalık sayısının) düşmesinde önemli bir katkısı vardır.

1.11.3.5 - Modulo İşlemcisi %

Modulo işlemcisi bir bölmenin kalan kısmını döndürür. Örnek olarak 3 % 2 işleminin sonucu 1 olarak geri döner. Aşağıdaki eşitlik karakteristiktir.

x = (x//y)*y + (x%y)
    

1.11.3.6 - Üs alma İşlemcisi **

Üs alma işlemcisi aslında iki işlemciden oluşan bir ifadedir. 5**4 ifadesinde tekli artı görünmez. Fakat, 3.5**-2 ifadesinde ise ilk olarak tekli eksi işlemcisi sağ işleneni olan 2 ile işleme girer ve sonucu olan -2 değeri üs alma işlemcisinin sağ işleneni olarak işlev yapar. Sonuç, 1/3.5**2 = 1/((7/2)*(7/2)) = 1/(49/4) = 4/49 = 0.08163265306122448 dir.

Düşük düzey işlemcilerini bu çalışmada gerek olmadığından (genellikle gerek olmaz), bu çalışmada incelemeyeceğiz. Karşılaştırma işlemcisini de karşılaştırma işlemlerini incelerken inceleyeceğiz.

1.12 - İfadeler (Expressions)

İfadeler, birden çok işlemci ve veri içeren topluluklardır. Daha çok matematik ve mantıksal bağıntıların bilgisayar sisteminde değerlendirilmesi için yapılan düzenlemelere ifade adı verilir.

He kadar işlemci ve işlenen içerirse içersin, tüm ifadeler bir tek sonuca ulaşırlar. Bu sonucun oluşturulması için tüm bilgisayar dillerinin uyguladığı kesin kurallar, hemen hemen tüm bilgisayar dillerinde birbirinin aynıdır.

İfadelerde önce öncelik sırası daha yüksek işlemciler değerlendirilir. Eğer işlemcilerin öncelik sırası aynı işe, soldaki daha önce uygulanır. Yani öncelik sıraları soldan sağadır. Bunun tek istisnası, üs alma işlemsidir ve öncelik sırası daha önce gördüğümüz gibi, sağdan soladır.

Bir ifadede parantez kullanımı, ifadenin anlamına açıklık getirir fakat işlem hızını düşürür. Programın ilk sürümünde çok belirgin öncelik sıraları dışında, parantez kullanılması önerilir. Programın çalışmasından sonra, ifadenin doğru değerlendirilmesi sınanarak öncelik sıralarına güvenilen sürümlerini yazarak güncellemek olanağı her zaman bulunabilir. C.A.R Hoare, "Başlangıçta en iyileştirme (optimizasyon) düşünmek sorunu kendi kendine davet etmektir ve bundan kesinlikle kaçınılmalıdır" demiştir.

Python derleyicisi, aşağıdaki ifadelerden numarası en küçük olanları numarası daha büyük olanlardan önce uygulayacaktır:

ifade1 , ifade2 , ifade3 , ifade4
(ifade1 , ifade2 , ifade3 , ifade4)
{ifade1 , ifade2 , ifade3 , ifade4}
ifade1 + ifade2 * (ifade3 - ifade4)
ifade3 , ifade3 = ifade1 , ifade2
    

Burada, özellikle üçüncü sıraya dikkat edelim. Bu bir toplama işlemi ve sol işleneni ifade1. Sağ işleneni ise, önce parantez içi işlem yapılarak bir sonuç belirleniyor ve bu sonuç ile ifade3 çarpılarak çıkan sonuç sağ işlenen olarak sol işlenen ifade1 ile toplanıyor. Yani, parantez içi daima öncelikle değerlendiriliyor. Parantez içinde, tüm işlemcilerin öncelik sırası, parantez dışı ile aynıdır.

Son satırda bir atama işlemi bulunuyor. Atama işleminde atama işlemcisinin öncelik sırası en düşük olanıdır. Yani, önce atama işlemcisinin sağında bulunan tüm ifadeler değerlendirilir, bir sonuç oluşur ve bu sonuç, atama işlemcisinin sağ işleneninde bulunan tanıtıcıya atanır. Bu işlem, sağ işlenenin değerinin bellekte bir alana yerleştirilmesi ve bu bellek alanına erişimi sağlayacak refrans değerinin atama işlemcisinin sol tafarındaki tanıtıcıya bağlanmasıdır. Bundan sonra tanıtıcının her çağrılmasında, tanıcının bellek referansının işaret ettiği bellek alanında bulunan değer geri döndürülecektir. Atama işleminin modern adı "Bağlanma (Binding)" dir.

Aşağıdaki tablo, Python derleyicisinin değerlendirdiği işlemci önceliğini açıklamaktadır. Tablo en düşük öncelikten (en düşük bağlanma) en yüksek öncelik sırasına (en yüksek bağlanma) ya doğru düzenlenmiştir. Aynı kutudaki işlemcilerin öncelik sıraları aynıdır. Sözdiziminde (sentaks) açıkça belirtilmedikçe, işlemciler çift işlenenlidir. Aynı sıradaki işlemcilerin öncelik sıraları soldan sağa doğrudur. Bunun tek istisnası, üs alma işlemcisidir ve bunun öncelik sırası tam aksi yönde yani sağdan sola doğrudur.

Notlar:

• 1 - Hernekadar abs(x%y) > abs(y) olduğu matematikçe gerçek olsa bile, yuvarlatmalardan dolayı, ondalık sayılar için böyle çıkmayabilir. Python float veri tipinin IEEE 754 standardına uygun bir çift duyarlıklı ondalıklı sayı olduğu varsayılırsa, -1e100 % 1e100 sonucu, 1e100 ile aynı işarete sahiptir. Hesaplanan değer, 1e100 dür. Fakat, math.fmod() çağrısı -1e100 değerini geri döndürür. Hangisinin daha yararlı olduğu, yürütülen çalışmaya bağlıdır.
• 2 - Eğer x y nin çok yakın bir tamsayı katı ise, yuvarlatmalardan dolayı, x//y, (x-x%y)//y den bir birim yüksek çıkabilir. Python divmod(x,y)[0]*y + x % y nin x 'e en yakın olması düşüncesi ile sonuncu ifadenin değerini döndürür.
• 3 - Unicode karakterlerinin desteklenmesi sonucunda, sözel verilerin karşılaştırılmasında beklenmedik sonuçlar alınabilir. Bunun önlenmesi için, sözel veri karşılaştırmalarının unicode.normalize() fonksiyonun kullanılması ile yapılması sağlık verilir.
• 4 - Bazı durumlarda in işlemcisi gereksiz davranış gösterebilir.
• 5 - % işlemcisi, aynı zamanda sözel verilerin biçimlendirilmesi, (formatlanması) için kullanılmaktadır.
• 6 - Üs alma işlemcisi, sağındaki ifadeden daha gevşek bağlanır. Yani, 2**-1 in değeri 0.5 dir.

Dördüncüye kadar uyarılarda sözü edilen durumlara çok az rastlanabileceğini belirtelim.

1.13 - Python Komut Satırı İle Çalışmak

Tantıcılara değer bağlanması (atama) yöntemlerini inceledikten sonra artık tanıtıcılara değer bağlanması ve bu değerlerin geri çağrılmasını, Python komut satırı (chevron) kullanımı ile deneyebiliriz.

Python komut satırı, yana doğru yazılmış askeri rütbe işaretlerine benzer. Görünümü >>> şeklindedir. Chevron en eski olarak, Girit'teki eski Miken keramik kalıntılarında bulunmuştur. Buna chevron (küçük keçi = çepiç) adı verilmiştir ve tarih boyunca süsleme figürü ve daha sonraları askeri rütbe işareti olarak kullanılmıştır. Chevron, Python programlama dilinin komut satırı başlangıcı olarak kullanılmaktadır. Python programlama dilinin, bir diğer üstünlüğü de, program yapılmasına gerek olmadan, komut satırı üzerinden her türlü işlemin yapılabilmesidir. Python komut satırı üzerinden çalışmanın, bir program öncesi deneme çalışması olarak çok yararlı olduğu belirtilebilir.

Python komut satırı, Eğer python.exe sistem veriyolu (path) üzerinde ise, herhangibir klasörden, değilse, kendi klasöründe bir DOS komut penceresi açılarak (c:\windows\cmd.exe) komut satırına python.exe girilip, enter tuşuna basılarak açılabilir. Çoğu IDE de bir Python komut satırı penceresi sağlamaktadır.

Bir fonksiyon tanımı ve çağrılması:

>>>def kare(a , b) : 
...  return a * b 


>>>kare(4 , 3) 
Out[7]: 12

Görüldüğü gibi, Python komut satırı, her türlü program öğesinin uygulanmasına olanak sağlayabilmektedir. Konular ilerleyip tam programlar yazımını açıklayana kadar Python komut satırında uygulamalar yapacağız.

1.14 - Atama (Bağlanma) (Binding) İşlemi

Atama işlemi, atama işlemcisi (=) kullanılarak yapılır. Atama işlemcisi, önceliği en düşük olan iki işlenenli bir işlemcidir. Atama işlemcisinin sol işleneni mutlaka tek bir geçerli tanıtıcı (identifier) olmak zorundadır. Sağ işlenen bir ifade olabilir. Ne kadar karışık olursa olsun, her ifade, mutlaka bir sonuca ulaşır ve ulaşılan sonuç, sol işlenene atanır.

Her programlama dilinde, sonradan değiştirilebilen (mutable) veriler ile sonradan değiştirilemeyen (immutable) verilerin atama mekanizmaları farklı olmak zorundadır. Değişebilen veriler, canlı nesnelerdir. Her an bazı elemanlarının eklenmesi veya çıkarılması veya yeniden tanımlanması ile güncellenebilirler. Değişebilen verilerin bazı kısımları güncellenebilirken, diğer kısımları değişmeden kalabilir. Değişmeyen veriler ise belirli ve bütün değerlerdir. Değişmeyen verilerin bazı parçaları değiştirilemez, verinin tamamının değişmesi gerekir.

Python programlama dilinde, değiştirilemeyen (immutable) veriler, sayılar, sözel veriler (strings), topluluklar (tuples), donmuş kümeler (frozensets) veri tipleridir.

Değiştirilemeyen veriler tamamlanmış verilerdir. Bir kez atandıktan sonra değiştirilemezler. Zamanla ilgileri yoktur. Bir kez tanımlanırlar ve sonsuza kadar değerlerlerini korurlar. Değişemeyen veriler bir tanıtıcıya değerle bağlanırlar. Yerleştirildikleri bellek alanının operatif değeri yoktur. Tanıtıcıya değeri bağlanır ve uçucu (volatil) olarak tanımlanan bir bellek alanına yerleştirilirler. Bu bellek alanın kalıcı olması gerekli değildir, çünkü tanıtıcıya değer olarak bağlanmışlardır. Tanıtıcılar çağrılınca değeri geri döndürürler. Bu değer tanıtıcının saklandığı geçici bir bellek alanındadır ve program akışına göre sık sık yeri değişebilir. Bu sorun olmaz, çünkü değiştirilemeyen veriler prensip olarak, az sayıda bit ile temsil edilebilen, sayılar gibi küçük boyutta verilerdir. Topluluk, donmuş küme ve sözel verilerin büyük olma potansiyelleri vardır, fakat bunlar da normal bir programda akla yakın büyüklüklerde olurlar.

Atama işleminin değişemez tipte verilerle nasıl yürüyebileceğini inceleyelim. Örnek olarak en basit,

>>>a = 12;
>>>a;
>>>
0

bir atama işleminin yürüyüşünün anatomisi, a tanıtıcısına bir tamsayı verisi olan 12 değerinin bağlandığını ve a tanıtıcısı çağrıldığında bağlanmış olduğu tamsayı verisi olan 12 değerini döndürdüğüdür. Bağlanmış olan 12 değeri bir tamsayıdır, makine dilinde az sayıda bit ile tanımlanır ve küçük bir bellek alanında a tanıtıcısı ile birlikte saklanır. tanıtıcı çağrıldığında kendisine bağlanmış olan değeri döndürür. Tüm değişmez verilerde atama işlemi bu şekilde yürür. Programda bildirim sonlarında kullanılan semikolon (;) tamamen isteğe bağlıdır, fakat kullanılması daha kolay okunabilen kodlar oluşturur.

Bir tanıtıcıya atanmış olan bir değerden sonra, aynı tanıtıcıya başka bir değer atanırsa, eski değer kaybolur ve tanıcıya yeni değer bağlanır. Buna tahrip edici atama adı verilir. Örnek,

>>>a = 25;
>>>a = 50;
>>>a;
>>>
50

Görüldüğü gibi, a tanıtıcısına bağlanmış olan ilk 25 değeri kaybolmuş ve a tanıtıcısı artık yeni 50 değerini döndürmekedir. 25 değeri kaybolmuştur, artık hiçbir şekilde erişilemez.

Eğer eski değerin kaybolmaması istenirse, yeni değer başka bir tanıtıcıya atanmalıdır. Örnek,

>>>a = 25;
>>>b = 50;
>>>a;
>>>
25
>>>b;
>>>
50

Pyhton programlama dilinde, aşağıda görüldüğü gibi, çoklu atamalar yapılabilir.

>>>a = b = c  =  0;
>>>a;
>>>
0
>>>b;
>>>
0
>>>c;
>>>
0

Python derleyicisi, aynı zamanda çok sıradışı olan aşağıdaki tipte atamayı da kabul eder.

>>>a , b = 23,45;
>>>a;
>>>
23
>>>b;
>>>
45

Bir tanıtıcıya bağlanmış bir değerin, bağlanmış olduğu tanıtıcının çağrılarak, döndürdüğü değerin başka bir tanıtıcıya atanmasına, "aktarma" işlemi adı verilir. Akatarılan değerin değişebilir (mutable) veya değişemez (immutable) bir veri tipinde olmasına göre, Python derleyicisi aktarma mekanizmalarını farklı şekillerde uygular.

Değişemez bir verinin başka bir tanıtıcıya aktarılması değerle aktarım mekanizması ile olur. Bir tanıtıcıya değişemez (immutable) bir veri bağlandığında, tanıtıcıya verinin değeri bağlanır. Bu değer başka bir tanıtıcıya aktarılacağı vakit, o değerin kopyası diğer tanıtıcıya atanır. Sonuçta hem ilk hem de ikinci tanıtıcıya aynı değer bağlanmış olur. Fakat, her iki tanıtıcı da birbirinden bağımsızdır. İkinci tanıtıcıya bağlanmış olan değer, tahrip edici bir başka atama ile değiştirilebilir. Fakat, bu değişmeden ilk tanıtıcıya bağlanmış olan değer etkilenmez. Sonuçta, ilk tanıtıcı, kendisine bağlanmış olan orijinal değeri, ikinci tanıtıcı da kendisine bağlanmış olan son değeri döndürür. Örnek:

>>> a = 100;
>>> b = a;
>>> b = 47.8665;
>>>a;
>>>
100
>>>b;
>>>
47.8665

Yukarıdaki programda, aktarmadan sonra, aktarılan tanıtıcının bağlandığı değerin değişmesi, aktaran tanıtıcıya bağlanmış olan değeri etkilemiyor. Bunun nedeni, aktarılan değerin, ilk tanıtıcının bağlandığı değerin kopyası olmasıdır. Orijinal değer saklanıyor ve sadece kopyası aktarılıyor. Aktarma gerçekleştikten sonra, her iki tanıtıcı ayrı bellek alanlarında saklandıkları için, birbirlerinden bağımsız olarak belli değerlere bağlanmış oluyorlar. Bir tanesine bağlanan değerin değiştirilmesi, başka tanıtıcılara bağlanmış olan değerleri değiştirmez. Yukarıdaki uygulama bunu açıkça belirtiyor. Bu aktarım mekanizmasına, "değerle aktarım" veya "kopyalanarak aktarım" adı verilir ve sadece değiştirilemeyen veriler için geçerlidir.

Değiştirilemeyen değerler güncellenemez. Sadece yerleştirildikleri bellek alanından geri çağrılabilir, üzerlerinde işlem yapılarak yeni değerler oluşturulabilir ve bu yeni değerler aynı tanıtıcıya atanarak, aynı bellek alanına yerleştirilebilir. Bunun bir örneği aşağıda görülmektedir.

a + = 1;
    

Bu ifadede + işlemcisinin öncelik sırası atama işlemcisinden daha yüksektir. Önce attırma işlemi gerçekleşir. Bu işlem, a tanıtısının güncel değeri + 11 şeklinde sonuçlanır. Toplama işlemi sonucu atama işlemininin sağ işlenenidir. Bu şekilde a tanıtıcısı ile ulaşılabilir olan bellek lokasyonunda eski değerin 1 arttırılarak değiştirilmiş şekli yerleştirilir. Sonuçta, eski değere 1 eklenerek elde edilmiş olan yeni değer, aynı bellek lokasyonunda saklanır. Bu bir tahrip edici atamadır. Atama sonunda eski değer kaybolur ve tanıtıcıya yeni değer bağlanmış olur.

Değiştirilemeyen veriler, bir fonksiyona argüman olarak belirtildiğinde, aynı şekilde kopyası argüman olarak kullanılır. Bu nedenle, fonksiyon içinde argümanın değeri değişirse, bu değişme fonksiyon dışına yansımaz. Bu çok önemli bir olgudur ve hep akılda tutulmalıdır. Bunun bir örneği, aşağıda görülmektedir.

>>>def degis(a , b):
...          c = b;
...          b = a;
...          a = c;
...          print("Fonksiyonda x degeri = ", a , "Fonksiyonda y degeri = " , b);
    
x  =  100;
y  =  1016;

degis(x , y);
Fonksiyonda x degeri =  1016 Fonksiyonda y degeri =  100
x
Out[20]: 100
y
Out[21]: 1016
    

Yukarıdaki uygulamada x ve y tanıtıcılarına iki sayısal değer bağlanıyor. Sayısal değerler, değiştirilemez (immutable) tipte verilerdir ve değerle (kopyalanarak) aktarılırlar. Bu değerler, argüman olarak degis() fonksiyonuna yerleştiriliyorlar. Veriler değişmez türde olduklarından, orijinalleri saklanıyor ve sadece kopyaları fonksiyona argüman olarak, yerleştiriliyor. Fonksiyon içinde, kopyaların değerleri değişiyor. Fakat bu değişiklikler, fonksiyon dışındaki orijinal değerleri etkilemiyor. Fonksiyon dışındaki veriler bağlanmış oldukları orijinal değerleri muhafaza ederler. Bu olaylar, yukarıdaki programda adım adım izlenebilir.

Değiştirilemez bir verinin kopyalanabilirliğinin nedeni, bu verinin statik bir veri olmasıdır. Bu veriler bir kez atandıktan sonra hep aynı kalır. Bu verilerin toplam bit sayısı, bir kez bir tanıtıcıya bağlandıktan sonra değişmez. Sabit bir bit sayısına sahip bir verinin yerleşeceği alan uzunluğu belirlidir bu alan uzunluğu, programın ileri aşamalarında değişmez. Bu nedenle, statik bir bellek alanının içeriği her zaman kopyalanabilir niteliktedir.

Değişebilir veriler bunun aksine dinamik karakterdedir. Bu veriler atandıktan sonra bazı kısımları aynı kalırken bazı kısımları değiştirilebilir. Bazı kısımlar çıkartılırken bazı kısımlar veriye eklenebilir. Bu durumda, veri adeta canlı bir varlık olarak düşünülebilir. Bu veride yapılan değişikliklere, "Verinin Güncellenmesi" adı verilir.

Güncellenebilen veriler, bir tanıtıcıya bağlanmak istendiğinde, veri belleğin daha durağan bir kısmına yerleştirilir ve tanıtıcıya bu alana erişim kodu olan bellek referansı bağlanır. Bellek referansı bir hex sayıdır ve güncellenemeyen bir değer olduğundan, aktarılacağı vakit, bu değerin kopyası aktarılır. Aktarımdan sonra, hem ilk tanıtıcı hem de aktarılan tanıtıcıya aynı bellek referansı bağlanmış olur. Her iki tanıtıcı da aynı bellek alanına erişim sağlarlar ve aynı veriyi güncelleyebilirler. Veri aynıdır ve hep aynı bellek alanında bulunmaktadır. Bu bellek alanına birden fazla tanıtıcıya bağlanmış olan aynı bellek referansı ile erişilebilir. Yani, aynı veri farklı tanıcılarlarla güncellenebilir veya çağrılabilir. Bu veriye erişimi olan her tanıtıcı çağrıldığında, daima verinin en son güncellenmiş şekline erişebilir ve ancak verinin en son güncellenmiş halini döndürebilir. Bu mekanizmaya "Referansla Aktarım" adı verilir. Aslında, "Referansın Kopyası ile Aktarım" denilse daha doğru olabilirdi.

Değişebilir bir verinin referansla aktarımı konusunda aşağıda iki uygulama verilmiştir. Bunlardan ilki, değiştirilebilir bir veri türünün referansla aktarımında oluşan olayların izlenmesini sağlamaktadır.

>>>a  = [23, "Ahmet" , 16.45 , 36];
>>>b = a;
>>>b.remove(36);
>>>b;
Out[26]: [23, 'Ahmet', 16.45]
>>>a;
Out[27]: [23, 'Ahmet', 16.45]    
    

Yukarıdaki progamda, ilk olarak bir a tanıtıcısına bir liste tipi veri bağlanıyor. Liste veri tipi bir değişebilen veri tipi olduğundan, belirli bir bellek alanına yerleştirilip erişim kodu a değişkenine bağlanıyor. Sonra, a daki değer, b tanıtıcısına bağlanıyor. Burada a tanıtıcısında bir hex sayı değeri (liste verisinin yerleştirildiği bellek alanının erişim kodu) olduğundan, ve sayılar değişemez veri tiplerinden olduklarından, a daki değerin kopyası b ye bağlanıyor. Aktarım sonunda hem a, hem de b aynı hex değerine ( liste tipi verinin yerleştirildiği bellek alanına erişim kodu veya başka bir deyişle erişim referansı) bağlanmış olduğundan, aynı liste tipi veriye erişim sağlayabiliyorlar. Bu tanıcıların her ikisi de, yerleşik aynı listeyi güncelleyebiliyor veya güncellenmiş liste değerine (aynı değere) erişip bu değeri döndürebiliyor. Bir program adımı sonra, yerleşik liste, tanıtıcılardan birisi kullanılarak güncelleniyor. Hangi tanıtıcı veriyi güncellerse güncellesin, güncellenen değer her iki tanıtıcı tarafından da geri döndürülebiliyor.

Aynı sonuç, bir değişebilen verinin bağlandığı bir tanıtıcının bir fonksiyona argüman olarak uygulanması sırasında da yaşanır. Tanıtıcı üzerinde sadece verinin yerleştirildiği bellek alanına erişimi sağlayan hex kodu bulunur. Bu bir değişemez değer olduğundan, fonksiyona argüman olarak bu hex kodunun kopyası gönderilir. Fonksiyon içinde argümanın değeri değişirse, bu değişiklik doğal olarak dışaıdaki tanıtıcının döndüreceği değeri de değiştirir. Programı izleyelim:

>>>veriListe = [ 23, 'Ahmet', 16.45];

>>>def listeAzalt (liste):
...         liste.remove([liste(len)-1]);
...         print('Dahili Liste :', liste);
>>>listeAzalt(veriListe);
Dahili Liste :  [23, 'Ahmet']
>>>print('Harici Liste :', veriListe);
Harici Liste =  [23, 'Ahmet']
    

Yukarıdaki programda, ilk olarak [23, 'Ahmet' ,16.45] şeklinde bir liste literal olarak tanımlanarak, statik bir bellek alanına yerleştiriliyor ve erişim kodu, veriListe adında bir tanıtıcıya bağlanıyor. Sonra, listeAzalt adinda bir fonksiyon tanımlanıyor. Bu fonksiyon argüman olarak bir liste verisi alıyor ve argümanı olan listenin son elemanını listeden çıkarıyor. Geri kalan listeyi de görüntülüyor. Bu fonksiyona argüman olarak veriListe tanıtıcısını besliyoruz. Aslında, veriListe adlı tanıtıcıya sadece literal olarak tanımlanmış ve bir bellek alanına yerleştirilmiş listeye erişim kodu bağlanmış olduğundan ve bu kod da sayısal bir değer olup kopyalanabilir nitelikte olduğundan, fonksiyona sadece ana veriye erişim kodunun kopyası argüman olarak gönderilmiş oluyor. Fonkiyon argümanı, ana veriye erişim kodunu içerdiğinden, fonksiyon argümanı üzerinden yapılacak her değişiklik ana veriye yansıyor. Fonksiyon içinde argüman güncelleniyor. Bu güncelleme, doğruda doğruya literal olarak tanımlanmış liste üzerinden oluyor ve literal olarak tanımlanmış liste güncellenmiş oluyor. Güncellenmiş olan literal olarak tanımlanmış liste, fonksiyon içinden görüntüleniyor ve fonkisyonun işlevi tamamlanıyor. Literal olarak tanımlanmış liste, fonksiyon dışından da çağrıldığında, fonksiyon içinde gerçekleşen güncellemenin, fonksiyon dışına da yanısımış olduğu, görüntülenen liste elemanlarından açıkça anlaşılıyor.

Güncellenebilen verilerin kopyalanarak aktarılmaları engelleyen nedenlerden birisi, bu verilerin genişleyebilme potansiyelleridir. Büyük verilerin kopyalanmasının, hem programı yavaşlatacağı, hem de kontrolsuz olarak sürekli bellek işgal edilmesi sonunda, programın kullanabileceği bellek adreslerinin kısa sürede tükenebileceği gözönüne alınarak, aktarımların buna meydan vermeyecek mekanizmalar üzerinden gerçekleşmesi sağlanır. Bir başka neden de, bu verilerin dinamik niteliğidir. Güncellenebilir bir veri, bir tanıtıcıya bağlansa ve bu tanıtıcıdan başka bir tanıtıcıya değer ile aktarılsa, sonuçta her iki tanıtıcı, farklı bellek alanlarında tutulan farklı veriye erişim yapar duruma gelirler. Bu durumda, her iki tanıtıcı da farklı veriler üzerinde güncelleme yaparlar. Bu durumda, güncelleme olayı karmaşık bir duruma dönüşür. Her tanıtıcı, aynı olması gereken verinin başka bir güncel durumuna erişim sağlar. Eğer veri bir banka hesabı ise, sonuç kötü olur. Bu nedenle, değiştirilebilir bir veri, belirli ve değişmez bir bellek alanında sabit tutulup, farklı tanıtıcıların hep aynı veriyi güncellemesi sağlanır. Değiştirilebilen bir veriye erişimi olan her tanıtıcının, verinin aynı güncellenmiş durumuna erişim sağlaması gerekir. Aksi halde kaos yaratılır.

• « Python Ana Sayfa
• 
  
• « Önceki Sayfa
• 
  
• Sonraki Sayfa »
• 
  
• 
  
•