Python Set Vs List – Gerçek Fark

Python programlama dünyasında, farklı amaçlara hizmet eden çeşitli veri yapılarıyla sıklıkla karşılaşacaksınız. Bu yapılar arasında kümeler ve listeler, veri koleksiyonlarını depolamak ve değiştirmek için yaygın olarak kullanılır.

Benzer görünseler de, özelliklerinde ve kullanım durumlarında dikkate değer farklılıklar vardır.

İçindekiler

• Python Setlerini ve Listelerini Anlamak
  • Python Kümeleri nedir?
  • Python Listeleri Nedir?
• Kümeler ve Listeler Arasındaki 3 Temel Fark
  • 1. Sipariş ve İndeksleme
  • 2. Değişkenlik
  • Unsurların Benzersizliği
  • 3. Desteklenen İşlemler
• Doğru Veri Yapısını Nasıl Seçersiniz?
  • Setler için Kullanım Örnekleri
  • Listeler İçin Kullanım Örnekleri
• AKümeler ve Listeler Arasında Performans Karşılaştırması
  • Zaman Karmaşıklığı
  • Hafıza kullanımı
• Ortak İşlemler ve Yöntemler
  • Yöntemi Ayarla
  • Liste Yöntemi
• Son Sözümüz

Python Setlerini ve Listelerini Anlamak

Tamam, o halde önce bazı şeyleri açıklayalım.

Python Kümeleri nedir?

Bir Python seti, üye adı verilen sıralanmamış farklı öğeler koleksiyonunu temsil eden yerleşik bir veri yapısıdır.

Bu güçlü araç, özellikle veri bilimi uygulamalarında ve matematiksel işlemlerde kullanışlıdır.

Python kümeleri aşağıdaki özelliklere sahiptir:

1. Sırasızdırlar, yani bir kümedeki öğeler dizinlerinden bağımsız olarak depolanır. Benzersiz değerlerin bu sırasız koleksiyonu, verimli üyelik testlerini ve küme kavrayışlarını destekler.

2. Yinelenen değerlere izin vermezler. Bu, benzersiz değerlerle çalışmanız, bir listeden yinelenenleri kaldırmanız veya birleşimler, kesişimler ve simetrik farklar gibi ayarlanmış işlemleri gerçekleştirmeniz gerektiğinde onları kullanışlı kılar.

Python'da bir küme oluşturmanın iki yolu vardır:

1. Kıvrımlı parantez olarak da bilinen kaşlı ayraçları ({}) kullanarak.

2. Tek bir bağımsız değişken alan yerleşik set() işlevini kullanarak, kümeye dahil etmek istediğiniz öğeleri içeren yinelenebilir.

Kıvrımlı parantezler ve yerleşik set işlevi kullanılarak bir Python seti oluşturmak için genel bir sözdizimi aşağıda verilmiştir:

my_set = {1, 2, 3}
another_set = set([4, 5, 6])

Python Listeleri Nedir?

Python listesi, diğer programlama dillerindeki dinamik dizilere benzeyen yerleşik bir veri yapısıdır.

Birden çok öğeyi tek bir değişkende depolamak için kullanılırlar, bu da onları dizeler, sayılar ve mantıksal değerler gibi çeşitli veri türlerini işlemek için çok yönlü bir seçenek haline getirir.

Python Listeleri aşağıdaki özelliklere sahiptir:

1. Sıralıdırlar, bu da belirli bir öğenin listede benzersiz bir konuma sahip olduğu ve dizini aracılığıyla erişilebileceği anlamına gelir. Bu sıralı koleksiyon, dilimleme, birleştirme ve liste kavrama gibi işlemleri gerçekleştirmenize izin vererek rasgele erişimi destekler.

2. Değişkendirler ve bir liste oluşturulduktan sonra öğeleri değiştirilebilir, bu da veri yapılarıyla çalışırken esneklik sunar.

3. Python listeleri, yinelenen değerlere izin verir ve dizeler, sayılar ve boolean'lar dahil olmak üzere çeşitli veri türlerinin bir karışımını depolayabilir.

Python'da liste oluşturmanın iki yolu vardır :

