Sıralama NASIL YAPILIR
**********************

Yazar:
   Andrew Dalke and Raymond Hettinger

Yayın Versiyonu:
   0.1

Python listeleri, listeyi yerinde değiştiren yerleşik bir
"list.sort()" yöntemine sahiptir.  Ayrıca, bir yinelenebilirden yeni
bir sıralanmış liste oluşturan bir "sorted()" yerleşik işlevi de
vardır.

Bu belgede, Python kullanarak verileri sıralamak için çeşitli
teknikleri keşfediyor olacağız.


Sıralama Temelleri
==================

Basit bir artan sıralama yaratmak çok kolaydır: "sorted()"
fonksiyonunu çağırmanız yeterlidir. Bu fonksiyon, yeni bir sıralanmış
liste döndürür:

   >>> sorted([5, 2, 3, 1, 4])
   [1, 2, 3, 4, 5]

Ayrıca "list.sort()" yöntemini de kullanabilirsiniz. Listeyi yerinde
modifiye eder (ve karışıklığı önlemek için "None" döndürür).
Genellikle "sorted()" yönteminden daha az kullanışlıdır - ancak
orijinal listeye ihtiyacınız yoksa, biraz daha verimlidir.

   >>> a = [5, 2, 3, 1, 4]
   >>> a.sort()
   >>> a
   [1, 2, 3, 4, 5]

Diğer bir fark ise "list.sort()" metodunun sadece listeler için
tanımlanmış olmasıdır. Buna karşılık, "sorted()" fonksiyonu herhangi
bir yinelenebiliri kabul eder.

   >>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
   [1, 2, 3, 4, 5]


Anahtar Fonksiyonları
=====================

Hem "list.sort()" hem de "sorted()", karşılaştırma yapmadan önce
listenin her öğesi üzerinde çağrılacak bir işlevi (veya başka bir
çağrılabiliri) özellikle belirtmek için bir *key* parametresine
sahiptir.

