Bu bölüm, bir listeden (dizi) yinelenen öğeleri kaldırarak veya çıkararak Python’da nasıl yeni bir liste oluşturulacağını açıklar.
Aşağıdaki ayrıntılar burada açıklanmıştır.
- Yinelenen öğeleri kaldırın ve yeni listeler oluşturun
- Orijinal listenin sırasını koruma:
set() - Orijinal listenin sırasını korur:
dict.fromkeys(),sorted() - İki boyutlu dizi (liste listesi)
- Orijinal listenin sırasını koruma:
- Yinelenen öğeleri ayıklayın ve yeni bir liste oluşturun
- Orijinal listenin sırasını koruma
- Orijinal listenin sırasını korur
- İki boyutlu dizi (liste listesi)
Aynı konsept, listeler yerine demetlere de uygulanabilir.
için aşağıdaki makaleye bakın
- Bir listenin veya demetin yinelenen öğeleri olup olmadığını belirlemek istiyorsanız
- Tek bir liste yerine birden çok listeleme arasında ortak olan veya ortak olmayan öğeleri çıkarmak istiyorsanız
Listelerin farklı veri türlerini depolayabileceğini ve dizilerden kesinlikle farklı olduğunu unutmayın. Bellek boyutu ve bellek adresleri veya büyük verilerin sayısal olarak işlenmesini gerektiren işlemlerde dizileri işlemek istiyorsanız dizi (standart kitaplık) veya NumPy kullanın.
Yinelenen öğeleri kaldırın ve yeni listeler oluşturun
Orijinal listenin sırasını koruma:set()
Orijinal listenin sırasını korumaya gerek yoksa, bir set tipi set oluşturan set()’i kullanın.
Küme türü, yinelenen öğeleri olmayan bir veri türüdür. set() öğesine bir liste veya başka bir veri türü iletildiğinde, yinelenen değerler yok sayılır ve yalnızca benzersiz değerlerin öğe olduğu set türünde bir nesne döndürülür.
Bunu bir Tuple yapmak istiyorsanız, Tuple() kullanın.
l = [3, 3, 2, 1, 5, 1, 4, 2, 3]
print(set(l))
# {1, 2, 3, 4, 5}
print(list(set(l)))
# [1, 2, 3, 4, 5]
Tabii ki set olarak da bırakılabilir. Küme türü kümesi hakkında daha fazla bilgi için aşağıdaki makaleye bakın.
Orijinal listenin sırasını korur:dict.fromkeys(),sorted()
Orijinal listenin sırasını korumak istiyorsanız, sözlük türünün fromkeys() sınıf yöntemini veya yerleşik sort() işlevini kullanın.
dict.fromkeys(), anahtarları bağımsız değişkenlerde belirtilen listeler, demetler, vb. olan yeni bir sözlük nesnesi oluşturur. İkinci bağımsız değişken atlanırsa, değer Yoktur.
Sözlük anahtarlarında yinelenen öğeler bulunmadığından, yinelenen değerler set()’teki gibi yok sayılır. Ek olarak, öğeleri sözlük anahtarları olan bir liste elde etmek için bir sözlük nesnesi list() öğesine argüman olarak iletilebilir.
print(dict.fromkeys(l))
# {3: None, 2: None, 1: None, 5: None, 4: None}
print(list(dict.fromkeys(l)))
# [3, 2, 1, 5, 4]
Python 3.7’den beri (CPython 3.6’dır) dict.fromkeys() öğesinin argüman dizisinin sırasını koruduğu garanti edilmiştir. Önceki sürümler, yerleşik sort() işlevini aşağıdaki gibi kullanır.
Sıralanmış bir öğe listesi döndüren sorted argüman anahtarı için list tuple yöntemi index()’i belirtin.
index(), listeyi orijinal listenin sırasına göre sıralamak için sort() anahtarı olarak belirtilebilen değerin dizinini (listedeki öğenin numarası) döndüren bir yöntemdir. Argüman anahtarı, çağrılabilir (çağrılabilir) bir nesne olarak belirtilir, bu nedenle () yazmayın.
print(sorted(set(l), key=l.index))
# [3, 2, 1, 5, 4]
İki boyutlu dizi (liste listesi)
İki boyutlu diziler (liste listeleri) için set() veya dict.fromkeys() kullanan yöntem bir TypeError ile sonuçlanır.
l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]
# l_2d_unique = list(set(l_2d))
# TypeError: unhashable type: 'list'
# l_2d_unique_order = dict.fromkeys(l_2d)
# TypeError: unhashable type: 'list'
Bunun nedeni, listeler gibi hash edilemeyen nesnelerin, tür kümesinin öğeleri veya dict türünün anahtarları olamamasıdır.
Aşağıdaki işlevleri tanımlayın Orijinal listenin sırası korunur ve tek boyutlu listeler ve demetler için çalışır.
def get_unique_list(seq):
seen = []
return [x for x in seq if x not in seen and not seen.append(x)]
print(get_unique_list(l_2d))
# [[1, 1], [0, 1], [0, 0], [1, 0]]
print(get_unique_list(l))
# [3, 2, 1, 5, 4]
Liste anlama notasyonu kullanılır.
Burada, aşağıdakileri kullanıyoruz
- “X ve Y”deki X, and operatörünün kısa devre değerlendirmesinde yanlışsa, Y değerlendirilmez (yürütülmez).
- append() yöntemi Yok değerini döndürür.
Orijinal listenin seq öğeleri görülende mevcut değilse, o zaman ve sonrası değerlendirilir.
see.append(x) yürütülür ve eleman görülene eklenir.
append() yöntemi None döndürdüğünden ve None False olduğundan, not see.append(x) True olarak değerlendirilir.
Liste anlama gösterimindeki koşullu ifade Doğru olur ve oluşturulan nihai listenin bir öğesi olarak eklenir.
Orijinal liste dizisinin öğeleri görülende mevcutsa, o zaman görülmeyen x Yanlış’tır ve liste anlama ifadesi için koşullu ifade Yanlış’tır.
Bu nedenle, oluşturulan nihai listenin öğeleri olarak eklenmezler.
Diğer bir yöntem, sonuç sıralanacak olsa da, NumPy’nin işlevi np.unique() içinde argüman eksenini ayarlamaktır.
Yinelenen öğeleri ayıklayın ve yeni bir liste oluşturun
Orijinal listenin sırasını koruma
Orijinal listeden yalnızca yinelenen öğeleri çıkarmak için collections.Counter() öğesini kullanın.
Öğeleri anahtar ve öğelerin sayısını değer olarak içeren bir collections.Counter (sözlüğün alt sınıfı) döndürür.
import collections
l = [3, 3, 2, 1, 5, 1, 4, 2, 3]
print(collections.Counter(l))
# Counter({3: 3, 2: 2, 1: 2, 5: 1, 4: 1})
Sözlüğün bir alt sınıfı olduğu için, anahtarları ve değerleri almak için item() kullanılabilir. Sayısı iki veya daha fazla olan anahtarların çıkarılması yeterlidir.
print([k for k, v in collections.Counter(l).items() if v > 1])
# [3, 2, 1]
Orijinal listenin sırasını korur
Yukarıdaki örnekte gösterildiği gibi, Python 3.7’den beri, collections.Counter’ın anahtarları orijinal listenin sırasını korur vb.
Önceki sürümlerde, sorted() ile sıralama yapmak ve yinelenen öğeleri silmek yeterlidir.
print(sorted([k for k, v in collections.Counter(l).items() if v > 1], key=l.index))
# [3, 2, 1]
Kopyaları olduğu gibi çıkarmak istiyorsanız, orijinal listedeki öğeleri iki veya daha fazla sayıda bırakmanız yeterlidir. Sipariş de korunur.
cc = collections.Counter(l)
print([x for x in l if cc[x] > 1])
# [3, 3, 2, 1, 1, 2, 3]
İki boyutlu dizi (liste listesi)
İki boyutlu diziler (liste listeleri) için, sırasıyla orijinal listenin sırası korunmadığında ve korunduğunda aşağıdaki işlevler mümkündür. Aynı zamanda tek boyutlu listeler ve demetler için de çalışır.
l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]
def get_duplicate_list(seq):
seen = []
return [x for x in seq if not seen.append(x) and seen.count(x) == 2]
def get_duplicate_list_order(seq):
seen = []
return [x for x in seq if seq.count(x) > 1 and not seen.append(x) and seen.count(x) == 1]
print(get_duplicate_list(l_2d))
# [[0, 1], [1, 1]]
print(get_duplicate_list_order(l_2d))
# [[1, 1], [0, 1]]
print(get_duplicate_list(l))
# [3, 1, 2]
print(get_duplicate_list_order(l))
# [3, 2, 1]
Yinelenenlerle ayıklamak istiyorsanız, orijinal listedeki öğeleri iki veya daha fazla sayıda bırakın.
print([x for x in l_2d if l_2d.count(x) > 1])
# [[1, 1], [0, 1], [0, 1], [1, 1], [1, 1]]
count()’un hesaplama karmaşıklığı O(n) olduğundan, yukarıda gösterilen ve count()’u art arda yürüten işlevin çok verimsiz olduğuna dikkat edin. Daha akıllı bir yol olabilir.
Counter, sözlüğün bir alt sınıfıdır, bu nedenle, öğeleri listeler veya diğer hash edilemeyen nesneler olan bir listeyi veya demeti collections.Counter()’a iletirseniz, bir hata meydana gelir ve onu kullanamazsınız.
# print(collections.Counter(l_2d))
# TypeError: unhashable type: 'list'