1. Listenin sınırlarını gösteren köşeli parantezler kullanarak.

2. Tek bir bağımsız değişken veya listeye dahil etmek istediğiniz öğeleri içeren bir yineleme alabilen yerleşik list() işlevini kullanarak.

Aşağıdaki Python kodu, köşeli parantezler ve yerleşik list() işlevi kullanılarak bir Python listesi oluşturmayı gösterir:

list1 = [1, 2, 3] 
list2 = list([4, 5, 6])

Kümeler ve Listeler Arasındaki 3 Temel Fark

Bir Python seti ile bir liste arasındaki çoklu farklardır. Önemli olanlardan bazıları aşağıda listelenmiştir:

1. Sipariş ve İndeksleme

Python Listesinde Sıralama ve İndeksleme : Bir Python listesi indekslemeyi destekleyebilir, yani bir listedeki öğelere listedeki konumlarını kullanarak erişebilirsiniz. Bu, verileri bilinen bir sırayla işlerken esneklik sağlar.

Aşağıdaki Python kodu, listelerin sırasını ve indekslenmesini gösterir:

# Creating a Python list
my_list = [3, 5, 2, 8, 1]

# Accessing elements using their index
first_element = my_list[0]  # This will be 3
third_element = my_list[2]  # This will be 2

# Modifying elements using their index
my_list[1] = 7  # The list becomes [3, 7, 2, 8, 1]

# Iterating over a list maintaining the order
for item in my_list:
    print(item)

Python Setleri: Bir Python seti, indeksleme içermeyen sırasız bir koleksiyondur; bu, konumlarını kullanarak öğelere erişemeyeceğiniz anlamına gelir. Bu, öğelerin sırası önemli olmadığında kullanışlıdır.

Aşağıdaki Python kodu, sıra ve indeksleme kümelerini gösterir:

# Creating a Python set
my_set = {3, 5, 2, 8, 1}

# Sets are unordered, so you cannot access elements using their position
# This would raise an error: first_element = my_set[0]

# Modifying a set by adding or removing elements
my_set.add(6)       # The set becomes {1, 2, 3, 5, 6, 8}
my_set.discard(5)   # The set becomes {1, 2, 3, 6, 8}

# Iterating over a set (order is not guaranteed)
for item in my_set:
    print(item)

2. Değişkenlik

Python Listesi: Bir Python listesi değişkendir ve öğelerini değiştirmenize olanak tanır. Yuvalanmış listeler de dahil olmak üzere her türlü nesneyi tutabilirler, böylece saklayabilecekleri içerik açısından daha fazla esneklik sunarlar.

Aşağıdaki kod, Python listelerinde değişebilirliği gösterir:

# Creating a Python list
my_list = [3, 5, 2, 8, 1]

# Modifying the list by appending elements
my_list.append(4)  # The list becomes [3, 5, 2, 8, 1, 4]

# Modifying the list by removing elements
my_list.remove(2)  # The list becomes [3, 5, 8, 1, 4]

# Lists can hold any type of object, including nested lists
nested_list = [1, 2, [3, 4], 5]

Python Kümesi: Tıpkı Python'daki bir liste gibi , bir Python seti de değişkendir ve değiştirilebilir. Bununla birlikte, Python'daki kümeler yalnızca hashable (değişmez) nesneleri tutabilir, yani bir kümeler kümeniz veya listeler gibi değişken nesneler içeren bir kümeniz olamaz.

Aşağıdaki kod, Python kümelerinin değişebilirliğini gösterir:

# Creating a Python set
my_set = {3, 5, 2, 8, 1}

# Modifying the set by adding elements
my_set.add(6)       # The set becomes {1, 2, 3, 5, 6, 8}

# Modifying the set by removing elements
my_set.discard(5)   # The set becomes {1, 2, 3, 6, 8}

# Sets can only hold hashable (immutable) objects
valid_set = {1, 2, 3, 4, (5, 6)}

# The following would raise an error because lists are mutable and cannot be stored in sets
# invalid_set = {1, 2, [3, 4]}

Unsurların Benzersizliği

