Ders 19
Ders 19
3.2 - Topluluk (Tuple) Tipi Veriler
Topluluk tipi veriler, normal parantezler arasında gösterilen, aralarında bir virgül ile ayrılmış veri topluluklarıdır. Örnek olarak (8, 2, 10) topluluk tipi bir veridir. Daha doğru bir açıklama ile, bu topluluk sınıfının bir sınıf örneğidir.
Topluluk sınıfı koleksiyonlar, bir kez atandıktan sonra kısmen değiştirilemez veriler olarak tanımlanır. Aslında bu tanım ne her zaman doğru, ne de her zaman yanlıştır. Koleksiyon tipi veriler olarak genel açıdan belirtilen, topluluk verilerinin elemanları her türden olabilir.
Tek boyutlu koleksiyonlar, eleman olarak sadece sayısal veya sözel, fakat tek değerli elemanlar içerirler. Örnek:
t1 = (25, 'www, 34, 'Dünya')
Bu örnekteki t1 değişkenin değeri, koleksiyon tiplerinden, topluluk tipinde bir değerdir. Burada, t topluluğu, tek boyutlu olmasına karşın, aynı tipte veri içermediği için heterojen tipte bir topluluk değeridir. Tek boyutlu ve heterojen bir topluluk olan t topluluğu, kısmen değiştirilemez (immutable) bir topluluk değeridir. Bu değer kısmen değiştirilemez çünkü elemanlarından hiçbiri kısmen değiştirilebilir (mutable) veri tiplerinden birisi değildir.Bir diğer örnek,
t2 = (34, 67, 89)
Bu örnekteki t2 değişkeninin değeri, tek boyutlu homojen bir topluluktur. Tek boyutlu olmasının nedeni, hiçbir elemanının koleksiyon tipinde eleman olmamasıdır. Homojen olmasının nedeni, tüm elemanlarının aynı tip değerlerden oluşmasıdır. Bu topluluk, kısmen değiştirilemez, yani güncellenemez, ancak toptan değiştirilebilir (immutable) karakterdedir. Değiştirilemez olmasının nedeni, tek boyutlu olmasıdır. Tek boyutlu hiçbir topluluk, kısmen değişebilir nitelikte değildir. Bir diğer örnek,
t3 = ((12,67), (56,88), (126 , 'Günaydın'))
Bu örnekteki t3 değişkenin değeri, iki boyutlu homojen bir topluluktur. Bu topluluğun elemanları, sadece topluluk (tuple) veri tipinde olduğu için homojen bir topluluktur. İki boyutlu olmasının nedeni elemanlarının tek boyutlu olması, yani hiçbir koleksiyon veri tipinde eleman içermemeleridir. Bu iki boyutlu topluluk kısmen değişemez (güncellenemez) niteliktedir. Çünkü, hiçbir elemanı kısmen değişebilir (güncellenebilir) nitelikte değildir. Bu topluluk ancak tamamen değiştirilebilir. Bir başka örnek,
T4 = (23, 'ali', 12.67, 'YARIÇAP', [12, 'Mor Salkım Sokak Beşiktaş-Istanbul'])
Bu topluluk üç boyutludur, çünkü elemanları koleksiyon tipi bir veri tipi olan liste tipi bir eleman içermektedir. Bu tek elemanlı bir veri olduğundan, homojenitesi hakkında bir değerlendirme yapılmaz. Bu topluluk güncellenebilir (mutable) bir topluluktur. Çünkü, elemanı, güncellenebilir (mutable) bir veri tipi olan liste tipi bir eleman içermektedir. Bu örnekteki gibi, güncellenebilir tipte eleman içeren toplululara çok dikkat edilmesi gerekir. Çünkü bunlar, prensip olarak güncellenemez bir veri tipi olan topluluk veri tipinde, sıradışı bir nitelik olan güncellenebilir nitelikte verilerdir.
Kısa süre sonra inceleyeceğimiz saözlük (dictionary) tipinde koleksiyonlarda veriler (anahtar:değer) toplulukları olarak yerlştirilir. Anahtar değerlerine program sonuna kadar değişmeyen bir hash değeri verilir. Bu hash değerinin program sonuna kadar aynı kalması için program sonuna kadar değişmemesi gerekir. Sözlük tipi verilerin anahtar değerleri olarak kullanılabilecek değerlere "hashable" adı verilir. Topluk verilerinin bu kriteryuma uyanları, sadece tek boyutlu, elemanları koleksiyon tipi olmayan topluluklardır. Bunları sözlükler ile çalışırken daha yakından inceleyeceğiz.
Bu sayfa ile birlikte uygulama düzeni değişecektir. İlk uygulamalarımızda, Python programlama dili için zorunlu olmamasına karşın, bildirim sonlarına noktalı virgül konulmuştu. Bunun amacı, Python programlama diline yeni başlayanlar için, bildirimlerin tanınmasıydı. Bir süre sonra, artık herkes bildirimleri tanıyacak yeterli düzeye eriştiğinden, bildirim sonlarına noktalı virgül konulması uygulamasına son verilmişti. Program kodları ise, belirli bir süre, saklı sözcükleri, işlemcileri, sözel ve sayısal verileri belirtmek için, çeşitli renklerde yazıldı. Bu aşamada, artık her izleyici, Python program dilinin çeştli öğelerini tanıyabilecek duruma geldiğinden, program kodlarının renkli olarak yazılmasına da gerek olmayacaktır. İzleyicilerin izlemeleri kolay olsun diye programlar belirli bir numara sayısı le verilmekteyken artık bu uygulama da sorunlara neden olabilecektir. Python programlama dili, hem varsayılan builtins modülünde, hem de çağrılmayı bekleyen modüllerde, sayısız denilecek kadar hazır fonksiyon, değer, tanımlanmış nesne sınıfı içermektedir. Hiçbir kitabın, bunların tümünü tek bir ciltte kapsama olanağı yoktur. Ayrıca yazılmış kitap ve web sayfalarının tümüne yakını, okuduğunuz dahil, sadece tanıtım amaçlı öğretim için yazılmışlardır. Bunlar arasında ilginç görülenlerin zaman içinde, ilgili konu başlığına eklenmesi harika olacaktır. Oysa, birbirini sıra numarası ile izleyen uygulamaların arasına yeni numaralı bir uygulamanın eklenmesi, ancak tüm uygulama numaralarının değişmesi ve bu uygulamaların kaydedildikleri disk dosyalarının yeniden isimlendirilmesi gibi çok uğraşı gerektiren bir yöntemle gerçekleştirilebilir. Bu yüzden, uygulama programları ve sonuçları artık sayfa içinde verilecektir. Bu şekilde, web sayfalarının dinamik özelliğinden yararlanılabilecek, gereğinde eklemeler yapılabilecek, yeni örnekler sunulabilecek, bu şekilde, dinamik yetenekli web sayfalarının avantajının kaybolup, kitap sayfaları gibi sabit sayfalara dönüşmeleri engellenmiş olacaktır.
Bundan sonra uygulama örnekleri iPython notebook larındaki hücreler (cell) kullanılarak gerçekleştirilecek ve bu sayfalara kopyalanacak, bu yüzden program metinleri ayrı dosyalar halinde saklanmayacaktır. iPython hücereleri birer IDE niteliğindedir. Bu yüzden iPython hücrelerinde yazılan programlar aynen bir IDE'de yazılmış gibidir. Bu program örneklerinin metinleri kopyalanarak tüm Python IDE lerinde değiştirilmeden kullanılabilir. Program çıktıları ise, eskisi gibi kahverengi olarak belirtilecek, bu şekilde programlar ve çıktılar ayrılmış olacaktır.
Bilgisayarlara iPython kurulması gayet kolaydır. Bu konuda iPython web sitesinde verilen kurulum bilgilerinin uygulanması yeterlidir. Bilgisayarlara iPython kurulursa, uygulama programları ders sayfalarından daha kolaylıkla çalıştırılabilekleri iPython hücrelerine aktarılabilir. Yine de bu zorunlu değildir ve program metinleri herhangibir IDE ye kes-yapıştır yöntemi ile aktarılabilir.
3.2.1 - Topluluk (Tuple) Tipi Verilerin Yaratılması
Topluluklar literal olarak (veya bir dosyadan okutarak) atama ile yaratılabilir. Örnek :
tpl = (3, 5, 78)
print(tpl)
Program Sonucu :
(3, 5, 78)
Topluluklar sözdizimi olarak, virgülle ayrılmış verilerdir. İstenirse parantez kullanılmadan da atanabilirler. Örnek:
tpl = 3, 5, 78
print(tpl)
Program Sonucu :
(3, 5, 78)
Görüldüğü gibi, sonuç aynı olmakta ve bir topluluk tipi veri yaratılmaktadır.Fakat en doğrusu, alışılmış olduğu gibi parantez kullanılarak literal ile veya dosyadan okutarak atama yapmaktır. Örnek,
x = (23, 35, 16)
print(x)
Program Sonucu :
(23, 35, 16)
Yukarıdaki atama işlemine çok dikkat edilmesi gerekir. Atama işleminin sağ veya sol işleneninde virgül ile ayrılmış birden çok veri bulunuyorsa bu gizli bir topluluk anlamına gelir. Python programlama dilinde bu şekilde çok gizli topluluk tanımları bulunmaktadır.
İki topluluğun birbirbirine eşit olması için, birbirlerine denk gelen tüm elemanların birbirlerine eşit olması gerekir. Bu özellikten çoklu atamaların kısaltılması amacı ile yararlanılabilir. Örnek:
Topluluklar, atama işlemlerinde kolaylık sağlar. Aşağıda görüldüğü gibi, birden çok değişkene topluluk tipi sekansların uygulanması ile kolayca atama gerçekleştirilebilir. Topluluk tipi veriler, atama işlemcisinin sol tarafında bulunabilir. Bu topluluğun elemanları, bire bir sağ taraftaki topluluk elemanlarına atanabilirler.
a, b, c = 23, 45, 89
print('a = {0}, b = {1}, c = {2}'.format(a, b, c))
Program Sonucu :
a = 23, b = 45, c = 89
Burada aslında iki gizli topluluk tipi veri birbirlerine eşit hale getirilmektedirler.
(a, b, c) = (23, 45, 89)
Bu iki topluluğun eşitlenebilmesi için, denk elemanlarının birlerine eşitlenmesi gerekir. Bu şekilde, sol taraftaki ilk eleman, sağ taraftaki ilk eleman ile eşitlenir ve a = 23 ataması gerçekleşir. Diğer elemanlar da benzer şekilde atanırlar ve bu şekilde, tek atama işleminde ün atama birden yapılmış olur.
Atama işleminin sol tarafında, bir topluluğun elemanlarının olması, çok kullanışlı bir değişim (swap) işlemine olanak sağlar. Örnek,
# Normal swap
a = 45
b = 92
temp = a
a = b
b = temp
print(" a = {0}, b = {1}".format(a, b))
Program Sonucu :
a = 92, b = 45 # tuple swap a = 45 b = 92 a, b = b, a print(" a = {0}, b = {1}".format(a, b)) Program Sonucu :
a = 92, b = 45
Yukarıdaki uygulamadan, değer değişimi (swap) işleminin ne kadar kolay uygulanabildiği görülüyor.
Tek elemanlı bir topluluk aşağıdaki gibi atanamaz:
t1 = (4)
print (t1, type(t1))
Program Sonucu :
4 <class 'int'>
Görüldüğü gibi, bu bir tamsayı sonucu veriyor. Eğer tek elemanlı bir topluluk atanmak istenirse, o vakit literalin sonuna bir virgül eklemek gerekir. Örnek
t2 = (34,)
print (t2, type(t2))
Program Sonucu :
(34,) <class 'tuple'>
Bu sefer atama amacına ulaşmış ve bir topluluk yaratılmış olmaktadır.
İçi boş parantezler, sıfır elemanlı bir topluluk anlamına gelir. Örnek,
p = ()
print (p, type(p))
Program Sonucu :
() <class 'tuple'>
Topluluklar, iki sayının aritmetik işlem sonucu (toplama, çıkarma, çarpma , bölme, üs alma vb ... olarak yaratılabilirler. Sadece bu işlemin sonuna bir virgül eklenerek, işlemin bir aritmetik işlem değil, bir topluluk yaratma olduğu belirtilmelidir. Örnek:
a = 12
b = 33
c = (a + b,)
print('c{0} , \nveri tipi = {1}'.format (c, type(c)))
Program Sonucu :
c = (45,) veri tipi = <class 'tuple'>
Topluluklar, önceden tanımlanmış toplulukların elemanlarının toplamı olarak da yaratılabilirler. Örnek,
a1 = (2, 4)
b1 = (7, 5)
c1 = (a1 + b1,)
print('c1 = {0} \t veri tipi = {1}'.format (c1, type(c1)))
Program Sonucu :
c1 = ((2, 4, 7, 5),) veri tipi = <class 'tuple'>
Oluşan topluluk, c1 = (2, 7, 2, 7) olarak belirtilebilir. Bu işlem birleştirme (concatenation) işlemidir. Bir başka örnek:
a2 = (2, 4)
c2 = (a2 * 3,)
print('c2 = {0} \t veri tipi = {1}'.format (c2, type(c2)))
Program Sonucu :
c2 = ((2, 4, 2, 4, 2, 4),) veri tipi = <class 'tuple'>
Oluşan topluluk, c2 = (2, 4, 2, 4, 2, 4) olarak belirtilebilir. Bu işleme çoğaltma adı verilir.
Öntanımlı tuple() fonksiyonu, başka veri tiplerinde tanımlanmış koleksiyonları, topluluk tipine dönüştürmek için uygulanır. Bu fonksiyon argümanı olan her koleksiyonu, topluluğa dönüştürür. Hiç argümansız uygulanan tuple() fonksiyonu, boş bir topluluk yaratır. Örnek,
p = tuple()
print(p, '\t', type(p))
Program Sonucu :
() <class 'tuple'>
Öntanımlı tuple() fonksiyonunun bu şekilde kullanımı anlamsızdır, çünkü p = () ataması da sonuçta boş bir topluluk yaratır. Aynı şekilde, tuple() fonksiyonunun argümanı olarak bir topluluk kullanımı da anlamsızdır çünkü, ortada dönüşecek bir veri tipi yoktur, argüman zaten topluluk veri tipindedir.
Öntanımlı tuple() fonksiyonunun argümanı olarak kullanılması gereken veri tipleri, topluluktan başka koleksiyon veri tipleridir. Örnek,
topluluk = tuple('Yaşam')
print('topluluk = {0} {1}'.format (topluluk, type(topluluk)))
Program Sonucu :
topluluk = ('Y', 'a', 'ş', 'a', 'm') <class 'tuple'>
Sözel tipte veriler, aslında bir karakter koleksiyonudur. Burada, öntanımlı tuple() fonksiyonu, sözel tipte verinin karakterlerini sıralı olarak, topluluk tipine dönüştürerek, topluluk adında ve topluluk veri tipinde bir değişkene atamaktadır.
Tamsayılar içeren topluluklar, öntanımlı range () fonksiyonu ile yaratılabilirler. Örnek:
p = tuple(range(1,10))
print('p = {0}'.format(p))
Program Sonucu :
p = (1, 2, 3, 4, 5, 6, 7, 8, 9)
Bir başka örnek:
pt = tuple(range(10,0, -1))
print('pt = {0}'.format(pt))
Program Sonucu :
pt = (10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
Fonksiyonlar sadece tek bir değeri geri döndürebilirler. Fakat, bazı fonksiyonlar, birden çok değeri değeri geri döndürür gibi görünebilirler. Aslında, birden çok değeri geri döndürür görüntüsünde olan fonksiyonlar, birçok değeri eleman olarak içeren sadece bir tek topluluğu geri döndürürler. Örnek olarak öntanımlı divmod (a, b ) fonksiyonu, a ve b gibi iki argüman alır ve bunların bölümünün kalan (a%b) ve sonuç (a/b) değerlerini verir. Bu iki değer ayrı ayrı hesaplanabilir ama divmod() fonksiyonu yardımı ile birlikte hesaplanmaları, daha etkin olarak nitelendirilir. Burada divmod() fonksiyonun geri döndürdüğü iki değer, iki değerli bir topluluğun elemanları olarak atanır. Örnek,
# Fonksiyonlardan Birden Çok Değer Döndürülmesi bölmeSonucu = divmod(444444, 6) print("Sonuç = {1} , Kalan = {0}".format(bölmeSonucu[1], bölmeSonucu[0])) Program Sonucu :
Sonuç = 74074 , Kalan = 0
Topluluklar, daha önce atanmış bir topluluğu işaret eden bir değişkenin de taşıdığı, bellek referansı değerinin başka bir değişkene aktarımı sonucunda da oluşabilir. Örnek:
p = (28, 89, 34)
q = p
print(q)
Program Sonucu :
(28, 89, 34)
Burada uygulanan işlem, sadece p nin değeri olan bellek referansının (bir hex tamsayı) q değişkenine aktarılmasıdır. Sonunda her ikisi de aynı bellek alanına işaret eder duruma gelirler ve işaret ettileri bellek alanında bir veri yığını yerleşik durumdadır. Bu durumda p ve q aynı veri yığınına işaret ederler ve bu veri yığınında bir değişiklik (eleme veya çıkarma gibi) olursa, bu değişlik hem p nin hem de q nün geri döndüreceği değeri değiştirir. Yani, bellek referanslarının aktarımı sonucunda, her iki değişken de birbirlerine bağımlı kalırlar. Buna sığ kopyalama denilir. Sığ kopyalama, değişkenin bellek referansının (verinin değil!) kopyalanması ile gerçekleşir.
Verinin sabit kalıp, veriye erişimi sağlayan bellek referanslarının kopyalanması değişmeyen (immutable) veriler için hiçbir sotun yaratmaz. Tam aksine, veri kopyalanıp başka bir bellek alanına aynı verinin bir kopyası yerleştirilmediğinden, bellek ekonomisi de gerçekleşmiş olur. Veri yığını belirli bir bellek alanına yerleşmiştir. Program sonuna kadar değişme olasılığı da yoktur. Aslında bu veriyi işaret eden bellek referansının da başka bir değişkene aktarımı kozmetik bir olaydır. Bunun hiçbir gereği yoktur. Değişmeyen ve program sonuna kadar da değişmeyecek olan, bellekte yerleşik yeri değişmeyecek bir veriye işaret eden bir tek işaretçi (pointer), sadece bir tek değişkene atanırsa yeterli olur. Veriye gerek duyulursa, veriye işaret eden işaretçiyi değer olarak taşıyan değişkenin çağrılması yeterlidir. Fazla değişkene gerek olmamasına karşın, eğer mutlaka kopyalama istenirse salt bellek referansının kopyalanması, yani sığ kopyalama yeterlidir. Özetle, sığ kopyalama, değişmeyen veriler için tek ve yeterli kopyalama mekanizmasıdır. Sığ kopyalamanın uygulanmasının sonuçları aşağıdaki programda görülmektedir.
t1 = (8, (6, 9, 10, ('Ali Haydar Alan', 5, 7)), 45 ,16)
t2 = (8, (6, 9, 10, ('Ali Haydar Alan', 5, 7)), 45, 16)
print('t1 = {0} {1}'.format (t1, type(t1)))
print('t2 = {0} {1}'.format (t2, type(t2)))
t1 =(8, (6, 9, 10, ('Mehmet Yerebakan', 5, 7)), 45 ,16)
print('t1 = {0} {1}'.format (t1, type(t1)))
print('t2 = {0} {1}'.format (t2, type(t2)))
Program Sonucu :
t1 = (8, (6, 9, 10, ('Ali Haydar Alan', 5, 7)), 45, 16) <class 'tuple'>
t2 = (8, (6, 9, 10, ('Ali Haydar Alan', 5, 7)), 45, 16) <class 'tuple'>
t1 = (8, (6, 9, 10, ('Mehmet Yerebakan', 5, 7)), 45, 16) <class 'tuple'>
t2 = (8, (6, 9, 10, ('Ali Haydar Alan', 5, 7)), 45, 16) <class 'tuple'>
Yukarıdaki programda, t1 değişkeninin değeri, değişmeyen tipte bir topluluktur. Bu topluğun tüm elemanları değişmeyen tipte olduklarından, topluluk da değişmeyen tiptedir. Bu topluluk t2 değişkenine bellek referansını kopyalanması yolu ile sığ kopyalanmıştır. Bunun hiçbir dezavantajı yoktur. Bu tip topluluklar güncellenemez ve ancak topan değişebilir. Program içinde bu değişmenin yapıldığı görülüyor. Bu durumda, t1 değişkeninin işaret ettiği bellek alanı boşaltılır. Değer toptan yenilenir. Yenilenen değer, bellekte yeni bir alana yerleştirilir. Bu yeni bellek alanına işaret eden işaretçi, t1 değişkenine atanır ve bu durumda, orijinal t1 değişkeni ile sığ kopyası t2 değişkeni farklı bellek alanlarında yerleşmiş farklı verilere işaret ettiklerinden birbirlerinden tamamen bağımsız olurlar. Program sonunda, her iki değişkenin de farklı verileri döndürdükleri görülmektedir. Bu uygulama, güncellenemez verilerin sığ kopyalanmasının, bağımsız kopyalar oluşturmak için yeterli olduğunu belirtmektedir.
Şimdi güncellenebilen bir toplulukta, sığ kopyalamanın yetersizliğini belirten bir uygulamayı izleyelim:
g1 = ("Sara Alhadef" , ["Yeşil Çayır Sokak no:16/8 Nişantaş, Şişli- Istanbul"])
g2 = g1 # referansların kopyalanması (sığ kopyalama)
print('g1 = {0} {1}'.format (g1, type(g1)))
print('g2 = {0} {1}'.format (g2, type(g2)))
g1[1].append("Avrupa Yakası")
print('g1 = {0} {1}'.format (g1, type(g1)))
print('g2 = {0} {1}'.format (g2, type(g2)))
Program Sonucu :
g1 = ('Sara Alhadef', ['Yeşil Çayır Sokak no:16/8 Nişantaş, Şişli- Istanbul']) <class 'tuple'>
g2 = ('Sara Alhadef', ['Yeşil Çayır Sokak no:16/8 Nişantaş, Şişli- Istanbul']) <class 'tuple'>
g1 = ('Sara Alhadef', ['Yeşil Çayır Sokak no:16/8 Nişantaş, Şişli- Istanbul', 'Avrupa Yakası']) <class 'tuple'>
g2 = ('Sara Alhadef', ['Yeşil Çayır Sokak no:16/8 Nişantaş, Şişli- Istanbul', 'Avrupa Yakası']) <class 'tuple'>
Yukarıdaki program güncellenebilen bir veri tipi için, salt sığ kopyalamanın, bağımsız kopyalar oluşturulması için yeterli olmadığını, sığ kopyalamada orijinal ile kopyanın birbirlerine bağımlı kaldıklarını, birinin güncellediği değerin her iki kopya değişkenine de yansıdığını belirtmektedir.
Güncellenebilir topluluklar için durum değişiktir. Burada güncellenebilen bir topluluk vardır ve salt bellek referansının kopyalanması sonucunda birbirine bağımlı değişkenlerin yaratılması o an için geçerli değerin kopyalanıp, program sonuna kadar değişmeden saklanabilmesi olası değildir. Veri değişebilir niteliktedir. Sığ kopyalama birbirine bağımlı değişkenler yaratır. Veriyi bir değişken güncellerse, hem değişken hem de onun sığ kopyası orijinal değil, güncellenen değere erişir olacaklardır. Bu durumda kopyanın değer stabilitesi kaybolacak, bir değeri kopyalamışken, program içinde başka bir değeri geri döndürür duruma gelecektir. Bu durumun çözümü, bağımız kopyalar yaratmakla sağlanır. Bu da kopyalamanın bellek referansının değil, verinin kendisinin kopyalanıp bellekte başka bir yere yerleştirilmesi ve bu alana da sadece kopyanın işaret etmesidir. Bu durumda iki değişken birbirbirinden bağımsız olacak ve her biri ayrı bir veriyi güncelleyebilecektir. Buna derin kopyalama adı verilir. Derin kopyalama mekanizması, verinin kopyalanıp yeni bir alana yerleştirilmesi ve bu alana erişebilecek tek referansın sadece kopya değişkenine atanmasıdır. Aşağıda bir derin kopyalama uygulaması görülmektedir.
import copy
g1 = ("Sara Alhadef" , ["Yeşil Çayır Sokak no:16/8 Nişantaş, Şişli- Istanbul"])
g2 = copy.deepcopy(g1) # Bağımsız kopya (derin kopyalama)
g1[1].append("Avrupa Yakası")
print('g1 = {0} {1}'.format (g1, type(g1)))
print('g2 = {0} {1}'.format (g2, type(g2)))
Program Sonucu :
g1 = ('Sara Alhadef', ['Yeşil Çayır Sokak no:16/8 Nişantaş, Şişli- Istanbul', 'Avrupa Yakası']) <class 'tuple'>
g2 = ('Sara Alhadef', ['Yeşil Çayır Sokak no:16/8 Nişantaş, Şişli- Istanbul']) <class 'tuple'>
Yukarıdaki uygulama, kısmen değişebilir verilerin bağımsız olarak kopyalanmaları için derin kopyalama yönteminin uygulanmasının zorunlu olduğu açıkça belirtmektedir.
Bu uygulamalarda topluluk verisinin hangi kısmının güncellenebildiği dikkatle izlenmelidir. Topluluklar prensip olarak güncellenemeyen koleksiyonlardır. Bir topluluk kesinlikle güncellenemez (kısmen değiştirilemez). Aşağıdaki uygulama bunu açıkça ortaya koymaktadır.
pg = (7,8,[77,45,89])
pg.append(77)
Program Sonucu :
Traceback (most recent call last)
-<ipython-input-2-2a4ba33dc439> inn <module>()
----> 1 pg.append(77)
AttributeError: 'tuple' object has no attribute 'append'
Burada güncellenebilen, sadece topluluk nesne örneğinin güncellenebilir elemanlarıdır. Örnek,
pg = (7,8,[77,45,89])
pg[2].append(99)
print(pg)
Program Sonucu :
(7, 8, [77, 45, 89, 99])
Yukarıdaki uygulamadan açıkça güncellenenin, topluluk değil, topluluğun güncellenebilir bir elemanı olan liste tipindeki üçüncü elemanı olduğu görülmektedir.
Topluluklar listelere benzer ve listeler gibi toplulukların da alt toplulukları oluşturulabilir. Bu işlemlere dilimleme (slicing) denilmektedir. Bu konuda çeşitli örnekler aşağıda görülmektedir.
y = x[1:2]
print('x = {0} y = {1}'.format(x , y))
y = x[0:-2]
print('x = {0} y = {1}'.format(x , y))
y = x[-3:-2]
print('x = {0} y = {1}'.format(x , y))
y = x[-len(x):-2]
print('x = {0} y = {1}'.format(x , y))
y = x[0:-len(x)+1]
print('x = {0} y = {1}'.format(x , y))
y = x[0:len(x)-1]
print('x = {0} y = {1}'.format(x , y))
y = x[0:-1]
print('x = {0} y = {1}'.format(x , y))
Program Sonucu :
x = ('a', 'b', 'c') y = ('b',)
x = ('a', 'b', 'c') y = ('a',)
x = ('a', 'b', 'c') y = ('a',)
x = ('a', 'b', 'c') y = ('a',)
x = ('a', 'b', 'c') y = ('a',)
x = ('a', 'b', 'c') y = ('a', 'b')
x = ('a', 'b', 'c') y = ('a', 'b')
Dilimleme, bir topluluğun kopyalanmasını (replication) sağlayabilir. Fakat, oluşturulan replikanın sadece orijinal topluluğun bir sığ kopyası olduğu, daima gözönüne alınmalıdır. Örnek :
pg = (7,8,[77,45,89])
qg = pg[:] #replikasyon
print('Orijinal topluluk (güncellemeden önce) : {0}'.format(pg))
print('Replika (güncellemeden önce) : {0}'.format(qg))
pg[2].append(77) #güncelleme
print('Orijinal topluluk (güncellemeden sonra) : {0}'.format(pg))
print('Replika (güncellemeden sonra) : {0}'.format(qg))
Program Sonucu :
Orijinal topluluk (güncellemeden önce) : (7, 8, [77, 45, 89])
Replika (güncellemeden önce) : (7, 8, [77, 45, 89])
Orijinal topluluk (güncellemeden sonra) : (7, 8, [77, 45, 89, 77])
Replika (güncellemeden sonra) : (7, 8, [77, 45, 89, 77])
Bu uygulamada, replikasyonun sadece bir sığ kopyalama olduğu, replikasyon işleminin sadece bir referans aktarımı olduğu, replikasyondan sonra oluşan replikanın orijinal topluluğa işaşeret eden değişken ile aynı veriye işaret edeceği, bu veride yaşanacak bir güncelleme sonunda veride kısmen bir değişiklik olursa, orijinal ve replikanın aynı değişmiş veriye erişeceği açıkça görülmektedir.
Topluluklar, tuple() fonksiyonu, önceden yaratılmış bir topluluk ve bu topluluk üyelerine uygulanabilen kriteryumlara göre yaratılabilirler.
y = tuple( i >'a' for i in x)
print('y = {0}'.format(y))
d = (1, 2, 3, 4,)
y = tuple( i*i for i in d)
print('y = {0}'.format(y))
z = tuple (q >3 for q in d)
print('z = {0}'.format(z))
Program Sonucu :
y = (False, True, True)
y = (1, 4, 9, 16)
z = (False, False, False, True)
List comprehensions yöntemi, topluluk tipi verilerde uygulanamaz. Çünkü topluluk tipi veriler, değiştirilemez veri tiplerindendir, dolayısı ile append() fonksiyonu bu veri tipine uygulanamaz.
d = (1, 2, 3, 4,)
y = ( i*i for i in d)
print('y = {0}'.format(y))
Program Sonucu :
y = <generator object <genexpr> at 0x0000000007346870>
# oysa liste tipinde veriler ile çalışır ! y = [i*i for i in d] print('y = {0}'.format(y)) Program Sonucu :
y = [1, 4, 9, 16]
Tamsayılar içeren topluluklar, range() fonksiyonu ile yaratılabilirler.
p = tuple(range(1,10))
print('p = {0}'.format(p))
Program Sonucu :
p = (1, 2, 3, 4, 5, 6, 7, 8, 9)
pt = tuple(range(10,0, -1))
print('pt = {0}'.format(pt))
Program Sonucu :
pt = (10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
Topluluk tipi koleksiyonların oluşturulma yöntemlerini inceledik. Oluşturulan topluluk elemanlarına erişim sağlanması yöntemleri ile devam edeceğiz.
3.2.2 - Topluluk (Tuple) Tipi Verilerin Elemanlarına Erişim
Topluluk veri tipi bir koleksiyon veri tipidir. Topluluk verilerine tüm koleksiyon veri tipleri için uygulanabilen yöntemlerle erişim sağlanabilir.
Topluluk elemanlarına indis değerleri ile erişilebilir. İndis değerleri 0 den başlar ve koleksiyon sonuna kadar bir artarak devam eder. Aşağıdaki uygulama, bir topluluk verisinin elemanlarına erişim için uygulanması gereken indis değerlerini açıklamaktadır.
pq = (12, 56, 38, (34, 27, (92, 77, 66)), 2, 7)
for x, i in enumerate(pq):
print('pq[{0}] = {1}'.format(x, i))
if type(i) == tuple:
a = x
for y, j in enumerate(i):
print('pq[{0}][{1}] = {2}'.format(a, y, j))
if type(j) == tuple:
b = y
for z, k in enumerate(j):
print('pq[{0}][{1}][{2}] = {3}'.format(a, b, z, k))
Program Sonucu :
pq[0] = 12
pq[1] = 56
pq[2] = 38
pq[3] = (34, 27, (92, 77, 66))
pq[3][0] = 34
pq[3][1] = 27
pq[3][2] = (92, 77, 66)
pq[3][2][0] = 92
pq[3][2][1] = 77
pq[3][2][2] = 66
pq[4] = 2
pq[5] = 7
Bu program sonuçları, çok önemli bilgileri açığa çıkarmaktadır. Herşeyden önce, Python koleksiyonlarının JavaScript dizileri gibi boyutlu olmadıklarını, sadece çeşitli derinliklerde elemanlar içeren veri yığınları olduklarını belirtmektedir. Bu koleksiyonlarda her elemana kendi derinliğine göre düzenlenen indislerle erişilmektedir. Örnek olarak pq topluluğunda, üçüncü elemanın değeri 38 dir. Bu pq ile eşdüzey bir elementtir ve bu gibi eşdüzey elemanlara sadece tek bir indis değeri ile erişilebilir. Dördüncü eleman bir topluluktur ve pq[3] bu topluluğa erişmektedir. Eğer dördüncü elemanın iç elemanlarına erişmek istenirse, iki karakterli indis değerleri ile çağırmak gerekmektedir. İlk indis değeri, elemanın indis değeri, ikinci karakter ise, elemanın iç elemanının indis değeridir. Tukarıdaki programda pq[3][0] indis değeri, 34 değerine erişmektedir. Dördüncü elemanın üçüncü elemanı bir topluluktur ve bunun da ilk elemanına pq[3][2][0] indis değeri ile erişilmektedir.
Python programlama dilininde, koleksiyonların elemanlarına sıralı erişim sağlayan sadece iki döngü yapısı bulunmaktadır. Bunlardan ilki for in diğeri while döngüleridir. Bu döngülerin her ikisinin de yürüyüşünü daha önce incelemiştik. Burada da çeşitli örnek uygulamalar yaparak, bu iki döngü sistemi üzerinde deneyimlerimizi arttıracağız.
ilk olarak while döngüleri üzerine uygulamalar yaparak bu döngü sistemini daha yakından tanımaya çalışacağız. Bu dööngü sisteminin yürüyüşü çok basittir ve yapısı çok esnektir. Öyle ki tüm döngü gereksinmelerini while döngüleri karşılayabilmektedir. Aşağıdaki örneği lütfen iyi izleyiniz.
pq = (12, 56, 38, (34, 27, (92, 77, 66)), 2, 7)
i=0
j = 0
k = 0
while i <len(pq):
print('pq[{0}] = {1}'.format(i, pq[i]))
if (hasattr(pq[i], "__iter__")):
print(pq[i] ,'is iterable')
while j <len(pq[i]):
print('pq[{0}][{1}] = {2}'.format(i, j, pq[i]))
if (hasattr(pq[i][j], "__iter__")):
print(pq[i][j] ,'is iterable')
while k <len(pq[i][j]):
print('pq[{0}][{1}][{2}] = {3}'.format(i, j, k, pq[i][j][k]))
if (hasattr(pq[i][j][k], "__iter__")):
print(pq[i][j][k] ,'is iterable')
k= k + 1
j = j + 1
i= i + 1
Program Sonucu :
pq[0] = 12
pq[1] = 56
pq[2] = 38
pq[3] = (34, 27, (92, 77, 66))
(34, 27, (92, 77, 66)) is iterable
pq[3][0] = (34, 27, (92, 77, 66))
pq[3][1] = (34, 27, (92, 77, 66))
pq[3][2] = (34, 27, (92, 77, 66))
(92, 77, 66) is iterable
pq[3][2][0] = 92
pq[3][2][1] = 77
pq[3][2][2] = 66
pq[4] = 2
pq[5] = 7
Bu program, üç düzeyli bir topluluğun tüm elemanlarına erişebilmektdir. Üç düzeyli bir topluluk olduğu için, i, j, k olarak üç döngü değişkeni kullanılmıştır. İlk döngü değişkeni i, pq ile eşdüzey elemanları taramaktadır. Her elemanın bir koleksiyon olup olmadığı '__iter__' öntanımlı özelliğine sahip olup olmadığı kontrol edilmektedir. Eğer bu bir iterator (koleksiyon) (daha doğrusu, koleksiyon tipi bir veri sınıfının bir nesne örneği) ise, bunun iç elemanları taranmaktadır. değilse, bir sonraki elemana geçilmektedir.
Bu program, üç düzeyli koleksiyonlar için düzenlenmiş olmasına karşın, kolaylıkla iki ve tek düzeyli koleksiyonlara uyarlanabilecektir. Bu şekilde, tüm kolrksiyon tipi nesnelerin elemanlarına erişim için, evrensel bir program olma yeteneğindedir.
Python programlama dilinde, while döngüleri, koleksiyon tipi verilerin indis değerlerine ve elemanlarına eriim için temel döngü mekanizmasıdır. İkinci dögü mekanizması olan for in döngüleri de aynı erişmleri sağlayabilecek yatenektedir.
Python programlama dilinin for in döngüleri, Perl , JavaScript gibi temel dillerin for each döngülerinin replikasıdır. Bilinçli olarak kullanıldığında her türlü koleksiyon tipi verinin elemanlarına erişimi daha kullanışlı olarak sağlayabilir.
Python programlama dilinin for in döngülerinde, döngü değişkeni (konvansiyonel olarak i kullanılır, fakat her tanımlayıcı olabilir), her iterasyonda koleksiyonun elanlarının birinin değerini alır. Bu değerle her türlü işlem yapıldıktan sonra döngü bir sonraki elemana geçer ve koleksiyondaki tüm elemanlar tarandıktan donra döngü tamamlanır. Örnek,
myTuple = (4, 6 , 7, 18)
for i in myTuple:
print (i, " " , end ="")
Program Sonucu :
4 6 7 18
Bu tip döngülerde, erişlen eleman üzerinde her türlü manipülasyon (çeşitli karşılaştırmalar, hesaplamalar, diske yazma vb..yapılabilir. Görüldüğü gibi, yazılımı ve anlaşılması çok kolay, anlaşılablilir bir döngü mekanizmasıdır.
İki elemanları iki düzeye yayılmış koleksiyonlarda bu döngülerin kullanımı biraz dikkat gerektirir. Örnek,
qq = ((12,45, 67,), (88, 65, 44, 33), 36, 28)
x = 0
y = 0
for i in qq:
print('qq[{0}] = {1}'.format(x, i))
if (hasattr(i, "__iter__")):
print(i ,'is iterable')
for j in i:
print('qq[{0}][{1}] = {2}'.format(x, y, j))
y = y + 1
x = x + 1
Program Sonucu :
qq[0] = (12, 45, 67)
(12, 45, 67) is iterable
qq[0][0] = 12
qq[0][1] = 45
qq[0][2] = 67
qq[1] = (88, 65, 44, 33)
(88, 65, 44, 33) is iterable
qq[1][3] = 88
qq[1][4] = 65
qq[1][5] = 44
qq[1][6] = 33
qq[2] = 36
qq[3] = 28
Yukarıdaki program, iki boyutlu koleksiyonların, hem eleman indislerinin belirtildiği, hem de elemanlarına erişim sağlandığı evrensel bir programdır. Bu program ile, Python programlama dilinin for in döngülerinin nekadar kullanışlı kolay anlaşılır döngüler olduğunu görebiliyoruz.
Eğer, eleman indislerine değil, salt elemanlara gereksinme olacaksa, program daha da hafifleyecektir. Örnek:
qq = ((12,45, 67,), (88, 65, 44, 33), 36, 28)
for i in qq:
if (hasattr(i, "__iter__")):
for j in i:
print(j , '(Düzey 2)')
else:
print(i)
Program Sonucu :
12 (Düzey 2)
45 (Düzey 2)
67 (Düzey 2)
88 (Düzey 2)
65 (Düzey 2)
44 (Düzey 2)
33 (Düzey 2)
36
28
Salt iki düzeyde topluluklar içeren düzenli yapıda topluluklar için, Python programlama dilinin for in döngüleri, iki döngü değişkeni ile tüm elemanlara erişim olanağı sağlamıştır. Örnek:
tt = (('Selim Kazan' ,'Orkun Kunt'), ('Güler İyidoğan', 'Sevda Küreli'))
for i, j in tt:
print (i ,j)
Program Sonucu :
Selim Kazan Orkun Kunt
Güler İyidoğan Sevda Küreli
Programdan da görülebildiği gibi, çok kompakt ve kullanışlı bir kodlama olanağı sağlanmış.
Python programlama dilinde, for in döngülerinde, indis değerlerine erişimi kolaylaştırmak anmacı ile, öntanımlı enumerate () fonksiyonu uygulanabilir. Bu fonksiyon, tek boyutlu, iteratör içermeyen toplulukları, iki elemanlı topluklardan oluan iki boyutlu topluluklara dönüştürür. Örnek:
tpw = ( 12, 45, 67, 89)
print(*enumerate(tpw))
Program Sonucu :
(0, 12) (1, 45) (2, 67) (3, 89)
Program sonuçalrı yeni düzenlemeyi açıklamaktadır. Burada * saçılma işlemcisidir ve oluşan tüm elemanların gösterimini sağlamaktadır. Bunu birazdan inceleyeceğz. Her elamanın ilk iç elemanı indis değeri, ikinci elemanı ise, orijinal topluluğun elemanının değeridir. Bu yeni topluluğu iki döngü değişkeni ile bir for in döngüsü le tararsak, hem indis, hem de eleman değerlerine erişebiliriz. Örnek:
tpw = ( 12, 45, 67, 89)
for i, j in enumerate(tpw):
print(i, j)
Program Sonucu :
0 12
1 45
2 67
3 89
Çok kullanışlı ve yararlı bir yöntem, fakat uygulanan topluluğun veri yapısının uygun olması gerekir.
Değişke sayıda elemanı olabilen toplulukların tüm elemanlarının erişimi * işlemcisi ile sağlanır. Bu işlemci saçılma işlemcisidir vew bir topluğunun elemanlarının serbest değerler gibi hareket etmesini sağlar. Eğer, bir değer koleksiyonunuz varsa ve bunu bir fonksiyona argüman olarak sağlamak isterseniz * saçılma işlemcisi kullanarak sağlayabilirsiniz. Örnek olarak, aha önce incelediğimiz divmod (a,b ) öntanımlı fonksiyonu salt a ve b gibi iki sayısal argüman alır ve bölme sonucu ile kalanı geri döndürür. Bu fonksiyon aşağıda görüldüğü gibi, iki elemanlı bir topluluk, argüman olarak sağlanmaya çalışılırsa, hata verir. Çünkü iki iç elemanlı da olsa, tek elemanlı bir topluluğu, tek argüman olarak algılar ve tek argüman ile geriye bir sonuç döndüremeyeceğinden, bu argümanı kabul etmeyerek hata verir.
oran = (4, 2)
print('Sonuç = {0} Kalan : {1}'.format(divmod(oran)))
Program Sonucu :
TypeError Traceback (most recent call last)
<ipython-input-58-efb5c301269a> in <module>()
1 oran = (4, 2)
----> 2 print('Sonuç = {0} Kalan : {{1}'.format(divmod(oran)))
TypeError: divmod expected 2 arguments, got 1
Aynı fonksiyonu divmod(oran[0], oran[1]) şeklinde çağırırsak iki elemanlı bir topluluk geri döndürür. Bu topluğun ilk elemanı bölme sonucu, ikinci elemanı kalan değeridir. Bu sonuçlara erişim için aşağıdaki program uygulanabilir.
oran = (4, 2)
tx = divmod(oran[0], oran[1])[0]
ty = divmod(oran[0], oran[1])[1]
print('Bölme Sonucu = {0} Kalan = {1}' .format(tx, ty))
Program Sonucu :
Bölme Sonucu = 2 Kalan = 0
Oysa veriyi saçılım parametresi ile iki serbest değer olarak divmod() fonksiyonuna argüman olarak yerleştirirsek daha kolay olarak sonucu bulabiliriz.
oran = (4, 2)
print('Sonuç = {0} Kalan : {1}'.format(divmod(*oran)[0], divmod(*oran)[1]))
Program Sonucu :
Sonuç = 2 Kalan : 0
Öntanımlı sum() fonksiyonu sadece iki argüman kabul eder ve onların toplamını döndürür. Toplanma işlemcisi (saçılmanın tersi) kullanarak değişken sayıda argüman alıp hepsinin toplamını veren bir fonksiyon yazılması olanaklıdır. Örnek:
t = (7, 4, 6, 7)
def sumfor(*t):
sum =0
for i, j in enumerate(t):
sum = sum + j
print(i ,j)
return sum
print(sumfor(7, 4, 6, 7))
Program Sonucu :
0 7
1 4
2 6
3 7
24
Yukarıdaki programda, hem indisleri, hem verileri hem de toplamı görüntüleyebiliyoruz. Eğer salt toplamı görüntülemek istersek, program dahada hafifleyecektir.
def topla(*t):
sum =0
for i in t:
sum = sum + i
return sum
print('Toplama Sonucu = ',topla(7, 4, 6, 7))
Program Sonucu :
Toplama Sonucu = 24
İstendiğinde saçılmış bir topluluk ile de çağrılabilir. Örnek :
t = (7, 4, 6, 7)
def topla(*t):
sum =0
for i in t:
sum = sum + i
return sum
print('Toplama Sonucu = ',topla(*t))
Program Sonucu :
Toplama Sonucu = 24
Bu tür tanımlanmış bir fonksiyon sadece değişken sayıda sayılarla çalışabilir. Asında, herşey tanıma bağlıdır. Eğer formal parametresi sadece tek bir topluluk ile çalışacak şeklinde tanımlanırsa, bu sefer değişken sayıda sayısal veriyi bir topluklukta tanımlayıp bu topluluğu argüman olarak kullanarak fonksiyonu çağırmak gerekir.
toplam = (7, 4, 6, 7)
def topla(t):
sum =0
for i in t:
sum = sum + i
return sum
print('Toplama Sonucu = ',topla(topla))
Program Sonucu :
Toplama Sonucu = 24
Bu tanımla, fonksiyon bu sefer sadece bir tek topluluk tipinde argüman ile çağrılabilir.