1. Python’da Liste Tipi Değişkenler: Tuple
Liste tipi değişkenlerin ikincisi “tuple” değişkenleri parantezlerle “()” ifade edilir. Tuple değişkenlerinin elemanları aşağıda gösterildiği gibi virgül ile ayrılır.
myTuple = ("Volvo", "Opel", "Seat")
print(myTuple) #Sonuç: ('Volvo', 'Opel', 'Seat')
Tuple değişkenlerinin elemanları tekrar sıralanamaz ve değiştirilemez. Bununla birlikte bir tuple değişkeninde aynı elemandan birden fazla bulunabilir.
# Yorum satırlarını kademeli olarak kaldırınız ve hataları görmek için bölüm bazında çalıştırınız.
'''
#Bu bölümde hata göreceksiniz (sıralanamaz)
myTuple = ("Volvo", "Opel", "Seat")
myTuple.sort()
print(myTuple) #Sonuç: AttributeError: 'tuple' object has no attribute 'sort'
'''
'''
#Bu bölümde hata göreceksiniz (değiştirilemez)
myTuple = ("Volvo", "Opel", "Seat")
myTuple.remove("Opel")
print(myTuple) #Sonuç: AttributeError: 'tuple' object has no attribute 'remove'
'''
#Bir eleman tekrar edebilir
myTuple = ("Volvo", "Opel", "Seat", "Volvo")
print(myTuple) #Sonuç: ('Volvo', 'Opel', 'Seat', 'Volvo')
Bir tuple değişkeninin eleman sayısı “len” metodu ile elde edilebilir.
myTuple = ("Volvo", "Opel", "Seat")
print(len(myTuple)) #Sonuç: 3
Tek elemanlı bir tuple değişkeninde, elemandan sonra virgül olmalıdır. Aksi durumda Python onu bir tuple olarak algılamayacaktır.
myTuple = ("Volvo",)
print(type(myTuple)) #Sonuç: <class 'tuple'>
#Bu ise bir tuple değil
myTuple = ("Volvo")
print(type(myTuple)) #Sonuç: <class 'str'>
Bir tuple değişkeni birbirinden farklı tipte veriler içerebilir.
myTuple = ("Volvo", 2006, 1.6, True)
print(myTuple) #Sonuç: ('Volvo', 2006, 1.6, True)
Tuple değişkeni “tuple” metodu ile iç içe çift parantez kullanılarak da oluşturulabilir.
myTuple = tuple(("Volvo", 2006, 1.6, True))
print(myTuple) #Sonuç: ('Volvo', 2006, 1.6, True)
2. Python’da Tuple Elemanlarına Erişmek
Tuple değişkeninden herhangi bir elemana erişmek için indeks numaraları kullanılabilir.
myTuple = ("Volvo", 2006, 1.6, True)
print(myTuple[0]) #Sonuç: Volvo
print(myTuple[1]) #Sonuç:2006
print(myTuple[2]) #Sonuç:1.6
print(myTuple[3]) #Sonuç: True
Not: İndeks numaralarının list değişkenlerinde olduğu gibi köşeli parantez “[]” ile ifade edildiğine dikkat edin ve Python’da indeks numaralarının 0’dan başladığını göz önünde bulundurun.
Negatif indeks numaraları ile bir tuple değişkeninin elemanlarına sondan başa (sağdan sola) doğru erişilebilir.
myTuple = ("Volvo", 2006, 1.6, True)
print(myTuple[-1]) #Sonuç: True
print(myTuple[-2]) #Sonuç: 1.6
print(myTuple[-3]) #Sonuç: 2006
print(myTuple[-4]) #Sonuç: Volvo
Bir tuple değişkeninin birden fazla elemanına aşağıda gösterildiği gibi erişilebilir.
myTuple = ("Volvo", 2006, 1.6, True)
print(myTuple[1:3]) #Sonuç: (2006, 1.6)
myTuple = ("Volvo", 2006, 1.6, True)
print(myTuple[-4:-1]) #Sonuç: ('Volvo', 2006, 1.6)
Yukarıdaki örnekte [1:3] ifadesiyle, tuple değişkeninin birinci ve ikinci elemanlarına erişilir. İndeks aralığının ilk elemanı (örneğe göre 1 veya -4) erişilecek içeriğin indeks numarasına dahilken, son elemanı (örneğe göre 3 veya -1) erişilecek içeriğin indeks numarasına dahil değildir.
Belirli bir indeks aralığı yerine, belirli bir indeksten sonraki tüm elemanlara erişmek için aşağıdaki kodları inceleyebilirsiniz.
myTuple = ["Volvo", 2006, 1.6, True] print(myTuple[1:]) #Sonuç: [2006, 1.6, True] #[1:] indeks no.su 1'den sonraki (1 dahil) tüm elemanları çağırır myTuple = ["Volvo", 2006, 1.6, True] print(myTuple[:2]) #Sonuç: ['Volvo', 2006] #[:2] indeks no.su 2'den önceki (2 dahil değil) tüm elemanları çağırır
Bir tuple değişkeninin içine yuvalanmış başka bir tuple değişkeninin elemanlarına (veya iterable veri içeren bir elemanın karakterlerine) aşağıda gösterildiği gibi erişilebilir.
myNestedTuple = ("Volvo", (2006, 1.6, True)) #iç içe yuvalanmış iki tuple değişkeni olduğuna dikkat edin.
print(myNestedTuple[1][0]) #Sonuç: 2006
print(myNestedTuple[1][1]) #Sonuç: 1.6
print(myNestedTuple[1][2]) #Sonuç: True
print()
#iterable bir eleman olan Volvo ifadesinin karakterleri de aynı yöntemle elde edilebilir.
myNestedTuple = ("Volvo", (2006, 1.6, True))
print(myNestedTuple[0][0]) #Sonuç: V
print(myNestedTuple[0][1]) #Sonuç: o
print(myNestedTuple[0][3]) #Sonuç: v
“unpacking” olarak adlandırılan yöntemle, diğer bir ifadeyle tuple elemanlarının her birine değişken atayarak da aşağıda gösterildiği gibi tuple elemanlarına erişilebilir.
myTuple = ("Volvo", 2006, 1.6, True)
a,b,c,d = myTuple
print(a) #Sonuç: Volvo
print(b) #Sonuç: 2006
print(c) #Sonuç: 1.6
print(d) #Sonuç: True
print("__________\n")
"""
#Tuple elemanlarının sayısı ile unpack edecek değişken sayısı aynı olmadığı için hata alınacaktır.
myTuple = ("Volvo", 2006, 1.6, True)
a,b,c = myTuple #Sonuç: ValueError: too many values to unpack (expected 3)
print(a) #Sonuç:
print(b) #Sonuç:
print(c) #Sonuç:
"""
3. Python’da Bir Değeri Tuple Elemanları İçinde Kontrol Etmek
Bir değeri/elemanı tuple değişkeninin elemanları içinde bulunup bulunmadığını kontrol etmek için “if” koşulu ile birlikte “in” metodu kullanılabilir.
myTuple = ["Volvo", 2006, 1.6, True]
x = 1.6
if x in myTuple:
print("Evet,", x, "myTuple değişkeninin bir elemanıdır.") # Sonuç: Evet, 1.6 myTuple değişkeninin bir elemanıdır.
else:
print("Hayır,", x, "myTuple değişkeninin bir elemanı değildir.")
print("___________\n")
myTuple = ["Volvo", 2006, 1.6, True]
x = "Chevrolet"
if x in myTuple:
print("Evet,", x, "myTuple değişkeninin bir elemanıdır.")
else:
print("Hayır,", x, "myTuple değişkeninin bir elemanı değildir.") # Sonuç: Hayır, Chevrolet myTuple değişkeninin bir elemanı değildir.
4. Python’da Tuple Elemanlarını Değiştirmek
Daha önce bahsedildiği gibi bir tuple değişkeninin elemanı başka bir eleman ile değiştirilemez. Ancak aşağıda gösterildiği gibi tuple değişkeni önce list değişkenine çevrilir ve değişiklik yapıldıktan sonra list değişkeni tekrar tuple değişkenine dönüştürülür. Böylece dolaylı da olsa tuple nesnesinin elemanları değiştirilmiş olur.
myTuple = ("Volvo", 2006, 1.6, True)
myList = list(myTuple)
myList[2] = "Chevrolet"
myTuple = tuple(myList)
print("Bölüm 1:", myTuple) #Sonuç: ('Volvo', 2006, 'Chevrolet', True)
print("___________\n")
myTuple = ("Volvo", 2006, 1.6, True)
myList = list(myTuple)
myList[1:3] = ["Chevrolet", "Ford"] # myList'in 1. ve 2. elemanları değiştirilir
myTuple = tuple(myList)
print("Bölüm 2:", myTuple) #Sonuç: ('Volvo', 'Chevrolet', 'Ford', True)
print("___________\n")
myTuple = ("Volvo", 2006, 1.6, True)
myList = list(myTuple)
myList[2:3] = ["Chevrolet", "Ford"] # myList'in sadece 2. elemanı "Chevrolet" ve "Ford" elemanları ile değiştirilir. myList'in eleman sayısı 1 artar.
myTuple = tuple(myList)
print("Bölüm 3:", myTuple) #Sonuç: ('Volvo', 2006, 'Chevrolet', 'Ford', True)
print("___________\n")
myTuple = ("Volvo", 2006, 1.6, True)
myList = list(myTuple)
myList[2:4] = ["Chevrolet", "Ford"] # myList'in son elemanının indeksi 3'tür; aslında 4. indeksi yoktur. Ancak bu satırda myList'in 2. ve 3. elemanı değiştirilir.
#myList[2:10] = ["Chevrolet", "Ford"] #myList[2:4] 4 yerine, 10 yazılsa da sonuç değişmez; myList'in son elemanı da değiştirilir.
myTuple = tuple(myList)
print("Bölüm 4:", myTuple) #Sonuç: ('Volvo', 2006, 'Chevrolet', 'Ford')
print("___________\n")
myTuple = ("Volvo", 2006, 1.6, True)
myList = list(myTuple)
myList[1:4] = ["Chevrolet"] # myList'in sadece 1.elemanı yerine "Chevrolet" elemanı yazılır ve myList'in eleman sayısı 2 olur. Çünkü [1:4] aralığının karşılığında sadece "Chevrolet" elemanı var.
myTuple = tuple(myList)
print("Bölüm 5:", myTuple) #Sonuç: ('Volvo', 'Chevrolet')
5. Python’da Tuple Değişkenine Eleman Eklemek (insert, append metotları)
Bir tuple nesnesinin belirli bir pozisyonuna (elemanları arasına bir) eleman eklemek için aşağıda gösterildiği gibi “insert” metodu kullanılabilir. Tuple değişkenlerinde bu metodu kullanabilmek için tuple değişkeni öncelikle list değişkenine dönüştürülür ve söz konusu işlem yapılır. Sonra da list değişkeni tekrar tuple değişkenine dönüştürülür.
myTuple = ("Volvo", 2006, 1.6, True)
myList = list(myTuple)
myList.insert(0, "Mercedes") # 0. indekse eklenecek.
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Mercedes', 'Volvo', 2006, 1.6, True)
myTuple = ("Volvo", 2006, 1.6, True)
myList = list(myTuple)
myList.insert(2, "Mercedes") # 2. indekse eklenecek.
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Volvo', 2006, 'Mercedes', 1.6, True)
Bir tuple nesnesinin sonuna eleman eklemek için aşağıda gösterildiği gibi “append” metodu kullanılabilir. “append” metodu “insert” metodundan farklı olarak pozisyon parametresine sahip değildir ve tuple nesnesinin daima sonuna eleman ekler. Ancak önce yukarıdaki dönüştürme işlemi yapılmalıdır.
myTuple = ("Volvo", 2006, 1.6, True)
myList = list(myTuple)
myList.append("Mercedes") # Son indekse eklenecek.
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Volvo', 2006, 1.6, True, 'Mercedes')
#Bir eleman yerine bir tuple'in kendisi de eklenebilir.
myTuple = ("Volvo", 2006, 1.6, True)
myList = list(myTuple)
myList.append(("Mercedes", "Toyota", "Nissan")) # Son indekse eklenecek.
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Volvo', 2006, 1.6, True, ('Mercedes', 'Toyota', 'Nissan')) # ('Mercedes', 'Toyota', 'Nissan') tuple'ının elemanlarının değil kendisinin eklendiğine dikkat edin.
Bir tuple’ın içine tek veya çok elemanlı başka bir tuple değerini aşağıda gösterildiği gibi dönüştürmeden ekleyebilirsiniz.
#Tuple'ın içine başka bir tuple değerini dönüştürmeden ekleyebilirsiniz. (tek eleman)
myTuple = ("Volvo", 2006, 1.6, True)
y = ("Mercedes",) #Tek elemanlı tuple değişkeninde virgül olması gerektiğini hatırlayın.
myTuple += y # Son indeksten itibaren eklenecek.
print(myTuple) #Sonuç: ('Volvo', 2006, 1.6, True, 'Mercedes')
#Tuple'ın içine başka bir tuple değerini dönüştürmeden ekleyebilirsiniz. (iki eleman)
myTuple = ("Volvo", 2006, 1.6, True)
y = ("Mercedes","Ford")
myTuple += y # Son indeksten itibaren eklenecek.
print(myTuple) #Sonuç: ('Volvo', 2006, 1.6, True, 'Mercedes', 'Ford')
6. Python’da Tuple Elemanlarını Silmek (remove, pop, clear metotları)
Bir tuple değişkeninden belirli bir elemanı kaldırmak/silmek için aşağıda gösterildiği gibi dönüştürme işleminden sonra “remove” metodu kullanılabilir.
myTuple = ("Volvo", 2006, "Volvo", 1.6, 2006, True)
myList = list(myTuple)
myList.remove(2006) # List değişkenindeki (soldan sağa doğru) ilk "2006" elemanını siler.
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Volvo', 'Volvo', 1.6, 2006, True)
Bir tuple değişkeninden belirli bir pozisyondaki elemanı kaldırmak/silmek ya da silinen elemanın değerini bir değişkende tutmak için aşağıda gösterildiği gibi dönüştürme işleminden sonra “pop” metodu kullanılabilir.
myTuple = ("Volvo", 2006, "Volvo", 1.6, 2006, True)
myList = list(myTuple)
myList.pop(4) # List değişkeninde 4. indekste yer alan "2006" elemanını siler.
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Volvo', 2006, 'Volvo', 1.6, True)
#pop() şeklinde indeks no kullanılmaz ise son eleman silinir.
myTuple = ("Volvo", 2006, "Volvo", 1.6, 2006, True)
myList = list(myTuple)
myList.pop() # List değişkeninde son indekste yer alan "True" elemanını siler.
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Volvo', 2006, 'Volvo', 1.6, 2006)
#Silinen elemanın değerini bir değişkende saklamak için pop metodu şu şekilde kullanılabilir.
myTuple = ("Volvo", 2006, "Volvo", 1.6, 2006, True)
myList = list(myTuple)
x = myList.pop(4) # List değişkeninde son indekste yer alan silinen ("2006") değeri gösterir.
myTuple = tuple(myList)
print(x) #Sonuç: 2006
print(myTuple) #Sonuç: ('Volvo', 2006, 'Volvo', 1.6, True)
Bir tuple değişkeninin (değişkenin kendisini değil) tüm elemanlarını silmek için aşağıda gösterildiği gibi dönüştürme işleminden sonra “clear” metodu kullanılabilir.
myTuple = ("Volvo", 2006, "Volvo", 1.6, 2006, True)
myList = list(myTuple)
myList.clear() #Sadece tüm elemanlar silinecek; değişkenin kendisi silinmeyecek
myTuple = tuple(myList)
print(myTuple) #Sonuç: ()
#myTuple değişkeninin tümüyle silinip silinmediğinin kontrolü.
try: myTuple
except NameError: myTuple = None
if myTuple is None:
print("Mytuple değişkeni artık yok.")
else:
print("Mytuple değişkeni var.") #Sonuç: Mytuple değişkeni var.
7. Python’da Tuple Değişkeninin Kendisini Silmek (del metodu)
Bir tuple değişkeninden belirli bir pozisyondaki elemanı kaldırmak/silmek ya da değişkenin tüm elemanları ile birlikte kendisini de silmek için aşağıda gösterildiği gibi dönüştürme işleminden sonra “del” metodu kullanılabilir.
myTuple = ["Volvo", 2006, "Volvo", 1.6, 2006, True]
del myTuple[1] #1. indeks no.'ya sahip eleman silinecek.
print(myTuple) #Sonuç: ['Volvo', 'Volvo', 1.6, 2006, True]
#myTuple değişkenini tümüyle silmek; sadece elemanlarının tümünü değil kendisini de silmek.
myTuple = ["Volvo", 2006, "Volvo", 1.6, 2006, True]
del myTuple
#myTuple değişkeninin tümüyle silinip silinmediğinin kontrolü.
try: myTuple
except NameError: myTuple = None
if myTuple is None:
print("Mytuple değişkeni artık yok.") #Sonuç: Mytuple değişkeni artık yok.
else:
print("Mytuple değişkeni var.")
8. Python’da Tuple Elemanlarına Döngülerle Erişmek (for, while döngüleri ile unpacking ve * yaklaşımı)
Bir tuple değişkeninin elamanlarına döngülerle erişmek için aşağıda gösterildiği gibi “for” döngüsü “in” metodu ile birlikte kullanılabilir.
myTuple = ("Volvo", 2006, 1.6, True)
for x in myTuple:
print(x)
#Sonuç:
#Volvo
#2006
#1.6
#True
Esasen bu yöntem yukarıda da değinilen “unpacking” işleminden başka bir şey değildir.
Eğer sonuçları alt alta değil de yan yana yazdırmak istersek, print metodunun end parametresinden yararlanabiliriz.
myTuple = ("Volvo", 2006, 1.6, True)
for x in myTuple:
print(x, end=" ")
#Sonuç: Volvo 2006 1.6 True
Yukarıdaki yöntemi “range” ve “len” metodu ile birlikte indeks numaralarını da kullanarak aşağıda gösterildiği gibi özelleştirebilirsiniz.
myTuple = ("Volvo", 2006, 1.6, True)
for x in range(len(myTuple)):
print(myTuple[x])
#Sonuç:
#Volvo
#2006
#1.6
#True
Bir önceki yöntemde “x” değişkenleri tuple’ın elemanlarını taşırken, yukarıdaki yöntemde tuple’ın indeks numaralarını taşımaktadır. Sonuçlar incelendiğinde ise yukarıdaki yöntemin bir önceki yöntemle aynı sonuçları sahip olduğu kolaylıkla fark edilebilir. Ancak tuple değişkeninin sadece ilk iki elemanı ya da sadece son iki elemanı tuple dışına çıkartılmak istenseydi, bir önceki yöntem kullanışsız, yukarıdaki yöntem ise oldukça kullanışlı olurdu.
#İlk iki değer için
myTuple = ["Volvo", 2006, 1.6, True]
for x in range(2):
print(myTuple[x])
#Sonuç:
#Volvo
#2006
print("___________\n")
#Son iki değer için
myTuple = ["Volvo", 2006, 1.6, True]
for x in range(len(myTuple)-2, len(myTuple)): #range(len(myTuple)-2, len(myTuple)) ifadesinin örnek özelinde range(2,4)'e eşit olduğuna dikkat edin.
print(myTuple[x])
#Sonuç:
#1.6
#True
Yukarıdaki sonuçlara “for” döngüsü yerine “while” döngüsü kullanılarak da aşağıda gösterildiği gibi ulaşılabilir.
#Tüm değerler için
myTuple = ["Volvo", 2006, 1.6, True]
x = 0
while x < len(myTuple): #x'in döngüye girmeden önceki ilk değeri 0. döngüye girdikten sonraki ilk değeri 1, döngüye girdikten sonraki ikinci değeri 2...
print(myTuple[x]) #Elemanlar indeks numaraları ile çıkartılıyor
x = x + 1
#Sonuç:
#Volvo
#2006
#1.6
#True
print("___________\n")
#İlk iki değer için
myTuple = ["Volvo", 2006, 1.6, True]
x = 0
#x'in döngüye girmeden önceki ilk değeri 0. döngüye girdikten sonraki ilk değeri 1, döngüye girdikten sonraki ikinci değeri 2.
#Ancak x = 2 için döngü sonlanıyor. Çünkü x < 2 koşulu döngüye giriş koşuludur.
while x < 2:
print(myTuple[x]) #elemanlar indeks numaraları ile çıkartılıyor
x = x + 1
#Sonuç:
#Volvo
#2006
print("___________\n")
#Son iki değer için
myTuple = ["Volvo", 2006, 1.6, True]
x = len(myTuple)-1 # myTuple 4 elemanlıdır. Son (4.) elemanın indeks no.su 3 olduğu için x = len(myTuple)-1 oldu.
while x >= 2: # x, 2'ye eşit veya büyük ise döngü içine girilecek, değilse döngü sonlanacak.
print(myTuple[x]) #Elemanlar indeks numaraları ile çıkartılıyor
x = x - 1 # myTuple elemanları içinde sondan başa doğru ilerlendiği için x değeri her döngüde 1 azaltıldı.
#Sonuç:
#True
#1.6
“unpacking” yöntemini kullanarak da bir tuple’ın elemanlarını aşağıda gösterildiği gibi tuple dışına çıkartabilirsiniz.
myTuple = ("Volvo", 2006, 1.6, True)
(x, a, y, ishak) = myTuple # x, a, y, ishak gibi string değerler kullanabilirsiniz. Ancak sayı kullanırsanız "SyntaxError: cannot assign to literal" hatasını alırsınız.
print(x) #Sonuç: Volvo
print(a) #Sonuç: 2006
print(y) #Sonuç: 1.6
print(ishak) #Sonuç: True
“unpacking” yönteminde değişkenin soluna “*” işareti ilave edilirse, “*” işaretli olan değişkenle çıkartılan tuple elemanları aşağıda gösterildiği gibi tuple dışına list olarak çıkartılır.
myTuple = ("Volvo","Toyota", "Mercedes", "Ford", "Peugeot")
(a, b, *c) = myTuple
print(a) #Sonuç: Volvo
print(b) #Sonuç: Toyota
print(c) #Sonuç: ['Mercedes', 'Ford', 'Peugeot']
print("___________\n")
myTuple = ("Volvo","Toyota", "Mercedes", "Ford", "Peugeot")
(a, *b, c) = myTuple
print(a) #Sonuç: Volvo
print(b) #Sonuç: ['Toyota', 'Mercedes', 'Ford']
print(c) #Sonuç: Peugeot
print("___________\n")
myTuple = ("Volvo","Toyota", "Mercedes", "Ford", "Peugeot")
(*a, b, c) = myTuple
print(a) #Sonuç: ['Volvo', 'Toyota', 'Mercedes']
print(b) #Sonuç: Ford
print(c) #Sonuç: Peugeot
9. Python’da Tuple Değişkenleri İçin Döngü Sentaksını Sadeleştirmek (for döngüsü)
Tuple değişkenlerinde aşağıda gösterildiği gibi döngü sentaksları kısaltılabilir.
#Bu döngüyü aşağıdaki şekilde kısaltabiliriz
#myTuple = ("Volvo", 2006, 1.6, True)
#for x in myTuple:
# print(x)
#Kısaltılmış form
myTuple = ("Volvo", 2006, 1.6, True)
[print(x) for x in myTuple] #prin(x) metodunu başa al, myTuple sonundaki iki noktayı kaldır ve satırın tümünü tuple köşeli parantezi içinde belirt.
#Sonuç:
#Volvo
#2006
#1.6
#True
“myTuple” değişkenini kullanarak içinde sadece “e” harfi olanlardan ve içinde “e” harfi olmayanlardan yeni bir tuple değişkeni oluşturmak için kullanılan (normal ve kısa formda olan) döngülerin sentakslarını aşağıda inceleyebilirsiniz.
myTuple = ("Volvo","Toyota", "Mercedes", "Ford", "Peugeot")
newList = []
for x in myTuple:#myTuple elemanlarını dolaş
if "e" in x: #İçinde "e" karakteri olan myTuple elemanlarını newList'e ekle.
newList.append(x)
newTuple = tuple(newList)
print(newTuple)
#Sonuç: ('Mercedes', 'Peugeot')
#Yukarıdaki döngünün kısa formu
myTuple = ("Volvo","Toyota", "Mercedes", "Ford", "Peugeot")
newList = [x for x in myTuple if "e" in x]
newTuple = tuple(newList)
print(newTuple)
#Sonuç: ('Mercedes', 'Peugeot')
#İçinde "e" karakteri olmayan myTuple elemanlarını newList'e ekle.
myTuple = ("Volvo","Toyota", "Mercedes", "Ford", "Peugeot")
newList = [x for x in myTuple if "e" not in x]
newTuple = tuple(newList)
print(newTuple)
#Sonuç: ('Volvo', 'Toyota', 'Ford')
Kısa sentaks ile oluşturulan tuple değişkenlerinin “for” döngüsü ile alternatif kullanımları için aşağıdaki kodları inceleyebilirsiniz.
#myTuple değişkeni elemanlarından yeni bir tuple değişkeni oluştur
myTuple = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"]
newTuple = [x for x in myTuple]
print(newTuple) #Sonuç: ['Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot']
print("___________1\n")
#myTuple değişkeni elemanlarından son ikisinden yeni bir tuple değişkeni oluştur
myTuple = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"]
newTuple = [myTuple[x] for x in range(len(myTuple)-2, len(myTuple))]
print(newTuple) #Sonuç: ['Ford', 'Peugeot']
print("___________2\n")
#myTuple değişkeninde "Toyota" elemanına eşit olmayan tüm elemanlardan yeni bir tuple değişkeni oluştur
myTuple = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"]
newTuple = [x for x in myTuple if x != "Toyota"]
print(newTuple) #Sonuç: ['Volvo', 'Mercedes', 'Ford', 'Peugeot']
print("___________3\n")
#myTuple değişkeninde "Mercedes" elemanına eşit olmayan tüm elemanlardan yeni bir tuple değişkeni oluştur; Mercedes elemanı yerine ise newTuple'e "Audi" elemanı ekle
myTuple = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"]
newTuple = [x if x != "Mercedes" else "Audi" for x in myTuple]
print(newTuple) #Sonuç: ['Volvo', 'Toyota', 'Audi', 'Ford', 'Peugeot']
print("___________4\n")
#myTuple değişkeni eleman sayısına eşit ve tüm elemanları 1'den oluşan yeni bir tuple oluştur.
myTuple = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"]
newTuple = [1 for x in myTuple]
print(newTuple) #Sonuç: [1, 1, 1, 1, 1]
10. Python’da Tuple Değişkenlerini Kopyalamak (copy, list metotları)
Tuple değişkenleri yukarıdaki döngü yöntemleriyle özelleştirilmiş şekillerde çoğaltılabileceği gibi “copy” ve “list” metotları kullanılarak da çoğaltılabilir.
#copy metodu
myTuple = ("Volvo","Toyota", "Mercedes", "Ford", "Peugeot")
myList = list(myTuple) #list'e dönüştür
newList = myList.copy() #kopyala
newTuple = tuple(newList) #tuple'a dönüştür
print(newTuple) #Sonuç: ('Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot')
#list metodu
myTuple = ("Volvo","Toyota", "Mercedes", "Ford", "Peugeot")
myList = list(myTuple) #list'e dönüştür
newList = list(myList) #kopyala
newTuple = tuple(newList) #tuple'a dönüştür
print(newTuple) #Sonuç: ('Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot')
11. Python’da Tuple Değişkenlerini Birleştirmek (+ operatörü ile append, extend, join metotları)
Tuple değişkenleri yukarıdaki döngü yöntemleriyle özelleştirilmiş şekillerde birleştirilebileceği gibi “+” operatörü ile “append” ve “extend” metotları kullanılarak da birleştirilebilir.
#+ operatörü
myTuple1 = ("Volvo","Toyota", "Mercedes", "Ford", "Peugeot")
myTuple2 = ("Honda","Fiat", "Renault", "Seat", "Skoda")
newTuple = myTuple1 + myTuple2
print(newTuple) #Sonuç: ('Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot', 'Honda', 'Fiat', 'Renault', 'Seat', 'Skoda')
print("___________1\n")
#append metodu
myTuple1 = ("Volvo","Toyota", "Mercedes", "Ford", "Peugeot")
myTuple2 = ("Honda","Fiat", "Renault", "Seat", "Skoda")
myList1 = list(myTuple1) #list'e dönüştür
for x in myTuple2:
myList1.append(x)
myTuple1 = tuple(myList1) #tuple'a dönüştür
print(myTuple1) #Sonuç: ('Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot', 'Honda', 'Fiat', 'Renault', 'Seat', 'Skoda')
print("___________1\n")
myTuple1 = ("Volvo","Toyota", "Mercedes", "Ford", "Peugeot")
myTuple2 = myTuple1 * 2
print(myTuple2) #Sonuç: ('Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot', 'Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot')
Farklı tuple’ların elemanlarını birleştirmek ya da bir tuple’a diğer tuple’ın tüm elemanlarını eklemek için “extend” metodunu kullanabilirsiniz.
myTuple = ("Volvo", 2006, 1.6, True)
myList = list(myTuple)
myList.extend(("Mercedes", "Toyota", "Nissan")) # Son indeksten itibaren eklenecek.
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Volvo', 2006, 1.6, True, 'Mercedes', 'Toyota', 'Nissan') #tuple olarak eklenmediğine, sadece elemanların eklendiğine dikkat edin.
#Aynı işlemi şu şekilde de yapabiliriz.
myTuple = ("Volvo", 2006, 1.6, True)
myList = list(myTuple)
x = ("Mercedes", "Toyota", "Nissan")
myList.extend(x) # Son indeksten itibaren eklenecek.
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Volvo', 2006, 1.6, True, 'Mercedes', 'Toyota', 'Nissan') #tuple olarak eklenmediğine, sadece elemanların eklendiğine dikkat edin.
print("___________1\n")
#extend metodu
myTuple1 = ("Volvo","Toyota", "Mercedes", "Ford", "Peugeot")
myTuple2 = ("Honda","Fiat", "Renault", "Seat", "Skoda")
myList1 = list(myTuple1) #list'e dönüştür
myList1.extend(myTuple2)
myTuple1 = tuple(myList1) #tuple'a dönüştür
print(myTuple1) #Sonuç: ('Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot', 'Honda', 'Fiat', 'Renault', 'Seat', 'Skoda')
“list”, “tuple”, “set”, “dictionary” gibi farklı liste tipi değişkenin elemanlarını birleştirmek için de “extend” metodunu kullanabilirsiniz.
myTuple = ("Volvo", 2006, 1.6, True)
myList = list(myTuple)
myAddList = ["Mercedes", "Toyota", "Nissan"] # köşeli parantezlerle ifade edilen liste tipi değişkenler list'tir. Daha önce ayrıntılı açıklanmıştı.
myList.extend(myAddList) # Son indeksten itibaren eklenecek.
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Volvo', 2006, 1.6, True, 'Mercedes', 'Toyota', 'Nissan')
Tuple elemanlarını “join” metoduyla aşağıda gösterildiği gibi string bir değerde özelleştirilmiş biçimde birleştirebilirsiniz.
myTuple = ('P', 'y', 't', 'h', 'o', 'n')
myStr = "".join(myTuple)
print(myStr) #Sonuç: Python
myStr = "-".join(myTuple)
print(myStr) #Sonuç: P-y-t-h-o-n
myStr = ",".join(myTuple)
print(myStr) #Sonuç: P,y,t,h,o,n
12. Python’da Tuple Değişkeninin Tekrarlayan Elemanlarını Saymak (count metodu)
Bir elemanın tuple değişkeni içinde tekrar sayısını elde etmek için “count” metodunu aşağıda gösterildiği gibi dönüştürme yapmadan doğrudan kullanabilirsiniz.
myTuple = ('Volvo', 'Toyota', 'Mercedes', 'Volvo', 'Peugeot', 'Honda', 'Fiat', 'Volvo', 'Seat', 'Skoda')
x = myTuple.count("Volvo") #myTuple içinde Volvo elemanlarını sayar.
print(x) #Sonuç: 3
13. Python’da Tuple Elemanlarının İndeks Numarasını Elde Etmek (index metodu)
Bir elemanın list değişkeni içinde indeks numarasını elde etmek için “index” metodunu aşağıda gösterildiği gibi dönüştürme yapmadan doğrudan kullanabilirsiniz.
myTuple = ('Volvo', 'Toyota', 'Mercedes', 'Volvo', 'Peugeot', 'Honda', 'Fiat', 'Volvo', 'Seat', 'Skoda')
x = myTuple.index("Peugeot")
print(x) #Sonuç: 4")
14. Python’da Tuple Elemanlarını Sıralamak (sort, reverse metotları)
Tuple değişkeninin elemanlarını sıralamak için “sort” ve “reverse” metotlarını aşağıda gösterildiği gibi kullanabilirsiniz.
# Z'den A'ya sırala
myTuple = ('Volvo', 'Toyota', 'Mercedes', 'Volvo', 'Peugeot', 'Honda', 'Fiat', 'Volvo', 'Seat', 'Skoda')
myList = list(myTuple)
myList.sort(reverse=True)
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Volvo', 'Volvo', 'Volvo', 'Toyota', 'Skoda', 'Seat', 'Peugeot', 'Mercedes', 'Honda', 'Fiat')
print("___________1\n")
# A'dan Z'ye sırala
myTuple = ('Volvo', 'Toyota', 'Mercedes', 'Volvo', 'Peugeot', 'Honda', 'Fiat', 'Volvo', 'Seat', 'Skoda')
myList = list(myTuple)
myList.sort(reverse=False)
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Fiat', 'Honda', 'Mercedes', 'Peugeot', 'Seat', 'Skoda', 'Toyota', 'Volvo', 'Volvo', 'Volvo')
Tuple elemanlarını sondaki başta, baştakini ise sonda olacak şekilde devrik olarak sıralamak için aşağıdaki örneği inceleyebilirsiniz.
#Sondaki eleman ilk sırada, baştaki eleman son sırada olacak şekilde elemanları tersten sıralar.
myTuple = ('Volvo', 'Toyota', 'Mercedes', 'Volvo', 'Peugeot', 'Honda', 'Fiat', 'Volvo', 'Seat', 'Skoda')
myList = list(myTuple)
myList.reverse()
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Skoda', 'Seat', 'Volvo', 'Fiat', 'Honda', 'Peugeot', 'Volvo', 'Mercedes', 'Toyota', 'Volvo')
Elemanları karakter uzunluğuna göre sıralamak için aşağıdaki örneği inceleyebilirsiniz.
#Fonksiyon myTuple elemanlarının karakter uzunluğunu tespit ediyor.
def myFunc(expand_variable): #expand_variable yerine dilediğiniz bir notasyonu kullanabilirsiniz. Sonuç değişmeyecektir.
return len(expand_variable)
#Elemanların karakter uzunluğuna göre sırala
myTuple = ('Volvo', 'Toyota', 'Mercedes', 'Volvo', 'Peugeot', 'Honda', 'Fiat', 'Volvo', 'Seat', 'Skoda')
myList = list(myTuple)
myList.sort(reverse=False, key=myFunc) #myFunc fonksiyonunda belirtilen kritere göre sıralama yapacaktır. Yani karakter uzunluğu en az olandan en fazla olana doğru sıralama yapar.
myTuple = tuple(myList)
print(myTuple) #Sonuç: ('Fiat', 'Seat', 'Volvo', 'Volvo', 'Honda', 'Volvo', 'Skoda', 'Toyota', 'Peugeot', 'Mercedes')
15. Python’da Tuple Elemanlarının Toplamı (sum metodu)
List elemanlarının toplamında olduğu gibi tuple elemanlarının toplamı “sum” metodu kullanılarak aşağıda gösterildiği gibi hesaplanabilir.
myTuple = (1,3,5,7,2,4,6,8)
#myTuple toplamını hesapla
mySum = sum(myTuple)
print(mySum) #Sonuç: 36
#100'ün üzerine myTuple toplamını ilave et.
mySum = sum(myTuple, 100)
print(mySum) #Sonuç: 136
print("__________\n")
myTuple = (1,3,5,7,2,4,6,8)
mySum = sum(myTuple)
myAverage= mySum/len(myTuple) #toplamın eleman sayısını bölümü ortalamayı verecektir.
print (myAverage) #Sonuç: 4.5
16. Python’da Tuple Elemanlarının Maksimum ve Minimum Değerleri (max, min metotları)
Tuple elemanları sayısal ifadeler ise aşağıda gösterildiği gibi “max” metodu en büyük değere sahip elemanı, “min” metodu ise en küçük değere sahip elemanı verecektir.
myTuple = (1,3,5,7,2,4,6,8) maxVal = max(myTuple) # En büyük değere sahip elemanı verir. print(maxVal) #Sonuç: 8 myTuple = (1,3,5,7,2,4,6,8) minVal = min(myTuple) # En küçük değere sahip elemanı verir. print(minVal) #Sonuç: 1
Tuple elemanları sayısal değerlerden oluşmuyorsa aşağıda gösterildiği gibi “max” metodu alfabetik sıraya göre Z’den A’ya doğru ilk list elemanını, “min” metodu ise A’dan Z’ye doğru ilk list elemanını verecektir.
myTuple = ('Volvo', "Mercedes", "Ford", "Volkswagen")
maxVal = max(myTuple) #Alfabetik sıraya göre Z'den A'ya doğru ilk list elemanını verir.
print(maxVal) #Sonuç: Volvo
myTuple = ('Volvo', "Mercedes", "Ford", "Volkswagen")
minVal = min(myTuple) #Alfabetik sıraya göre A'dan Z'ye doğru ilk list elemanını verir.
print(minVal) #Sonuç: Ford
Ayrıca tuple elemanlarının karakter uzunluğuna göre en fazla ya da en az karakter içeren elemanlarını elde etmek için aşağıdaki komutları inceleyebilirsiniz.
myTuple = ('Volvo', "Mercedes", "Ford", "Volkswagen")
maxChar = max(myTuple, key=len) # En fazla karaktere sahip elemanı verir.
print(maxChar) #Sonuç: Volkswagen
myList = ('Volvo', "Mercedes", "Ford", "Volkswagen")
minChar = min(myTuple, key=len) # En az karaktere sahip elemanı verir.
print(minChar) #Sonuç: Ford
17. Python’da Tuple Elemanlarını Numaralandırmak (enumerate metodu)
Tuple elemanları (iterable string ifadedeler) “enumerate” metodu ile aşağıda gösterildiği gibi indekslenebilir.
myTuple = ('Volvo', "Mercedes", "Ford", "Volkswagen")
myStr = "Volvo"
#Elemanları 0-Volvo, 1-Mercedes gibi indekslemek istiyoruz. (Ya da string için 0-V, 1-o, 2-l vb. şeklinde indekslemek)
print (tuple(enumerate(myTuple))) #Sonuç: ((0, 'Volvo'), (1, 'Mercedes'), (2, 'Ford'), (3, 'Volkswagen'))
print (tuple(enumerate(myStr))) #Sonuç: ((0, 'V'), (1, 'o'), (2, 'l'), (3, 'v'), (4, 'o'))
print("__________\n")
#İndeks numaralarını ve elemanları alt alta yazdırabilirsiniz.
#myTuple için
for myIndx, myElem in enumerate(myTuple):
print("Indeks: ", myIndx, "----" + "Karakter: ", myElem)
#Sonuç:
"""
Indeks: 0 ----Karakter: Volvo
Indeks: 1 ----Karakter: Mercedes
Indeks: 2 ----Karakter: Ford
Indeks: 3 ----Karakter: Volkswagen
"""
print("__________\n")
#myStr için
for myIndx, myChar in enumerate(myStr):
print("Indeks: ", myIndx, "----" + "Karakter: ", myChar)
#Sonuç:
"""
Indeks: 0 ----Karakter: V
Indeks: 1 ----Karakter: o
Indeks: 2 ----Karakter: l
Indeks: 3 ----Karakter: v
Indeks: 4 ----Karakter: o
"""
print("__________\n")
#İndeks numarasını belirli bir değerden başlatabilirsiniz.
myTuple = ('Volvo', "Mercedes", "Ford", "Volkswagen")
for myIndx, myElem in enumerate(myTuple, 20):
print("Indeks: ", myIndx, "----" + "Karakter: ", myElem)
#Sonuç:
"""
Indeks: 20 ----Karakter: Volvo
Indeks: 21 ----Karakter: Mercedes
Indeks: 22 ----Karakter: Ford
Indeks: 23 ----Karakter: Volkswagen
"""
18. Python’da Tuple Elemanı Olarak Mantıksal Değişkenler (any, all metotları)
List değişkenlerinde olduğu gibi tuple değişkenlerinde de “any” metodu list elemanlarından en az birinin true olması durumunda true, diğer durumlarda ise false değer döndürür. “all” metodu list elemanlarının tümünün true olması durumunda true, diğer durumlarda ise false değerini döndürür.
# any methodu, bir değer kümesinin en az bir elamanı true ise true,
# tüm elemanları false ise false değeri döndürür.
#Tüm değerler false olduğu için x değişkeni false değerini alır.
x = any((False, False, False, False))
print(x) #Sonuç: False
#En az bir değer true olduğu için x değişkeni true değerini alır.
x = any((False, True, False, False))
print(x) #Sonuç: True
#En az bir değer true olduğu için x değişkeni true değerini alır.
x = any((True, False, False, False))
print(x) #Sonuç: True
print("__________\n")
# all methodu, bir değer kümesinin tüm elamanları true ise true,
# diğer durumlarda ise false değeri döndürür.
#Tüm değerler true olduğu için x değişkeni true değerini alır.
x = all((True, True, True, True))
print(x) #Sonuç: True
#Tüm değerler true olmadığı için x değişkeni false değerini alır.
x = all((False, True, True, False))
print(x) #Sonuç: False
#Tüm değerler false olduğu (tüm değerler true olmadığı) için x değişkeni false değerini alır.
x = all((False, False, False))
print(x) #Sonuç: False
19. Python’da List ve Tuple Değişkenlerinin Karşılaştırılması
List ve tuple değişkenlerinin ortak yanları aşağıda özetlenmiştir.
- Her ikisi de veri koleksiyonu içerebilen (iterable) nesnelerdir.
- Her ikisi de farklı veri tipleri içerebilir.
- Her ikisinin elemanlarına da indeks numaraları ile erişilebilir.
List ve tuple değişkenlerinin farklı yanları aşağıda özetlenmiştir.
- List değişkenlerine eleman eklenebilirken tuple değişkenlerine eklenemez.
- List değişkenlerinin elemanları silinebilirken tuple değişkenlerinin elemanları silinemez.
- Kısacası list değişkenlerinin elemanları değiştirilebilirken (mutable) tuple değişkenlerinin elamanları değiştirilemez (immutable).
- List değişkenlerinin elamanları sıralanabilirken tuple değişkenlerinin elemanları sıralanamaz.
List değişkenleri uygulamada daha çok homojen veri tiplerinde, tuple değişkenleri heterojen veri tiplerinde kullanılır. Tuple nesnelerinin elemanları arasındaki dolaşım (iteration) hızı (elemanlara erişim hızı olarak da düşünülebilir), list nesnelerine göre daha yüksektir. Çünkü tuple değişkenleri immutable olmaları sebebiyle hafızada daha az yer kaplar. Benzer şekilde immutable olan tuple nesneleri, salt okunur (read-only) veri yapıları inşa etmek için daha elverişlidir.
Not: Makalede list metotlarının birçoğu tuple değişkenleri için kullanılırken, tuple nesnelerinin önce list nesnesine dönüştürüldüğüne dikkat edin. List sınıfının add, remove, del, sort vb. eleman değişikliğine/güncellenmesine yol açan metotları tuple nesnelerine doğrudan uygulanamaz.
İshak Kutlu, Veri Bilimi İçin Python Notları