Python Kümeleri: Kümelerin önemli bir özelliği, yalnızca benzersiz öğeleri depolamalarıdır. Bir listeye yinelenen değerlerin eklenmesi yoksayılır. Bu, bir küme nesnesini, kopyaları kaldırmak veya benzersiz öğelerin varlığını kontrol etmek gibi farklı küme işlemleri için ideal hale getirir.

# Creating a Python set with duplicate elements
my_set = {3, 5, 2, 8, 1, 3, 2, 5}
# The duplicate elements are automatically removed: {1, 2, 3, 5, 8}

# Checking for the presence of a unique element
if 5 in my_set:
    print("5 is in the set")
# Output: 5 is in the set

# Removing duplicates from a list using a set
my_list = [3, 5, 2, 8, 1, 3, 2, 5]
unique_list = list(set(my_list))
# The unique_list becomes [1, 2, 3, 5, 8]

• 

  Python Listeleri: Listeler, yinelenen değerlere izin verir ve bunların sırasını korur; bu, yinelenenlerin ve öğe sırasının önemli bir rol oynadığı kullanım durumlarında gerekli olabilir.

  # Creating a Python list with duplicate elements
  my_list = [3, 5, 2, 8, 1, 3, 2, 5]
  # The list contains duplicate values: [3, 5, 2, 8, 1, 3, 2, 5]
  
  # Checking for the presence of an element in a list
  if 5 in my_list:
      print("5 is in the list")
  # Output: 5 is in the list
  
  # Counting the occurrences of a value in a list
  count_of_5 = my_list.count(5)
  print("5 appears", count_of_5, "times")
  # Output: 5 appears 2 times

  

3. Desteklenen İşlemler

Her biri belirli görevler için optimize edilmiş kümeler ve listeler üzerinde gerçekleştirilebilecek farklı işlemler vardır:

Python Lists: Due to their ordered and index-based nature, lists support operations like slicing, concatenation, repetition, and list comprehension. They also provide built-in methods, such as append(), pop(), and sort(), that allow you to manipulate elements of a list.

# Creating a Python list
my_list = [3, 5, 2, 8, 1]

# Slicing a list
sub_list = my_list[1:4]  # The sub_list becomes [5, 2, 8]

# Concatenation of two lists
list1 = [1, 2, 3]
list2 = [4, 5, 6]
concatenated_list = list1 + list2  # The concatenated_list becomes [1, 2, 3, 4, 5, 6]

# Repetition of a list
repeated_list = list1 * 2  # The repeated_list becomes [1, 2, 3, 1, 2, 3]

# List comprehension
squared_list = [x ** 2 for x in my_list]  # The squared_list becomes [9, 25, 4, 64, 1]

# Using built-in methods
my_list.append(4)  # The list becomes [3, 5, 2, 8, 1, 4]
my_list.pop()      # The list becomes [3, 5, 2, 8, 1]
my_list.sort()     # The list becomes [1, 2, 3, 5, 8]

Python Sets: Sets are optimized for performing set-related operations like union, intersection, difference, and checking membership using hash functions to find elements quickly. Since they are unordered and lack indexing, set operations differ from list-based ones.

# Creating Python sets
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# Union operation
union_set = set1.union(set2)  # The union_set becomes {1, 2, 3, 4, 5, 6, 7, 8}

# Intersection operation
intersection_set = set1.intersection(set2)  # The intersection_set becomes {4, 5}

# Difference operation
difference_set = set1.difference(set2)  # The difference_set becomes {1, 2, 3}

# Checking membership
if 3 in set1:
    print("3 is a member of set1")
# Output: 3 is a member of set1

How Do You Choose The Right Data Structure?

When working with Python, it’s essential to select the most suitable data structure for your specific task. In this section, we will discuss the best scenarios for using sets and lists, along with their unique advantages.

Let’s get into it.

Use Cases for Sets

Sets offer several advantages that make them the ideal choice for certain tasks:

Uniqueness: If you need to store a collection of unique elements, sets are the way to go. Sets automatically eliminate duplicates, ensuring that each element in the set is distinct.

