Python Programlama Dili

Bölüm 2

Genel Yöntemler

Top Navigasyon

Ders 18

3.1.3 - Listelerin Yaratılması

Listeler doğrudan veya dosyadan okunarak literal olarak atanabildikleri gibi, önceden atanmış listelerin kopyalanması yöntemleri ile oluşturulabilirler. Boş bir liste,

liste = []

şeklinde atanır. Bir liste literali,

liste = [3,4]

şeklinde atanır. Bir önceden atanmış bir liste yeni bir değişkene,

g = liste

şeklinde bağlanabilir. Listelerin kesilerek alt listeler oluşturulması, kopyalanarak yeni bir değişkene atanması yapılabilir. Bunların hepsini detaylı olarak incelemiş durumdayız.

Bazı durumlarda, önceden bir liste hazırlanması gerekebilir. Bu işlem için, liste çoğaltma işlemcisi * den yararlanılabilir. Örnek:

        
# -*- coding: utf-8 -*-
# ders18program1.py

>>> liste = [None]*5
>>> liste
[None, None, None, None, None]

Listelerin önceden yaratılmasında eleman olarak, genellikle None kullanılır. Fakat, her türlü önceden hazırlanmış eleman, aşağıdaki örnekte görülebileciği gibi, çoğaltılarak listelere önceden yerleştirilebilir.

>>> q = [5,7]*3
>>> q
[5, 7, 5, 7, 5, 7]

Listeler, list() öntanımlı fonksiyonundan yararlanarak da yaratılabilirler. Kullanım örnekleri aşağıda görülmektedir.

L = list() Örnek,

>>> L = list()
>>> L
[]

Bu işlemin L = [] işlemine eşdeğer olduğu görülüyor. Bu nedenle, kullanımı pratik değildir.

L = list(sekans) (Burada sekans birbirini izleyen veri topluluklarıdır. Bunlar, konteyner tiplerdir ve her türlü liste, topluluk (tuple) sözlük (dict) generator olabilir). Örnek,

L = (8 , 9 , 10)

Bu işlem de, L = [8, 9, 10] işlemine, yani bir liste değişkenine, bir liste literalinin atanması ile eşdeğer olduğu görülüyor. İkinci yöntem daha pratik olduğundan daha çok kullanılması doğaldır.

Bir sekans oluşturmak için, range () fonksiyonundan yararlanılabilir. Örnek :

d  = list(range(-2, 2))

L = list(ifade for değişken in sekans)

Bu işlem sonunda [-2, -1, 0, 1] listesi oluşur. Görüldüğü gibi list () fonksiyonu çok yararlı olmaktadır.

Bu son işlem list comphensions adı verilen ve salt Python programlama diline özgü bir liste yaratma yöntemi ile eşdeğerdir. Burada da daha güçlü olan sonuncusu daha yaygın olarak kullanılmaktadır.

Bu örneklerle de görüldüğüne göre, list() fonksiyonu genellikle az kullanılmasına karşın, çok yararlı ve yetenekli bir liste oluşturma yöntemidir.

List comprehensions adı verilen bir yöntem, listelerin oluşmasına olanak sağlar. Bu yöntem, salt Python programlama diline özgüdür. Bunu kısa süre sonra göreceğiz.

Bir listeyi daha önce tanımlamış bir liste elemanlarından yararlanılarak veya boş liste yeni elemanlar oluşturarak eklemek için, genellikle fonksiyonlardan yararlanılır. Bunun çok senaryoları vardır. Örnek olarak, atanmış bir listenin elemanları, bir fonksiyonun argümanı olarak kullanılarak, fonksiyonun geri döndürdüğü değer, yeni bir listenin elemanları olarak atanabilir. Aşağıdaki program, bu işlemin klasik yoldan çözümünü içermektedir.


def fonksiyon(a):

if a< 20 
return True

else :
return False


t  =  [20, 30, 5, 15, 40]
    
s = len(t)

ilk = [None ] * 5

for indis , eleman in enumerate(t) :

ilk [indis] =  fonksiyon(eleman)

ikinci = [] 

for eleman in t:

ikinci.append(fonksiyon(eleman))

for indis , eleman in enumerate(ilk) :
       
print('out :', indis, eleman)

for indis , eleman in enumerate(ikinci) :
    
print('out :', indis, eleman)


---------Program----Sonucunun----Görüntülenmesi-----------------------
ilk : 0 False
ilk : 1 True
ilk : 2 False
ilk : 3 False
ilk : 4 True
ikinci : 0 False
ikinci : 1 True
ikinci : 2 False
ikinci : 3 False
ikinci : 4 True

