Minimum ve Maksimum Sıralaması

Birkaç değerin minimumunu veya maksimumunu almak için min ve max fonksiyonlarını kullanırız:

min(7,2,1,5)
#Çıktı: 1
max(7,2,1,5)
#Çıktı: 7

Bir dizinin Minimum ve Maksimum değerleri

Bir dizinin (iterable) minimumunu elde etmek, sıralanmış bir dizinin ilk elemanına erişmeye eşdeğerdir:

min([2, 7, 5])
#Çıktı: 2
sorted([2, 7, 5])[0]
#Çıktı: 2

Öte yandan maksimum elde etmek biraz daha karmaşıktır, Çünkü sorted fonksiyonu ile sıralamayı koruruz ve max ilk karşılaşılan değeri döndürürüz. Yineleme olmaması durumunda maksimum, sıralanmış dönüşün son öğesiyle aynıdır:

max([2, 7, 5])
#Çıktı: 7

sorted([2, 7, 5])[-1]
#Çıktı: 7

Ancak maksimum değere sahip olarak değerlendirilen birden fazla öğe varsa bu geçerli değildir:

class MyClass(object):
    def __init__(self, value, name):
        self.value = value
        self.name = name
        
    def __lt__(self, other):
        return self.value < other.value
    
    def __repr__(self):
        return str(self.name)

sorted([MyClass(4, 'first'), MyClass(1, 'second'), MyClass(4, 'third')])
# Çıktı: [second, first, third]
max([MyClass(4, 'first'), MyClass(1, 'second'), MyClass(4, 'third')])
# Çıktı: first

< veya > işlemlerini destekleyen öğeler içeren tüm yinelenebilir öğelere izin verilir.

Bir yinelenebilir dosyadan N en büyük veya N en küçük öğeyi çıkarma

Bir yinelenebilir dosyanın en büyük veya en küçük değerlerinin bir sayısını (birden fazla) bulmak için heapq modülünün nlargest ve nsmallest özelliklerini kullanabiliriz:

import heapq
#En büyük 5 öğeyi seçmek
heapq.nlargest(5, range(10))
#Çıktı: [9, 8, 7, 6, 5]
heapq.nsmallest(5, range(10))
#Çıktı: [0, 1, 2, 3, 4]

Bu, tüm yinelenebilir dosyayı sıralamaktan ve ardından sondan veya baştan dilimlemekten çok daha verimlidir. Dahili olarak bu işlevler, bu kullanım durumu için çok verimli olan ikili yığın öncelik kuyruğu veri yapısını kullanır.

min, max ve sorted gibi, bu fonksiyonlar da isteğe bağlı anahtar kelime argümanını kabul ederler; bu argüman, bir eleman verildiğinde sıralama anahtarını döndüren bir fonksiyon olmalıdır.

Bir dosyadan en uzun 1000 satırı çıkaran bir program örneğine bakalım:

import heapq
with open(dosyaadı) as f:
   longest_lines = heapq.nlargest(1000, f, key=len)

Burada dosyayı açıyoruz ve f dosya tanıtıcısını nlargest’e aktarıyoruz. Dosyayı yineleyerek, dosyanın her satırını ayrı bir dize olarak alıyoruz. nlargest daha sonra her öğeyi (veya satırı) sıralama anahtarını belirlemek için len fonksiyonuna geçirir. len, bir dize verildiğinde, satırın uzunluğunu karakter olarak döndürür.

Bu yöntem yalnızca şu ana kadarki en büyük 1000 satırın bir listesi için depolama alanına ihtiyaç duyar; bu yöntmi, aşağıdakilerle karşılaştıralım:

longest_lines = sorted(f, key=len)[1000:]

burada dosyanın tamamını bellekte tutmamız gerekecektir.

Sıralanmış bir dizi elde etme

Bir dizi kullarak aşağıdaki koda bakalım:

sorted((7, 2, 1, 5)) # tuple
Çıktı: [1, 2, 5, 7]
sorted(['c', 'A', 'b']) # liste
Çıktı: ['A', 'b', 'c']
sorted({11, 8, 1}) # set
Çıktı: [1, 8, 11]
sorted({'11': 5, '3': 2, '10': 15}) # dict
Çıktı: ['10', '11', '3'] # sadece anahtarlar üzerinde yineleme yapar
sorted('bdca') # dize
Çıktı: ['a','b','c','d']

Burada elde edeceğimiz sonuç her zaman yeni bir listedir; orijinal veriler değişmeden kalır.

max ve min için Varsayılan Argüman

Boş bir diziyi max veya min’e aktaramayız:

min([])
ValueError: min() arg boş bir dizidir

Bununla birlikte, Python 3 ile, bir istisna oluşturmak yerine, dizi boşsa döndürülecek bir değerle default anahtar kelime argümanını iletebiliriz:

max([], default=42)
Çıktı: 42
max([], default=0)
Çıktı: 0

Anahtar argümanı kullanarak minimum – maksimum

Bir dizi dizinin minimum/maksimum değerini bulmak mümkündür:

list_of_tuples = [(0, 10), (1, 15), (2, 8)]
min(list_of_tuples)
Çıktı: (0, 10)

ancak her dizideki belirli bir öğeye göre sıralamak istiyorsanız anahtar argümanını kullanın:

min(list_of_tuples, key=lambda x: x[0]) # İlk elemana göre sıralama
Çıktı: (0, 10)
min(list_of_tuples, key=lambda x: x[1]) # İkinci öğeye göre sıralama
Çıktı: (2, 8)
sorted(list_of_tuples, key=lambda x: x[0]) # İlk elemana göre sıralama (artan)
Çıktı: [(0, 10), (1, 15), (2, 8)]
sorted(list_of_tuples, key=lambda x: x[1]) # İlk öğeye göre sıralama
Çıktı: [(2, 8), (0, 10), (1, 15)]

import operator
#Operatör modülü lambda fonksiyonuna verimli alternatifler içerir
max(list_of_tuples, key=operator.itemgetter(0)) # İlk öğeye göre sıralama
Çıktı: (2, 8)
max(list_of_tuples, key=operator.itemgetter(1)) # İkinci öğeye göre sıralama
Çıktı: (1, 15)
sorted(list_of_tuples, key=operator.itemgetter(0), reverse=True) # Tersine çevrilmiş (azalan)
Çıktı: [(2, 8), (1, 15), (0, 10)]
sorted(list_of_tuples, key=operator.itemgetter(1), reverse=True) # Tersine çevrilmiş (azalan)
Çıktı: [(1, 15), (0, 10), (2, 8)]

Özel durum : sözlüklerde minimum – maksimum

Minimum veya maksimum değerin alınması ya da sıralama kullanılması nesne üzerindeki yinelemelere bağlıdır. dict durumunda, yineleme yalnızca anahtarlar üzerindedir:

adict = {'a': 3, 'b': 5, 'c': 1}
min(adict)
Çıktı: 'a'
max(adict)
Çıktı: 'c'
sorted(adict)
Çıktı: ['a', 'b', 'c']

Sözlük yapısını korumak için .items() üzerinde yineleme yapmanız gerekir:

min(adict.items())
Çıktı: ('a', 3)
max(adict.items())
Çıktı: ('c', 1)
sorted(adict.items())
Çıktı: [('a', 3), ('b', 5), ('c', 1)]

Sıralama için, dict benzeri bir yapıya sahipken sıralamayı korumak için bir OrderedDict oluşturabilirsiniz:

from collections import OrderedDict
OrderedDict(sorted(adict.items()))
Çıktı: OrderedDict([('a', 3), ('b', 5), ('c', 1)])
res = OrderedDict(sorted(adict.items()))
res['a']
Çıktı: 3

Değere göre sıralama

Bu da yine anahtar argümanı kullanılarak mümkündür:

min(adict.items(), key=lambda x: x[1])
Çıktı: ('c', 1)
max(adict.items(), key=operator.itemgetter(1))
Çıktı: ('b', 5)
sorted(adict.items(), key=operator.itemgetter(1), reverse=True)
Çıktı: [('b', 5), ('a', 3), ('c', 1)]