Membership tests: Sets provide faster membership tests compared to lists. Due to their underlying hash table implementation and the use of hash functions, sets allow for highly efficient lookups based on hash values.

Set operations: Sets support operations such as union, intersection, difference, and symmetric difference that can be useful in many algorithms, data processing tasks, and data science applications.

Use Cases for Lists

Lists are better suited for the following scenarios:

Ordered data: Lists maintain the order of elements, making them suitable for tasks that require respecting the sequence of items, such as processing data in the order it was created or when support indexing is needed.

Mutable data: Lists are mutable, allowing you to add, remove, or modify a specific element as needed. This flexibility makes lists suitable for tasks that involve changing the content of the collection or when working with nested data structures, such as lists of lists or dictionaries.

Non-unique elements: Unlike sets, lists can store duplicate elements, making them appropriate for situations where the frequency of items matters, such as counting occurrences or maintaining the order of duplicate values.

Check out the below to show to further your learning.

APerformance Comparison Between Sets and Lists

In this section, we will compare the performance of Python sets and lists in terms of time complexity and memory usage, which is essential when working with large data structures or when optimizing code for efficiency.

Time Complexity

When it comes to time complexity, sets and lists have different strengths and weaknesses depending on the operations you perform due to their underlying implementation.

1. Searching: Sets use hash lookups and hash functions, which makes searching for an item significantly faster compared to lists. For example, searching through 100,000 items takes 49.663 seconds with a list, but only 0.007 seconds with a set, as it takes advantage of the hash value for quick access.

2. Yineleme: Öğeler üzerinde yineleme söz konusu olduğunda, listeler kümelerden biraz daha hızlıdır. Bunun nedeni, kümelerin benzersizliği sağlamak için ek işlemler gerektirmesi, listelerin ise doğrudan indeksleme ile basit sıralı bir koleksiyonu sürdürmesidir.

Hafıza kullanımı

Kümeler, artan bellek tüketimi pahasına, öğelerin benzersizliğini sağlamak için bir karma tablo tutmaları gerektiğinden, genellikle listelerden daha fazla bellek tüketir.

Listeler, öğeleri yalnızca sıralı olarak depolar, bu da daha düşük bellek tüketimine yol açar ve büyük veri koleksiyonlarını işlerken bellek açısından daha verimli bir seçim haline getirir.

import time
import random

# Generating a large list and set with 100,000 random integers
large_list = [random.randint(1, 1_000_000) for _ in range(100_000)]
large_set = set(large_list)

# Searching for an item in the list and set
search_value = random.randint(1, 1_000_000)

# Measuring the time it takes to search for the item in the list
start_time = time.time()
result = search_value in large_list
end_time = time.time()
list_search_time = end_time - start_time
print(f"List search time: {list_search_time:.6f} seconds")

# Measuring the time it takes to search for the item in the set
start_time = time.time()
result = search_value in large_set
end_time = time.time()
set_search_time = end_time - start_time
print(f"Set search time: {set_search_time:.6f} seconds")

# Iterating over the list and set
# Measuring the time it takes to iterate over the list
start_time = time.time()
for item in large_list:
    pass
end_time = time.time()
list_iter_time = end_time - start_time
print(f"List iteration time: {list_iter_time:.6f} seconds")

# Measuring the time it takes to iterate over the set
start_time = time.time()
for item in large_set:
    pass
end_time = time.time()
set_iter_time = end_time - start_time
print(f"Set iteration time: {set_iter_time:.6f} seconds")

Sağlanan kod, arama ve yineleme için zaman karmaşıklığı açısından Python kümeleri ve listeleri arasındaki performans karşılaştırmasını gösterir.

Küme parantezler (kıvrık ayraçlar olarak da adlandırılır) içine alınmış büyük bir liste ve rasgele tamsayılar kümesi oluşturur.

Ardından, hem listede hem de kümede tek bir bağımsız değişken kullanarak belirli bir öğeyi aramak için geçen süreyi ölçer ve listedeki ve kümedeki tüm öğeleri yinelemek için geçen süreyi ölçer.

Çıktı, Python listeleri ile bunların temel uygulamalarından kaynaklanan arama ve yineleme kümeleri arasındaki performans farklılıklarını gösterir.