Yukarıdaki programda iki farklı klasik yöntemle, var olan bir listeden hareketle iki ayrı liste yaratılmıştır. Yaradılış yöntemleri ne kadar farklı olursa olsun, sonuçta oluşan listeler, birbirlerinin aynı olmaktadırlar.

Yukarıdaki, programda klasik yönden çözülmüş olan, var olan bir liste elemanlarının, bir fonksiyona argüman olarak sağlanması ve fonsiyonun döndürdüğü değerlerin yeni bir listenin elemanları olarak atanması problemi, aşağıda bir uygulama örneği verilen map() fonksiyonu yardımı ile, daha kısa olarak çözümlenebilmektedir.

        
# -*- coding: utf-8 -*-
# ders18program2.py

def fonksiyon(a):

if a< 20 
return True

else :
return False


t  =  [20, 30, 5, 15, 40]
    

ilk = map( fonksiyon,t)

for indis , eleman in enumerate(ilk) :
       
print(indis, eleman)

---------Program----Sonucunun----Görüntülenmesi-----------------------
0 False
1 True
2 False
3 False
4 True

Yukarıdaki programda uygulanan map() fonksiyonunun, yetkinliğine ne kadar övgü yapılırsa yapılsın az gelebilir. Python programlama dilinin en güçlü yönlerinden birisi, çok iyi bir araştırma ile, en gerekli işlemleri yapabilecek fonksiyonların öntanımlı olarak verilmesi olarak belirtilmektedir.

Öntanımlı filter() fonksiyonu var olan bir sekansın bazı elemanların belirli bir kriteryuma göre filtreleyerek yeni bir liste oluşturur.

>>>d = list(filter((lambda x: x > 0), range(-2, 5)))  
>>>d
>>>[1, 2, 3, 4]

Bu filtreleme işlemi, klasik yöntemle, önce listenin oluşturulması, sonra bir for in döngüsü ile liste elemanları taranıp bir if karşılaştırılması yapılarak kriteryumu geçenleri yeni bir liste elemanları olarak yerleştirme şeklinde yapılabilir. Yine de, filter() öntanımlı fonksiyonu daha kısa ve daha etkili bir kodlama olanağı sağlar.

Python programlama dilinin en gözalıcı uygulamalarından birisi, "list comprehensions" adı verilen bir uygulamadır. Bu uygulama prensip olarak, map() fonksiyonunun işlevini daha kısa olarak yürütebilmek amacını taşımaktadır. Bu yöntemin ismini "liste oluşturma" olarak düşünebiliriz.

Liste oluşturma yönteminin temel sözdizimi,

[ ifade(k değerini içerir) for k in liste if koşul]

Burada, herşeyden önce, sonuçta bir listenin yaratılacağı, tüm yapılanmanın köşeli parantezler içine alınması ile belirtiliyor. Yaratılacak listenin bir değişkene atanması en doğrusu olacaktır. Bu tanımda ifade k döngü değişkenini içeren bir ifadedir ve bu ifadenin sonucu, oluşturacak listenin elemanlarını oluşturucaktır. Iterasyon değişkeni k, liste adında ekiden var olan bir sekansiyel veri tipi sınıf örneğinin elemanlarını sekansiyel olarak (birbiri ardınca son eleman tamamlanıncaya kadar) tarayacak ve her iterasyonda, eriştiği elemanın değerini alacaktır. Her iterasyonda kdöngü değişkeni k nın aldığı değer eğer varsa if ile başlayan koşulu sağlayıp sağlamadığı kontrol edilecek ve eğer koşul sağlanıyorsa, ifade o iterasyondaki k değeri ile hesaplanarak sonuç yeni oluşturulacak listenin bir elemanı olarak, oluşturulacak listeye yerleştirilecektir.

Bu yöntem, aşağıda açıklanan çalışma yöntemine koşuttur.

for item in list:
if conditional:
expression

Bu yöntem, aşağıda görülen programda çeşitli şekillerde uygulanmıştır.

        
# -*- coding: utf-8 -*-
# ders18program3.py

def fonksiyon(a):

if a< 20 
return True

else :
return False


t  =  [20, 30, 5, 15, 40]
    
ilk  = [fonksiyon(k) for k in t]


for indis , eleman in enumerate(ilk) :
       
print('ilk : 'indis, eleman)
    
