1. Python’da Liste Tipi Değişkenler: List
Python’da list değişkenini incelemeye başlamadan önce kısaca liste tipi değişkenlerden bahsetmek gerekirse, list, tuple, set ve dictionary olmak üzere 4 farklı liste tipi değişken vardır.
- list
- tuple
- set
- dictionary
Tek bir liste tipi değişken içinde çok sayıda veri tutulabilir. Bir tür veri koleksiyonları olarak değerlendirilebileceği gibi matematikteki kümeler gibi de düşünülebilir. Liste tipi değişkenlerin (Python sürümlerine göre değişebilmekle birlikte) temel farkları aşağıda özetlenmiştir.
- list: elemanlar sıralanabilir, değiştirilebilir, tekrar edebilir,
- tuple: elemanlar sıralanamaz, değiştirilemez, tekrar edebilir,
- set: elemanlar sıralanamaz, (eleman ekleme ve kaldırma hariç) değiştirilemez, tekrar edemez, indekslenemez,
- dictionary: sıralanabilir, değiştirilebilir, tekrar edemez.
Temel çalışma ilkeleri aynı olan liste tipi değişkenlerin çeşitlenmesinin sebebi güvenlik ve etkinlik arasındaki optimizasyon problemidir. Diğer bir ifadeyle liste tipi değişkenlerin çeşitlenmesinin çok güvenli yöntemlerin esnek olmamasına, esnek yöntemlerin ise yeterince güvenli olmamasına dayandığı söylenebilir.
Liste tipi değişkenlerin ilki “list” değişkenleri köşeli parantezlerle “[ ]” ifade edilir. List değişkenlerinin/sınıfının elemanları aşağıda gösterildiği gibi virgül ile ayrılır.
myList = ["Volvo", "Opel", "Seat"] print(myList) #Sonuç: ['Volvo', 'Opel', 'Seat']
List değişkenlerinin elemanları sıralanabilir ve değiştirilebilir. Ayrıca bir list değişkeninde aynı elemandan birden fazla bulunabilmesi anlamında elemanları tekrar edebilir.
#sıralanabilir/order
myList = ["Volvo", "Opel", "Seat"]
myList.sort()
print(myList) #Sonuç: ['Opel', 'Seat', 'Volvo']
#değiştirilebilir/changeable
myList = ["Volvo", "Opel", "Seat"]
myList.remove("Opel")
print(myList) #Sonuç: ['Volvo', 'Seat']
myList = ["Volvo", "Opel", "Seat", "Volvo"]
print(myList) #Sonuç: ['Volvo', 'Opel', 'Seat', 'Volvo']
Bir list değişkeninin eleman sayısı “len” metodu ile elde edilebilir.
myList = ["Volvo", "Opel", "Seat"] print(len(myList)) #Sonuç: 3
Bir list değişkeni birbirinden farklı tipte veriler içerebilir.
myList = ["Volvo", 2006, 1.6, True] print(myList) #Sonuç: ['Volvo', 2006, 1.6, True]
List değişkeni “list” metodu ile iç içe çift parantez kullanılarak da oluşturulabilir.
myList = list(("Volvo", 2006, 1.6, True))
print(myList) #Sonuç: ['Volvo', 2006, 1.6, True]
2. Python’da List Elemanlarına Erişmek
List değişkeninden herhangi bir elemana erişmek için indeks numaraları kullanılabilir.
myList = ["Volvo", 2006, 1.6, True] print(myList[0]) #Sonuç: Volvo print(myList[1]) #Sonuç:2006 print(myList[2]) #Sonuç:1.6 print(myList[3]) #Sonuç: True
Not: Python’da indeks numaralarının 0’dan başladığını göz önünde bulundurun.
Negatif indeks numaraları ile bir list değişkeninin elemanlarına sondan başa doğru erişilebilir.
myList = ["Volvo", 2006, 1.6, True] print(myList[-1]) #Sonuç: True print(myList[-2]) #Sonuç: 1.6 print(myList[-3]) #Sonuç: 2006 print(myList[-4]) #Sonuç: Volvo
Bir list değişkeninin belirli bir eleman aralığına aşağıda gösterildiği gibi erişilebilir.
myList = ["Volvo", 2006, 1.6, True] print(myList[1:3]) #Sonuç: [2006, 1.6] myList = ["Volvo", 2006, 1.6, True] print(myList[-4:-1]) #Sonuç: ['Volvo', 2006, 1.6]
Yukarıdaki örnekte [1:3] ifadesiyle, list 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.
myList = ["Volvo", 2006, 1.6, True] print(myList[1:]) #Sonuç: [2006, 1.6, True] #[1:] indeks no.su 1'den sonraki (1 dahil) tüm elemanları çağırır myList = ["Volvo", 2006, 1.6, True] print(myList[:2]) #Sonuç: ['Volvo', 2006] #[:2] indeks no.su 2'den önceki (2 dahil değil) tüm elemanları çağırır
Bir list değişkeninin içine yuvalanmış başka bir list değişkeninin elemanlarına (veya iterable veri içeren bir elemanın karakterlerine) aşağıda gösterildiği gibi erişilebilir.
myNestedList = ["Volvo", [2006, 1.6, True]] #iç içe yuvalanmış iki list değişkeni olduğuna dikkat edin. print(myNestedList[1][0]) #Sonuç: 2006 print(myNestedList[1][1]) #Sonuç: 1.6 print(myNestedList[1][2]) #Sonuç: True print() #iterable bir eleman olan Volvo ifadesinin karakterleri de aynı yöntemle elde edilebilir. myNestedList = ["Volvo", [2006, 1.6, True]] print(myNestedList[0][0]) #Sonuç: V print(myNestedList[0][1]) #Sonuç: o print(myNestedList[0][3]) #Sonuç: v
“unpacking” olarak adlandırılan yöntemle, diğer bir ifadeyle list elemanlarının her birine değişken atayarak da aşağıda gösterildiği gibi list elemanlarına erişilebilir.
myList = ["Volvo", 2006, 1.6, True]
a,b,c,d = myList
print(a) #Sonuç: Volvo
print(b) #Sonuç: 2006
print(c) #Sonuç: 1.6
print(d) #Sonuç: True
print("__________\n")
"""
#List elemanlarının sayısı ile unpack edecek değişken sayısı aynı olmadığı için hata alınacaktır.
myList = ["Volvo", 2006, 1.6, True]
a,b,c = myList #Sonuç: ValueError: too many values to unpack (expected 3)
print(a) #Sonuç:
print(b) #Sonuç:
print(c) #Sonuç:
"""
3. Python’da Bir Değeri List Elemanları İçinde Kontrol Etmek
Bir list değişkeninin elemanları içinde bir değerin bulunup bulunmadığını kontrol etmek için “if” koşulu ile birlikte “in” metodu kullanılabilir.
myList = ["Volvo", 2006, 1.6, True]
x = 1.6
if x in myList:
print("Evet,", x, "myList değişkeninin bir elemanıdır.") # Sonuç: Evet, 1.6 myList değişkeninin bir elemanıdır.
else:
print("Hayır,", x, "myList değişkeninin bir elemanı değildir.")
print("___________\n")
myList = ["Volvo", 2006, 1.6, True]
x = "Chevrolet"
if x in myList:
print("Evet,", x, "myList değişkeninin bir elemanıdır.")
else:
print("Hayır,", x, "myList değişkeninin bir elemanı değildir.") # Sonuç: Hayır, Chevrolet myList değişkeninin bir elemanı değildir.
4. Python’da List Elemanlarını Değiştirmek
Bir list değişkeninin elemanını başka bir eleman ile değiştirmek için aşağıda gösterildiği gibi değiştirilecek list elemanının indeks numarası kullanılabilir.
myList = ["Volvo", 2006, 1.6, True]
myList[2] = "Chevrolet"
print("Bölüm 1:", myList) #Sonuç: ['Volvo', 2006, 'Chevrolet', True]
print("___________\n")
myList = ["Volvo", 2006, 1.6, True]
myList[1:3] = ["Chevrolet", "Ford"] # myList'in 1. ve 2. elemanları değiştirilir
print("Bölüm 2:", myList) #Sonuç: ['Volvo', 'Chevrolet', 'Ford', True]]
print("___________\n")
myList = ["Volvo", 2006, 1.6, True]
myList[2:3] = ["Chevrolet", "Ford"] # myList'in sadece 2. elemanı "Chevrolet" ve "Ford" elemanları ile değiştirilir. myList'ine eleman sayısı 1 artar.
print("Bölüm 3:", myList) #Sonuç: ['Volvo', 2006, 'Chevrolet', 'Ford', True]
print("___________\n")
myList = ["Volvo", 2006, 1.6, True]
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.
print("Bölüm 4:", myList) #Sonuç: ['Volvo', 2006, 'Chevrolet', 'Ford']
print("___________\n")
myList = ["Volvo", 2006, 1.6, True]
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.
print("Bölüm 5:", myList) #Sonuç: ['Volvo', 'Chevrolet']
5. Python’da List Değişkenine Eleman Eklemek (insert, append metotları)
Bir list sınıfının belirli bir pozisyonuna (elemanları arasına bir) eleman eklemek için aşağıda gösterildiği gibi “insert” metodu kullanılabilir.
myList = ["Volvo", 2006, 1.6, True] myList.insert(0, "Mercedes") # 0. indekse eklenecek. print(myList) #Sonuç: ['Mercedes', 'Volvo', 2006, 1.6, True] myList = ["Volvo", 2006, 1.6, True] myList.insert(2, "Mercedes") # 2. indekse eklenecek. print(myList) #Sonuç: ['Volvo', 2006, 'Mercedes', 1.6, True]
Bir list sınıfının 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 list sınıfının daima sonuna eleman ekler.
myList = ["Volvo", 2006, 1.6, True]
myList.append("Mercedes") # Son indekse eklenecek.
print(myList) #Sonuç: ['Volvo', 2006, 1.6, True, 'Mercedes']
#Bir eleman yerine bir list'in kendisi de eklenebilir.
myList = ["Volvo", 2006, 1.6, True]
myList.append(["Mercedes", "Toyota", "Nissan"]) # Son indekse eklenecek.
print(myList) #Sonuç: ['Volvo', 2006, 1.6, True, ['Mercedes', 'Toyota', 'Nissan']] # ["Mercedes", "Toyota", "Nissan"] list'inin elemanlarının değil kendisinin eklendiğine dikkat edin.
Farklı list’lerin elemanlarını birleştirmek ya da bir list’e diğer list’in tüm elemanlarını eklemek için “extend” metodunu kullanabilirsiniz.
myList = ["Volvo", 2006, 1.6, True] myList.extend(["Mercedes", "Toyota", "Nissan"]) # Son indeksten itibaren eklenecek. print(myList) #Sonuç: ['Volvo', 2006, 1.6, True, 'Mercedes', 'Toyota', 'Nissan'] #list olarak eklenmediğine, sadece elemanların eklendiğine dikkat edin. #Aynı işlemi şu şekilde de yapabiliriz. myList = ["Volvo", 2006, 1.6, True] x = ["Mercedes", "Toyota", "Nissan"] myList.extend(x) # Son indeksten itibaren eklenecek. print(myList) #Sonuç: ['Volvo', 2006, 1.6, True, 'Mercedes', 'Toyota', 'Nissan'] #list olarak eklenmediğine, sadece elemanların eklendiğine dikkat edin. #Buradan bakınca da iki farklı listenin elemanlarının birleştirilmesi olarak görülebilir.
6. Python’da List Elemanlarını Silmek (remove, pop, clear metotları)
Bir list değişkeninden belirli bir elemanı kaldırmak/silmek için aşağıda gösterildiği gibi “remove” metodu kullanılabilir.
myList = ["Volvo", 2006, "Volvo", 1.6, 2006, True] myList.remove(2006) # List değişkenindeki (soldan sağa doğru) ilk "2006" elemanını siler. print(myList) #Sonuç: ['Volvo', 'Volvo', 1.6, 2006, True]
Bir list 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 “pop” metodu kullanılabilir.
myList = ["Volvo", 2006, "Volvo", 1.6, 2006, True]
myList.pop(4) # List değişkeninde 4. indekste yer alan "2006" elemanını siler.
print(myList) #Sonuç: ['Volvo', 2006, 'Volvo', 1.6, True]
#pop() şeklinde indeks no kullanılmaz ise son eleman silinir.
myList = ["Volvo", 2006, "Volvo", 1.6, 2006, True]
myList.pop() # List değişkeninde son indekste yer alan "True" elemanını siler.
print(myList) #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.
myList = ["Volvo", 2006, "Volvo", 1.6, 2006, True]
x = myList.pop(4) # List değişkeninde son indekste yer alan silinen ("2006") değeri gösterir.
print(x) #Sonuç: 2006
myList.pop(4)
print(myList) #Sonuç: ['Volvo', 2006, 'Volvo', 1.6]
Bir list değişkeninden belirli bir indeks aralığında yer alan elemanları kaldırmak için aşağıda gösterilen yöntem kullanılabilir.
myList = ["Volvo", 2006, "Volvo", 1.6, 2006, True] myList[1:3] = [] # List değişkenin 1. ve 2. indekslerinde yer alan elemanları siler. print(myList) #Sonuç: ['Volvo', 1.6, 2006, True]
Bir list değişkeninin (değişkenin kendisini değil) tüm elemanlarını silmek için aşağıda gösterildiği gibi “clear” metodu kullanılabilir.
myList = ["Volvo", 2006, "Volvo", 1.6, 2006, True]
myList.clear() #Sadece tüm elemanlar silinecek; değişkenin kendisi silinmeyecek
print(myList) #Sonuç: []
#myList değişkeninin tümüyle silinip silinmediğinin kontrolü.
try: myList
except NameError: myList = None
if myList is None:
print("Mylist değişkeni artık yok.")
else:
print("Mylist değişkeni var.") #Sonuç: Mylist değişkeni var.
7. Python’da List Değişkeninin Kendisini Silmek (del metodu)
Bir list 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 “del” metodu kullanılabilir.
myList = ["Volvo", 2006, "Volvo", 1.6, 2006, True]
del myList[1] #1. indeks no.'ya sahip eleman silinecek.
print(myList) #Sonuç: ['Volvo', 'Volvo', 1.6, 2006, True]
#myList değişkenini tümüyle silmek; sadece elemanlarının tümünü değil kendisini de silmek.
myList = ["Volvo", 2006, "Volvo", 1.6, 2006, True]
del myList
#myList değişkeninin tümüyle silinip silinmediğinin kontrolü.
try: myList
except NameError: myList = None
if myList is None:
print("Mylist değişkeni artık yok.") #Sonuç: Mylist değişkeni artık yok.
else:
print("Mylist değişkeni var.")
8. Python’da List Elemanlarına Döngülerle Erişmek (for, while döngüleri)
Bir list 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.
myList = ["Volvo", 2006, 1.6, True]
for x in myList:
print(x)
#Sonuç:
#Volvo
#2006
#1.6
#True
Yukarıdaki süreci basitçe ifade etmek gerekirse, yukarıda gösterildiği gibi “for” döngüsü “myList” elemanları içinde tek tek dolaşarak elemanları “x” değişkenine aktarır ve print(x) metodu ile alt alta yazdırır. Örneğin “for”un ilk döngüsünde “x” değişkeninin değeri “Volvo” olacak ve onu yazdıracaktır. “for”un ikinci döngüsünde “x” değişkeninin değeri “2006” olacak ve onu da yazdıracaktır. Süreç bu şekilde myList elemanlarının tümü için tekrarlanacaktır. 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.
myList = ["Volvo", 2006, 1.6, True]
for x in myList:
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.
myList = ["Volvo", 2006, 1.6, True]
for x in range(len(myList)):
print(myList[x])
#Sonuç:
#Volvo
#2006
#1.6
#True
Bir önceki yöntemde “x” değişkenleri list’in elemanlarını taşırken, yukarıdaki yöntemde list’in 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 list değişkeninin sadece ilk iki elemanı ya da sadece son iki elemanı liste 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
myList = ["Volvo", 2006, 1.6, True]
for x in range(2):
print(myList[x])
#Sonuç:
#Volvo
#2006
print("___________\n")
#Son iki değer için
myList = ["Volvo", 2006, 1.6, True]
for x in range(len(myList)-2, len(myList)): #range(len(myList)-2, len(myList)) ifadesinin örnek özelinde range(2,4)'e eşit olduğuna dikkat edin.
print(myList[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
myList = ["Volvo", 2006, 1.6, True]
x = 0
while x < len(myList): #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(myList[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
myList = ["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(myList[x]) #Elemanlar indeks numaraları ile çıkartılıyor
x = x + 1
#Sonuç:
#Volvo
#2006
print("___________\n")
#Son iki değer için
myList = ["Volvo", 2006, 1.6, True]
x = len(myList)-1 # myList 4 elemanlıdır. Son (4.) elemanın indeks no.su 3 olduğu için x = len(myList)-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(myList[x]) #Elemanlar indeks numaraları ile çıkartılıyor
x = x - 1 # myList 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
9. Python’da List Değişkenleri İçin Döngü Sentaksını Sadeleştirmek (for döngüsü)
List 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 #myList = ["Volvo", 2006, 1.6, True] #for x in myList: # print(x) #Kısaltılmış form myList = ["Volvo", 2006, 1.6, True] [print(x) for x in myList] #prin(x) metodunu başa al, myList sonundaki iki noktayı kaldır ve satırın tümünü list köşeli parantezi içinde belirt. #Sonuç: #Volvo #2006 #1.6 #True
“myList” değişkenini kullanarak içinde sadece “e” harfi olanlardan ve içinde “e” harfi olmayanlardan yeni bir list değişkeni oluşturmak için kullanılan (normal ve kısa formda olan) döngülerin sentakslarını aşağıda inceleyebilirsiniz.
myList = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"]
newList = []
for x in myList:#myList elemanlarını dolaş
if "e" in x: #İçinde "e" karakteri olan myList elemanlarını newList listesine ekle.
newList.append(x)
print(newList)
#Sonuç: ['Mercedes', 'Peugeot']
#Yukarıdaki döngünün kısa formu
myList = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"]
newList = [x for x in myList if "e" in x]
print(newList)
#Sonuç: ['Mercedes', 'Peugeot']
#İçinde "e" karakteri olmayan myList elemanlarını newList listesine ekle.
myList = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"]
newList = [x for x in myList if "e" not in x]
print(newList)
#Sonuç: ['Volvo', 'Toyota', 'Ford']
Kısa sentaks ile oluşturulan list değişkenlerinin “for” döngüsü ile alternatif kullanımları için aşağıdaki kodları inceleyebilirsiniz.
#myList değişkeni elemanlarından yeni bir list değişkeni oluştur
myList = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"]
newList = [x for x in myList]
print(newList) #Sonuç: ['Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot']
print("___________1\n")
#myList değişkeni elemanlarından son ikisinden yeni bir list değişkeni oluştur
myList = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"]
newList = [myList[x] for x in range(len(myList)-2, len(myList))]
print(newList) #Sonuç: ['Ford', 'Peugeot']
print("___________2\n")
#myList değişkeninde "Toyota" elemanına eşit olmayan tüm elemanlardan yeni bir list değişkeni oluştur
myList = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"]
newList = [x for x in myList if x != "Toyota"]
print(newList) #Sonuç: ['Volvo', 'Mercedes', 'Ford', 'Peugeot']
print("___________3\n")
#myList değişkeninde "Mercedes" elemanına eşit olmayan tüm elemanlardan yeni bir list değişkeni oluştur; Mercedes elemanı yerine ise newList'e "Audi" elemanı ekle
myList = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"]
newList = [x if x != "Mercedes" else "Audi" for x in myList]
print(newList) #Sonuç: ['Volvo', 'Toyota', 'Audi', 'Ford', 'Peugeot']
print("___________4\n")
#myList değişkeni eleman sayısına eşit ve tüm elemanları 1'den oluşan yeni bir liste oluştur.
myList = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"]
newList = [1 for x in myList]
print(newList) #Sonuç: [1, 1, 1, 1, 1]
10. Python’da List Değişkenlerini Kopyalamak (copy, list metotları)
List 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 myList = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"] newList = myList.copy() print(newList) #Sonuç: ['Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot'] #list metodu myList = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"] newList = list(myList) print(newList) #Sonuç: ['Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot']
“list” metodu ile string bir ifadenin karakterlerini aşağıda gösterildiği gibi list elemanlarına dönüştürebilirsiniz.
myStr = "Python" x = list(myStr) print(type(x)) #Sonuç: <class 'list'> print(x) #Sonuç: ['P', 'y', 't', 'h', 'o', 'n']
11. Python’da List Değişkenlerini Birleştirmek (+ operatörü ile append, extend, join metotları)
List 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ü myList1 = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"] myList2 = ["Honda","Fiat", "Renault", "Seat", "Skoda"] newList = myList1 + myList2 print(newList) #Sonuç: ['Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot', 'Honda', 'Fiat', 'Renault', 'Seat', 'Skoda'] #append metodu myList1 = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"] myList2 = ["Honda","Fiat", "Renault", "Seat", "Skoda"] for x in myList2: myList1.append(x) print(myList1) #Sonuç: ['Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot', 'Honda', 'Fiat', 'Renault', 'Seat', 'Skoda']
Farklı list’lerin elemanlarını birleştirmek ya da bir list’e diğer list’in tüm elemanlarını eklemek için “extend” metodunu kullanabilirsiniz.
myList = ["Volvo", 2006, 1.6, True] myList.extend(["Mercedes", "Toyota", "Nissan"]) # Son indeksten itibaren eklenecek. print(myList) #Sonuç: ['Volvo', 2006, 1.6, True, 'Mercedes', 'Toyota', 'Nissan'] #list olarak eklenmediğine, sadece elemanların eklendiğine dikkat edin. #Aynı işlemi şu şekilde de yapabiliriz. myList = ["Volvo", 2006, 1.6, True] x = ["Mercedes", "Toyota", "Nissan"] myList.extend(x) # Son indeksten itibaren eklenecek. print(myList) #Sonuç: ['Volvo', 2006, 1.6, True, 'Mercedes', 'Toyota', 'Nissan'] #list olarak eklenmediğine, sadece elemanların eklendiğine dikkat edin. #extend metodu myList1 = ["Volvo","Toyota", "Mercedes", "Ford", "Peugeot"] myList2 = ["Honda","Fiat", "Renault", "Seat", "Skoda"] myList1.extend(myList2) print(myList1) #Sonuç: ['Volvo', 'Toyota', 'Mercedes', 'Ford', 'Peugeot', 'Honda', 'Fiat', 'Renault', 'Seat', 'Skoda']
“tuple”, “set”, “dictionary” gibi farklı liste tipi sınıfların elemanlarını birleştirmek için de “extend” metodunu kullanabilirsiniz.
myList = ["Volvo", 2006, 1.6, True]
myTuple = ("Mercedes", "Toyota", "Nissan") # parantezlerle ifade edilen liste tipi değişkenler tuple'dır. Daha sonra ayrıntılı açıklanacaktır.
myList.extend(myTuple) # Son indeksten itibaren eklenecek.
print(myList) #Sonuç: ['Volvo', 2006, 1.6, True, 'Mercedes', 'Toyota', 'Nissan']
List elemanlarını “join” metoduyla aşağıda gösterildiği gibi string bir değerde özelleştirilmiş biçimde birleştirebilirsiniz.
myList= ['P', 'y', 't', 'h', 'o', 'n'] myStr = "".join(myList) print(myStr) #Sonuç: Python myStr = "-".join(myList) print(myStr) #Sonuç: P-y-t-h-o-n myStr = ",".join(myList) print(myStr) #Sonuç: P,y,t,h,o,n
12. Python’da List Değişkeninin Tekrarlayan Elemanlarını Saymak (count metodu)
Bir elemanın list değişkeni içinde tekrar sayısını elde etmek için “count” metodunu aşağıda gösterildiği gibi kullanabilirsiniz.
myList = ['Volvo', 'Toyota', 'Mercedes', 'Volvo', 'Peugeot', 'Honda', 'Fiat', 'Volvo', 'Seat', 'Skoda']
x = myList.count("Volvo") #myList içinde Volvo elemanlarını sayar.
print(x) #Sonuç: 3
13. Python’da List 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 kullanabilirsiniz.
myList = ['Volvo', 'Toyota', 'Mercedes', 'Volvo', 'Peugeot', 'Honda', 'Fiat', 'Volvo', 'Seat', 'Skoda']
x = myList.index("Peugeot")
print(x) #Sonuç: 4
14. Python’da List Elemanlarını Sıralamak (sort, reverse metotları)
List 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
myList = ['Volvo', 'Toyota', 'Mercedes', 'Volvo', 'Peugeot', 'Honda', 'Fiat', 'Volvo', 'Seat', 'Skoda']
myList.sort(reverse=True)
print(myList) #Sonuç: ['Volvo', 'Volvo', 'Volvo', 'Toyota', 'Skoda', 'Seat', 'Peugeot', 'Mercedes', 'Honda', 'Fiat']
print("___________1\n")
# A'dan Z'ye sırala
myList = ['Volvo', 'Toyota', 'Mercedes', 'Volvo', 'Peugeot', 'Honda', 'Fiat', 'Volvo', 'Seat', 'Skoda']
myList.sort(reverse=False)
print(myList) #Sonuç: ['Fiat', 'Honda', 'Mercedes', 'Peugeot', 'Seat', 'Skoda', 'Toyota', 'Volvo', 'Volvo', 'Volvo']
List 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. myList = ['Volvo', 'Toyota', 'Mercedes', 'Volvo', 'Peugeot', 'Honda', 'Fiat', 'Volvo', 'Seat', 'Skoda'] myList.reverse() print(myList) #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 myList 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
myList = ['Volvo', 'Toyota', 'Mercedes', 'Volvo', 'Peugeot', 'Honda', 'Fiat', 'Volvo', 'Seat', 'Skoda']
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.
print(myList) #Sonuç: ['Fiat', 'Seat', 'Volvo', 'Volvo', 'Honda', 'Volvo', 'Skoda', 'Toyota', 'Peugeot', 'Mercedes']
15. Python’da List Elemanlarının Toplamı (sum metodu)
List elemanlarının toplamı “sum” metodu kullanılarak aşağıda gösterildiği gibi hesaplanabilir.
myList = [1,3,5,7,2,4,6,8]
#myList toplamını hesapla
mySum = sum(myList)
print(mySum) #Sonuç: 36
#100'ün üzerine myList toplamını ilave et.
mySum = sum(myList, 100)
print(mySum) #Sonuç: 136
print("__________\n")
myList = [1,3,5,7,2,4,6,8]
mySum = sum(myList)
myAverage= mySum/len(myList) #toplamın eleman sayısını bölümü ortalamayı verecektir.
print (myAverage) #Sonuç: 4.5
List elemanları sayısal değerlerden oluşmuyorsa “sum” metodu aşağıda gösterildiği gibi hata döndürecektir.
# myList elamanları sayısal değilse aşağıdaki hata oluşur. myList = ['Volvo', 1.6, 2006, True] #myList toplamını hesapla mySum = sum(myList) print(mySum) #Sonuç: TypeError: unsupported operand type(s) for +: 'int' and 'str'
16. Python’da List Elemanlarının Maksimum ve Minimum Değerleri (max, min metotları)
List 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.
myList = [1,3,5,7,2,4,6,8] maxVal = max(myList) # En büyük değere sahip elemanı verir. print(maxVal) #Sonuç: 8 myList = [1,3,5,7,2,4,6,8] minVal = min(myList) # En küçük değere sahip elemanı verir. print(minVal) #Sonuç: 1
List 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.
myList = ['Volvo', "Mercedes", "Ford", "Volkswagen"] maxVal = max(myList) #Alfabetik sıraya göre Z'den A'ya doğru ilk list elemanını verir. print(maxVal) #Sonuç: Volvo myList = ['Volvo', "Mercedes", "Ford", "Volkswagen"] minVal = min(myList) #Alfabetik sıraya göre A'dan Z'ye doğru ilk list elemanını verir. print(minVal) #Sonuç: Ford
Ayrıca list 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.
myList = ['Volvo', "Mercedes", "Ford", "Volkswagen"] maxChar = max(myList, key=len) # En fazla karaktere sahip elemanı verir. print(maxChar) #Sonuç: Volkswagen myList = ['Volvo', "Mercedes", "Ford", "Volkswagen"] minChar = min(myList, key=len) # En az karaktere sahip elemanı verir. print(minChar) #Sonuç: Ford
17. Python’da List Elemanlarını Numaralandırmak (enumerate metodu)
List elemanları (iterable string ifadedeler) “enumerate” metodu ile aşağıda gösterildiği gibi indekslenebilir.
myList = ['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 (list(enumerate(myList))) #Sonuç: [(0, 'Volvo'), (1, 'Mercedes'), (2, 'Ford'), (3, 'Volkswagen')]
print (list(enumerate(myStr))) #Sonuç: [(0, 'V'), (1, 'o'), (2, 'l'), (3, 'v'), (4, 'o')]
print("__________\n")
#İndeks numaralarını ve elemanları alt alta yazdırabilirsiniz.
#myList için
for myIndx, myElem in enumerate(myList):
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.
myList = ['Volvo', "Mercedes", "Ford", "Volkswagen"]
for myIndx, myElem in enumerate(myList, 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 List Elemanı Olarak Mantıksal Değişkenler (any, all metotları)
“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
“any” metodunun kullanımına örnek olması amacıyla aşağıdaki örnek problemin çözümünü inceleyebilirsiniz.
# Problem: 1'den 5'e kadar olan sayıların 3 ile çarpımından oluşan kümenin elemanları içinde 4'e tam bölünebilen herhangi bir eleman var mı?
# Yukarıdaki problemi çözmek istiyoruz.
list1 = []
list2 = []
# Aşağıdaki döngü 1'den 5'e kadar olan sayıların 3 ile çarpımından oluşan bir list döndürecektir.
for i in range(1,6):
list1.append(3*i)
# list1 elemanlarının 4 ile bölümünden kalanı 0 olan, yani list1'in mod4'ü 0 olan,
# yani list1'in 4'e tam bölünebilen elemanı olup olmadığını verir.
# Aşağıda list1 elemanları içinde 4'e tam bölünebilen elemanları arayacağız.
# 4'e tam bölünebilenler true, bölünemeyenler ise false değerini alarak list2 değişkeninin elemanlarını oluşturacaklar.
for i in range(0,5):
list2.append(list1[i]%4==0) # Önceki makalelerden hatırlanacağı üzere x%4 x mod4, yani x'in 4'e bölümünden kalanı veriyordu. x%4==0 ise x'in 4'e bölümünden kalan 0 mı anlamına geliyor.
print(list1) #Sonuç: [3, 6, 9, 12, 15]
print(list2) #Sonuç: [False, False, False, False, True]
# list2 değişkeninin elemanlarının içinde en az bir true var ise
# 1'den 5'e kadar olan sayıların 3 ile çarpımından oluşan kümenin en az bir elemanı 4 ile tam bölünebilir diyebiliriz.
# Aşağıdaki sonuç true ise yukarıdaki önerme doğru, false ise yanlıştır sonucuna varabiliriz.
# İstatistikle ilgiliyseniz, size de hipotez testlerini anımsatmadı mı? :)
print(any(list2)) #Sonuç: True
“all” metodunun kullanımına örnek olması amacıyla aşağıdaki örnek problemin çözümünü inceleyebilirsiniz.
# Problem: 1'den 5'e kadar olan sayıların 3 ile çarpımından oluşan kümenin TÜM elemanları 3'e tam bölünebiliyor mu?
# Yukarıdaki problemi çözmek istiyoruz.
list1 = []
list2 = []
# Aşağıdaki döngü 1'den 5'e kadar olan sayıların 3 ile çarpımından oluşan bir list döndürecektir.
for i in range(1,6):
list1.append(3*i)
# list1 elemanlarının 3 ile bölümünden kalanı 0 olan, yani list1'in mod3'ü 0 olan,
# yani list1'in 3'e tam bölünebilen elemanı olup olmadığını verir.
# Aşağıda list1 elemanları içinde 3'e tam bölünebilen elemanları arayacağız.
# 3'e tam bölünebilenler true, bölünemeyenler ise false değerini alarak list2 değişkeninin elemanlarını oluşturacaklar.
for i in range(0,5):
list2.append(list1[i]%3==0) # Önceki makalelerden hatırlanacağı üzere x%3 x mod3, yani x'in 3'e bölümünden kalanı veriyordu. x%3==0 ise x'in 3'e bölümünden kalan 0 mı anlamına geliyor.
print(list1) #Sonuç: [3, 6, 9, 12, 15]
print(list2) #Sonuç: [True, True, True, True, True]
# list2 değişkeninin elemanlarının tümü true ise
# 1'den 5'e kadar olan sayıların 3 ile çarpımından oluşan kümenin tüm elemanları 3 ile tam bölünebilir diyebiliriz.
# Aşağıdaki sonuç true ise yukarıdaki önerme doğru, false ise yanlıştır sonucuna varabiliriz.
# İstatistikle ilgiliyseniz, size de hipotez testlerini anımsatmadı mı? :)
print(all(list2)) #Sonuç: True
19. Python’da Seriler (arrays)
Python’da aslında seriler (arrays) bulunmaz. Bunun yerine liste tipi değişkenlerden “list” değişkeni kullanılır. Python’da seriler (arrays), ilerde ayrıntılı bir makale serisi olarak hazırlanması planlanan numpy isimli kütüphane üzerinden kullanılır. Ancak çalışma ilkeleri bakımından oldukça benzerdir. Bu yüzden, numpy kütüphanesindeki serilerin çalışma ilkelerinin kavranması bakımından da yukarıdaki “list” değişkenlerinin üzerinde durulmasının son derece yararlı olacağı düşünülmektedir. Seriler özellikle de veri analizi ya da veri bilimi gibi veri işleme süreçlerinde çok sık kullanılır.
Seriler (“list” sınıfı gibi) tek bir değişkende çok sayıda veriyi depolayabilen koleksiyonlardır. “list” değişkenleri üzerinden serileri daha yakından incelemek için açıklamaları komutların içinde yapılmış olan aşağıdaki örneği inceleyebilirsiniz.
#Seriler
myListArray = ["Volvo","Toyota", "Ford", "Peugeot"]
print(myListArray) #Sonuç: ['Volvo', 'Toyota', 'Ford', 'Peugeot']
print("___________\n")
#Bir serinin elemanına erişmek. Python’da ilk elemanın indeks numarasının 1 ile değil, 0 ile temsil edildiğini hatırlayın.
myListArray = ["Volvo","Toyota", "Ford", "Peugeot"]
print(myListArray[0]) #Sonuç: Volvo
print(myListArray[2]) #Sonuç: Ford
print("___________\n")
#Bir serinin elemanlarını değiştirmek
myListArray = ["Volvo","Toyota", "Ford", "Peugeot"]
myListArray[0] = "Audi"
myListArray[2] = "Mercedes"
print(myListArray) #Sonuç: ['Audi', 'Toyota', 'Mercedes', 'Peugeot']
print("___________\n")
#Bir serinin eleman sayısını öğrenmek
myListArray = ["Volvo","Toyota", "Ford", "Peugeot"]
x = len(myListArray)
print(x) #Sonuç: 4
print("___________\n")
#Serinin elemanlarını for in döngüsü ile seri dışına çıkartmak
myListArray = ["Volvo","Toyota", "Ford", "Peugeot"]
for x in myListArray:
print(x)
#Sonuç:
#Volvo
#Toyota
#Ford
#Peugeot
print("___________\n")
#Bir seriye elaman eklemek
myListArray = ["Volvo","Toyota", "Ford", "Peugeot"]
myListArray.append("Audi")
print(myListArray) #Sonuç: ['Volvo', 'Toyota', 'Ford', 'Peugeot', 'Audi']
print("___________\n")
#Bir seriden elaman silmek
myListArray = ["Volvo","Toyota", "Volvo", "Ford", "Volvo", "Peugeot"]
myListArray.pop(3)
myListArray.remove("Volvo") #Silinecek elemandan birden fazla varsa, soldan sağa doğru ilk tekrar eden "Volvo" elemanını siler.
print(myListArray) #Sonuç: ['Toyota', 'Volvo', 'Volvo', 'Peugeot']
20. Python’da List Örneği: Farklı Veri Tipleri İçeren List Elemanlarını Ayıklamak
Serinin önceki makalelerinde işlenen yöntemlerden de yararlanılarak, list elemanları içinde string, integer, float gibi farklı tipte olan elamanları ayıklamak için aşağıdaki örneği inceleyebilirsiniz.
myList = ['Volvo', 1, 1.6, "Mercedes", 2, 3.5, "Ford", 3, 1.8, "Volkswagen", 4, 2.0]
newList = []
for i in myList:
if isinstance(i, str):
newList.append(i)
print(newList) #Sonuç: ['Volvo', 'Mercedes', 'Ford', 'Volkswagen']
print("_______________\n")
#Farklı bir yöntemle string olmayanları ayıklayalım.
myList = ['Volvo', 1, 1.6, "Mercedes", 2, 3.5, "Ford", 3, 1.8, "Volkswagen", 4, 2.0]
newList = []
for i in myList:
if type(i) is not str:
newList.append(i)
print(newList) #Sonuç: ['Volvo', 'Mercedes', 'Ford', 'Volkswagen']
print("_______________\n")
#String, integer ve float tipte verileri ayrıştırma
myList = ['Volvo', 1, 1.6, "Mercedes", 2, 3.5, "Ford", 3, 1.8, "Volkswagen", 4, 2.0]
StrList = []
IntList = []
FloList = []
for i in myList:
if type(i) is str:
StrList.append(i)
elif type(i) is int:
IntList.append(i)
elif type(i) is float:
FloList.append(i)
print(StrList) #Sonuç: ['Volvo', 'Mercedes', 'Ford', 'Volkswagen']
print(IntList) #Sonuç: [1, 2, 3, 4]
print(FloList) #Sonuç: [1.6, 3.5, 1.8, 2.0]
İshak Kutlu, Veri Bilimi İçin Python Notları