Etkili aramalar için karma değerleri hesaplamak amacıyla karma işlevlerinin kullanılması nedeniyle, arama işlemi kümelerde (0,000000 saniye) listelerden (0,002999 saniye) daha hızlıdır. Bununla birlikte, bir liste üzerinde yineleme (0,007995 saniye), bir küme üzerinde yinelemeden (0,017989 saniye) biraz daha hızlıdır, çünkü kümeler benzersizliği sağlamak için ek işlemler gerektirir.

Ortak İşlemler ve Yöntemler

Python'daki hem kümeler hem de listeler, her biri belirli görevler ve veri işleme için optimize edilmiş çeşitli işlemlere ve yöntemlere sahiptir. Bu yöntemlerden bazıları aşağıda listelenmiştir:

Yöntemi Ayarla

Küme yöntemleri, matematiksel işlemlere benzer işlemler gerçekleştirir ve bir koleksiyondaki benzersiz değerleri işlemek için güçlü araçlardır.

• add(element): Kümeye henüz mevcut değilse bir eleman ekler.

• remove(element): Belirtilen elemanı kümeden siler; eleman bulunamazsa hata verir.

• throw(element): Belirtilen öğe varsa kümeden siler. Eleman bulunamazsa hata oluşmaz.

• union(set2): Etkili bir set işlemi gerçekleştirerek, orijinal set ve set2'deki tüm öğeleri içeren yeni bir set döndürür.

• kesişim(küme2): Hem orijinal kümede hem de küme2'de ortak olan öğeleri içeren yeni bir küme döndürür.

• fark(küme2): Orijinal kümedeki öğeleri içeren ancak küme2'deki öğeleri içermeyen yeni bir küme döndürür.

• symmetric_difference(küme2): Öğeleri orijinal kümede veya küme2'de içeren, ancak her ikisinde birden olmayan yeni bir küme döndürür.

Liste Yöntemi

Liste yöntemleri, verileri işlemek için çeşitli yollar sağlar.

• append(element): Listenin sonuna bir eleman ekler.

• genişlet(yinelenebilir): Yinelenebilirden (örneğin, başka bir liste) tüm öğeleri listenin sonuna ekler.

• insert(index, element): Belirtilen dizine bir eleman ekler.

• remove(element): Belirtilen öğenin listedeki ilk örneğini kaldırır; eleman mevcut değilse bir hata verir.

• pop(index): Belirtilen dizindeki öğeyi kaldırır ve döndürür. İndeks verilmezse, son elemanı kaldırır.

• index(element): Belirtilen öğenin listedeki ilk geçtiği dizinin dizinini döndürür.

• count(element): Belirtilen öğenin listedeki oluşum sayısını döndürür.

• sort(): Listeyi varsayılan olarak artan düzende sıralar; azalan sıralama için reverse=True parametresini kullanın.

• reverse(): Listedeki elemanların sırasını ters çevirir.

Bu Python kümeleme ve listeleme yöntemlerini kullanarak verilerinizi etkili bir şekilde işleyebilir ve Python programlama, veri bilimi ve diğer uygulamalardaki çeşitli sorunları çözebilirsiniz.

Son Sözümüz

Veri yapınız için Python listeleri ve kümeleri arasında seçim yaparken, sıralı bir öğe koleksiyonuna ihtiyaç duyduğunuzda, yinelenen öğeleri korumak istediğinizde ve öğelere dizine göre erişme olanağı gerektirdiğinde listeleri kullanmayı düşünün.

Öğelerin benzersizliğinin önemli olduğu, öğelerin sırasının önemli olmadığı ve daha hızlı üyelik testinin tercih edildiği durumlarda kümeleri tercih edin. Listeler yinelemede mükemmel olsa da, kümeler daha verimli kontroller sağlar.

Her veri yapısı kendi avantajlarını ve sınırlamalarını sunarak onları Python programlamadaki çeşitli görevlerin üstesinden gelmek için güçlü araçlar haline getirdiğinden, seçiminiz nihai olarak projenizin gereksinimlerine bağlıdır. Eğlence!