ikinci = [elem * 2 for elem in t]

for indis , eleman in enumerate(ilk) :
       
print('ikinci : 'indis, eleman)
      
üçüncü  = [fonksiyon(k) for k in t if k > 15 ]

for indis , eleman in enumerate(üçüncü) :
       
print('üçüncü : 'indis, eleman)
      
---------Program----Sonucunun----Görüntülenmesi-----------------------
ilk :  0 False
ilk :  1 True
ilk :  2 False
ilk :  3 False
ilk :  4 True
ikinci :  0 False
ikinci :  1 True
ikinci :  2 False
ikinci :  3 False
ikinci :  4 True
üçüncü :  0 False
üçüncü :  1 True
üçüncü :  2 True

Yukarıdaki program liste oluşturma yönteminin çeşitli variyantlarını açık olarak belirtmektedir. Liste oluşturma yöntemi, Python programlama dilinin güçlü yöntemlerinden biridir ve çok iyi özümsenmelidir.

Bilgisayar progamları ile asal sayıların belirlenmesi çeşitli yöntemlerle yapılabilir. Aşağıdaki program, klasik bir asal ayı hesaplama yönteminin uygulanmasıdır.

        
# -*- coding: utf-8 -*-
# ders18program4.py
def primes(m):
d = []
  
for num in range(2, m): # 2 den m e kadar iterasyon
for i in range(2, num): # sayının çarpanlarının araştırılması
if num % i == 0: # ilk çarpan
# j = num / i # ikinci çarpan
# print('{0} eşittir {1} * {2}'.format(num, i, j))
break # bir sonraki sayıya geç
else: # döngünün else kısmı
d.append(num)
# print('\n', num, 'bir asal sayıdır\n')  
 return d


q = primes(20)
print(q)

    
---------Program----Sonucunun----Görüntülenmesi-----------------------
 [2, 3, 5, 7, 11, 13, 17, 19]

Yukarıdaki program son derece klasik ve anlaşılması kolay bir asal sayı hesaplama uygulamasıdır. Bu program, bu çalışma çerçevesinde geliştirilmiştir. Bu uygulamanın, programlama stili çok açıktır ve program yürüyüşü kolaylıkla izlenebilmektedir.

Bu program, http://www.secnetix.de/olli/Python/list_comprehensions.hawk tarafından, list comprehension yöntemine çevrilmiştir. Bu program, aşağıda görülmektedir.

        
# -*- coding: utf-8 -*-
# ders18program5.py

noprimes = [j for i in range(2, 8) for j in range(i * 2, 50, i)]
primes = [x for x in range(2, 50) if x not in noprimes]
print (primes)

Bu program çok kısadır, fakat bir önceki ile aynı sonucu vermektedir. Yani, her iki program da asal sayıları hesaplamaktadır. List comprehensions yöntemini kullanan yukarıdaki program, klasik yöntemi kullanan ilkine göre çok daha kısadır. Bu programda, iki liste oluşturulmakta ve ilk listeye asal sayı olmayan sayılar yerleştirilmektedir. Bu liste sıralı sayılarla karşılaştırılmakta ve asal sayılar olmayan sayıların listesinde bulunmayan sayılar, asal sayılar listesinin elemanları olarak atanmaktadırlar. Sadece bu program bile, list comprehensions yönteminin önemini belirtmek için yeterli sayılabilir.

Burada incelediğimiz, list () öntenımlı fonksiyon uygulamaları ileride de, örnek olarak, toplulukların (tuples), listelere çevrilmesinde, sözel veri uygulamalarında, ve daha başka uygulamalarda karşımız çıkacaktır. Liste oluşturma yöntemi, Python programlama dilinin güçlü yöntemlerinden biridir ve çok iyi özümsenmelidir.

Liste elemanlarının tümü sayısal değerlerden oluşuyorsa, elemanların değerlerinin toplamı sum () öntanımlı fonksiyonun uygulanması saptanabilir. Aşağıdaki program bu konuda bir uygulama örneğidir.

        
# -*- coding: utf-8 -*-
# ders18program6.py

f = [12.45, 14.56, 13.44, 14.66]

x = len(f)

toplam = sum(f)

ortalama = toplam / x

print("ortalama = {0: 2.2f}".format(ortalama))
    
---------Program----Sonucunun----Görüntülenmesi-----------------------
ortalama =  13.78

Görüldüğü gibi, sum() fonksiyonu çok kolaylık sağlayan bir fonksiyondur.