Örneğin, büyük/küçük harfe duyarlı olmayan bir dize karşılaştırması bu
şekilde yapılmaktadır:

   >>> sorted("This is a test string from Andrew".split(), key=str.lower)
   ['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

*key* (anahtar) parametresinin değeri, tek bir argüman alan ve
sıralama amacıyla kullanılacak bir anahtarı döndürecek bir fonksiyon
(veya başka bir çağrılabilir) olmalıdır. Bu teknik, hızlı çalışır
çünkü anahtar işlevi her girdi (input) kaydı için tam olarak bir kez
çağrılır.

Yaygın bir model, nesnenin bazı indislerini anahtar olarak kullanarak
karmaşık nesneleri sıralamaktır. Örneğin:

   >>> student_tuples = [
   ...     ('john', 'A', 15),
   ...     ('jane', 'B', 12),
   ...     ('dave', 'B', 10),
   ... ]
   >>> sorted(student_tuples, key=lambda student: student[2])   # sort by age
   [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

Aynı teknik, adlandırılmış niteliklere sahip nesneler için de
geçerlidir. Örneğin:

   >>> class Student:
   ...     def __init__(self, name, grade, age):
   ...         self.name = name
   ...         self.grade = grade
   ...         self.age = age
   ...     def __repr__(self):
   ...         return repr((self.name, self.grade, self.age))

   >>> student_objects = [
   ...     Student('john', 'A', 15),
   ...     Student('jane', 'B', 12),
   ...     Student('dave', 'B', 10),
   ... ]
   >>> sorted(student_objects, key=lambda student: student.age)   # sort by age
   [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]


Operatör Modülü İşlevleri
=========================

Yukarıda gösterilen anahtar-fonksiyon kalıpları çok yaygındır. Bu
nedenle Python, erişim fonksiyonlarını daha kolay ve hızlı hale
getirmek için bazı kolaylık fonksiyonları sağlar. "operator" modülü
"itemgetter()", "attrgetter()" ve bir "methodcaller()" fonksiyonuna
sahiptir.

Bu fonksiyonların kullanımı sonucunda, yukarıdaki örnekler daha basit
ve hızlı hale gelir:

   >>> from operator import itemgetter, attrgetter

   >>> sorted(student_tuples, key=itemgetter(2))
   [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

   >>> sorted(student_objects, key=attrgetter('age'))
   [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

Operatör modülü fonksiyonları birden fazla seviyede sıralama
yapılmasına izin verir. Örneğin, *sınıf* ve ardından *yaş*'a göre
sıralamak için:

   >>> sorted(student_tuples, key=itemgetter(1,2))
   [('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]

   >>> sorted(student_objects, key=attrgetter('grade', 'age'))
   [('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]


Yükselen ve Alçalan
===================

Hem "list.sort()" hem de "sorted()" boolean değerli bir *reverse*
parametresi kabul eder. Bu, azalan sıralamaları işaretlemek için
kullanılır. Örneğin, öğrenci verilerini ters olarak *yaş* sırasına
göre elde etmek için:

   >>> sorted(student_tuples, key=itemgetter(2), reverse=True)
   [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

   >>> sorted(student_objects, key=attrgetter('age'), reverse=True)
   [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]


Sıralama Kararlılığı ve Karmaşık Sıralamalar
============================================

Sıralamaların kararlıolması kesindir. Bunun anlamı ise, birden fazla
kayıt aynı anahtara sahip olduğunda, orijinal sıralamanın
korunacağıdır.

   >>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
   >>> sorted(data, key=itemgetter(0))
   [('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]

*blue* için iki kaydın orijinal sıralarını nasıl koruduğuna dikkat
edin, böylece "('blue', 1)" kaydının "('blue', 2)" kaydından önce
gelmesi garanti edilir.

Bu harika özellik, birkaç sıralama adımı sonucunda karmaşık
sıralamalar oluşturmanıza olanak tanır. Örneğin, öğrenci verilerini
azalan *sınıf* ve ardından artan *yaş* ile sıralamak için, önce *yaş*
sıralamasını yapın ve ardından *sınıf* kullanarak tekrar sıralayın:

   >>> s = sorted(student_objects, key=attrgetter('age'))     # sort on secondary key
   >>> sorted(s, key=attrgetter('grade'), reverse=True)       # now sort on primary key, descending
   [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

Bu, bir listeyi ve alan çiftlerini alıp bunları birden fazla geçişte
sıralayabilen bir sarmalayıcı fonksiyon oluşturacak şekilde
soyutlanabilir.

   >>> def multisort(xs, specs):
   ...     for key, reverse in reversed(specs):
   ...         xs.sort(key=attrgetter(key), reverse=reverse)
   ...     return xs

   >>> multisort(list(student_objects), (('grade', True), ('age', False)))
   [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

Python'da kullanılan Timsort algoritması, bir veri kümesinde zaten
mevcut olan herhangi bir sıralamadan yararlanabildiği için çoklu
sıralamayı verimli bir şekilde yapar.


Süsle-Sırala-Boz
================

Süsle-Sırala-Boz deyimi, içerdiği üç adımdan ilham alınarak
oluşturulmuştur:

* İlk olarak, ilk liste sıralama düzenini kontrol eden yeni değerlerle
  süslenir (dekore edilir).

* İkinci olarak, dekore edilmiş liste sıralanır.

* Son olarak, süslemeler kaldırılır ve yeni sırada yalnızca ilk
  değerleri içeren bir liste oluşturulur.

Örneğin, DSU yaklaşımını kullanarak öğrenci verilerini *sınıf* bazında
sıralamak için:

>>> decorated = [(student.grade, i, student) for i, student in enumerate(student_objects)]
>>> decorated.sort()
>>> [student for grade, i, student in decorated]               # undecorate
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

Bu deyim, veri çiftleri leksikografik (sözlükbilimsel) olarak
karşılaştırıldığı için işe yarar: İlk öğeler karşılaştırılır,
aynılarsa ikinci öğeler karşılaştırılır ve bu böyle devam eder.

*i* indeksini dekore edilmiş listeye dahil etmek her durumda gerekli
değildir, ancak dahil etmek iki fayda sağlar:

* Sıralama sabittir -- iki öğe aynı anahtara sahipse, sıralanmış
  listede sıraları korunacaktır.

* Orijinal öğelerin karşılaştırılabilir olması gerekmez çünkü dekore
  edilmiş çiftlerin sıralaması en fazla ilk iki öğe tarafından
  belirlenecektir. Örneğin orijinal liste doğrudan sıralanamayan
  karmaşık sayılar içerebilir.

Bu deyimin bir diğer adı da, deyimi Perl programcıları arasında
popüler hale getiren Randal L. Schwartz'a atfen Schwartzian
transform'dur.

Artık Python sıralama anahtar fonksiyonları sağladığından, bu tekniğe
pek sık ihtiyaç duyulmamaktadır.


Karşılaştırma Fonksiyonları
===========================

Sıralama için mutlak bir değer döndüren anahtar işlevlerinin aksine,
karşılaştırma işlevi iki girdi için göreceli bir sıralamayı hesaplar.

Örneğin, bir balance scale iki örneği karşılaştırarak göreceli bir
sıralama verir: daha hafif, eşit veya daha ağır. Benzer şekilde,
"cmp(a, b)" karşılaştırma fonksiyonu; girdiler eşitse sıfır, küçükse
negatif, büyükse pozitif bir değer döndürür.

Algoritmaları diğer dillerden çevirirken karşılaştırma
fonksiyonlarıyla karşılaşmak yaygındır.  Ayrıca, bazı kütüphaneler
API'lerinin bir parçası olarak karşılaştırma fonksiyonları sağlar.
Örneğin, "locale.strcoll()" bir karşılaştırma fonksiyonudur.

Bu durumlara uyum sağlamak için Python, karşılaştırma fonksiyonunu bir
anahtar fonksiyon olarak kullanılabilir hale getirmek için
"functools.cmp_to_key" aracını sağlar:

   sorted(words, key=cmp_to_key(strcoll))  # locale-aware sort order


Tuhaflıklar ve Sonlar
=====================

* Yerel ayarlara duyarlı sıralama yapmak istiyorsanız, anahtar
  işlevleri için "locale.strxfrm()" ve karşılaştırma işlevleri için
  "locale.strcoll()" kullanabilirsiniz. Bu gereklidir çünkü
  "alfabetik" sıralamalar, temel alfabe aynı olsa bile kültürler
  arasında farklılık gösterebilir.

* *reverse* parametresi sıralamalardaki kararlığı aynı şekilde korur
  (böylece eşit anahtarlara sahip kayıtlar orijinal sırasını korumuş
  olur). İlginç bir şekilde bu etki, parametre olmadan yerleşik
  "reversed()" fonksiyonu iki kez kullanılarak da simüle edilebilir:

     >>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
     >>> standard_way = sorted(data, key=itemgetter(0), reverse=True)
     >>> double_reversed = list(reversed(sorted(reversed(data), key=itemgetter(0))))
     >>> assert standard_way == double_reversed
     >>> standard_way
     [('red', 1), ('red', 2), ('blue', 1), ('blue', 2)]

* The sort routines use "<" when making comparisons between two
  objects. So, it is easy to add a standard sort order to a class by
  defining an "__lt__()" method:

     >>> Student.__lt__ = lambda self, other: self.age < other.age
     >>> sorted(student_objects)
     [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

  However, note that "<" can fall back to using "__gt__()" if
  "__lt__()" is not implemented (see "object.__lt__()").

* Anahtar işlevlerinin doğrudan sıralanan nesnelere bağlı olması
  gerekmez. Bir anahtar işlevi, harici kaynaklara da erişebilir.
  Örneğin, öğrenci notları bir sözlükte saklanıyorsa, öğrenci
  adlarından oluşan ayrı bir listenin sıralanmasında da
  kullanılabilirler:

     >>> students = ['dave', 'john', 'jane']
     >>> newgrades = {'john': 'F', 'jane':'A', 'dave': 'C'}
     >>> sorted(students, key=newgrades.__getitem__)
     ['jane', 'dave', 'john']
