ayarla

Yerleşik küme türü. Küme, benzersiz değerlerden oluşan değiştirilebilir ve yinelenebilir bir koleksiyondur. Bu değerler, kümenin öğeleridir. Bir kümenin tür adı "set"'dir.

Kümeler, değer eklemek, kaldırmak veya değerin varlığını kontrol etmek için sabit zamanlı işlemler sağlar. Kümeler, karma tablo kullanılarak uygulandığından sözlük anahtarları gibi küme öğeleri de karma oluşturulabilir olmalıdır. Bir değer, yalnızca sözlüğün anahtarı olarak kullanılabiliyorsa kümenin öğesi olarak kullanılabilir.

Kümeler, isteğe bağlı bağımsız değişkeninin benzersiz öğelerini içeren yeni bir küme döndüren set() yerleşik işlevi kullanılarak oluşturulabilir. Bu bağımsız değişken, yinelenebilir olmalıdır. Bağımsız değişken olmadan set() işlevini çağırmak boş bir küme oluşturur. Kümelerin değişmez söz dizimi yoktur.

in ve not in işlemleri, bir değerin kümede olup olmadığını kontrol eder:

s = set(["a", "b", "c"])
"a" in s  # True
"z" in s  # False

Bir küme yinelenebilir olduğundan for döngüsünün, liste kapsamının ve yinelenebilir öğeler üzerinde çalışan çeşitli yerleşik işlevlerin işleneni olarak kullanılabilir. Uzunluğu, len() yerleşik işlevi kullanılarak alınabilir. Yineleme sırası, öğelerin kümeye ilk eklendiği sıradır:

s = set(["z", "y", "z", "y"])
len(s)       # prints 2
s.add("x")
len(s)       # prints 3
for e in s:
    print e  # prints "z", "y", "x"

Boole bağlamında kullanılan bir küme, yalnızca boş değilse doğrudur.

s = set()
"non-empty" if s else "empty"  # "empty"
t = set(["x", "y"])
"non-empty" if t else "empty"  # "non-empty"

Kümeler, == ve != kullanılarak eşitlik veya eşitsizlik açısından karşılaştırılabilir. Bir küme s, yalnızca t aynı öğeleri içeren bir küme ise t değerine eşittir. Yineleme sırası önemli değildir. Özellikle, bir küme, öğelerinin listesine eşit değildir. Kümeler diğer kümelere göre sıralanmaz ve <, <=, >, >= kullanarak iki kümeyi karşılaştırma veya bir dizi kümeyi sıralama girişimi başarısız olur.

set() == set()              # True
set() != []                 # True
set([1, 2]) == set([2, 1])  # True
set([1, 2]) != [1, 2]       # True

İki küme üzerinde yapılan | işlemi, iki kümenin birleşimini döndürür: orijinal kümelerden birinde veya her ikisinde de bulunan öğeleri içeren bir küme.

set([1, 2]) | set([3, 2])  # set([1, 2, 3])

İki küme üzerinde yapılan & işlemi, iki kümenin kesişimini döndürür: yalnızca orijinal kümelerin her ikisinde de bulunan öğeleri içeren bir küme.

set([1, 2]) & set([2, 3])  # set([2])
set([1, 2]) & set([3, 4])  # set()

İki küme üzerinde yapılan - işlemi, iki kümenin farkını döndürür: sol taraftaki kümede bulunan ancak sağ taraftaki kümede bulunmayan öğeleri içeren bir küme.

set([1, 2]) - set([2, 3])  # set([1])
set([1, 2]) - set([3, 4])  # set([1, 2])

İki küme üzerinde yapılan ^ işlemi, iki kümenin simetrik farkını döndürür: orijinal iki kümeden yalnızca birinde bulunan ancak her ikisinde de bulunmayan öğeleri içeren bir küme.

set([1, 2]) ^ set([2, 3])  # set([1, 3])
set([1, 2]) ^ set([3, 4])  # set([1, 2, 3, 4])

Yukarıdaki işlemlerin her birinde, sonuçta elde edilen kümenin öğeleri iki işlenen kümedeki sıralarını korur. Sol taraftan alınan tüm öğeler, yalnızca sağ tarafta bulunan öğelerden önce sıralanır.

İlgili artırılmış atamalar (|=, &=, -= ve ^=) sol taraftaki grubu yerinde değiştirir.

s = set([1, 2])
s |= set([2, 3, 4])     # s now equals set([1, 2, 3, 4])
s &= set([0, 1, 2, 3])  # s now equals set([1, 2, 3])
s -= set([0, 1])        # s now equals set([2, 3])
s ^= set([3, 4])        # s now equals set([2, 4])

Starlark'taki tüm değiştirilebilir değerler gibi, bir küme de dondurulabilir. Dondurulduktan sonra, kümeyi güncellemeye yönelik tüm sonraki işlemler başarısız olur.

Üyeler

• ekle
• temizle
• fark
• difference_update
• sil
• kesişim (intersection)
• intersection_update
• isdisjoint
• issubset
• issuperset
• pop
• kaldır
• symmetric_difference
• symmetric_difference_update
• union
• güncelleme

add

None set.add(element)

Kümede zaten bulunan bir değere add izin verilir. Bu durumda küme değişmez.

Bir kümeye birden fazla öğe eklemeniz gerekiyorsa update veya |= artırılmış atama işlemine bakın.

Parametreler

temizle

None set.clear()

fark

set set.difference(*others)

s ve t kümelerse s.difference(t), s - t'e eşdeğerdir. Ancak - işleminin her iki tarafın da küme olmasını gerektirdiğini, difference yönteminin ise dizileri ve sözlükleri de kabul ettiğini unutmayın.

difference işlevini herhangi bir bağımsız değişken olmadan çağırmak mümkündür. Bu durumda, kümenin bir kopyası döndürülür.

Örneğin,

set([1, 2, 3]).difference([2])             # set([1, 3])
set([1, 2, 3]).difference([0, 1], [3, 4])  # set([2])

Parametreler

difference_update

None set.difference_update(*others)

s ve t kümelerse s.difference_update(t), s -= t ile eşdeğerdir. Ancak -= artırılmış atamasının her iki tarafın da küme olmasını gerektirdiğini, difference_update yönteminin ise dizileri ve sözlükleri de kabul ettiğini unutmayın.

difference_update işlevini herhangi bir argüman olmadan çağırmak mümkündür. Bu durumda küme değişmez.

Örneğin,

s = set([1, 2, 3, 4])
s.difference_update([2])             # None; s is set([1, 3, 4])
s.difference_update([0, 1], [4, 5])  # None; s is set([3])

Parametreler

sil

None set.discard(element)

Kümede bulunmayan bir değere discard izin verilir. Bu durumda küme değişmez. Mevcut olmayan bir öğeyi kaldırma girişimi başarısız olsun istiyorsanız bunun yerine remove öğesini kullanın. Bir kümeden birden fazla öğe kaldırmanız gerekiyorsa difference_update veya -= artırılmış atama işlemine bakın.

Örneğin,

s = set(["x", "y"])
s.discard("y")  # None; s == set(["x"])
s.discard("y")  # None; s == set(["x"])

Parametreler

kesişim

set set.intersection(*others)

s ve t kümelerse s.intersection(t), s & t ile eşdeğerdir. Ancak & işleminin her iki tarafın da küme olmasını gerektirdiğini, intersection yönteminin ise dizileri ve sözlükleri de kabul ettiğini unutmayın.

intersection işlevini herhangi bir bağımsız değişken olmadan çağırmak mümkündür. Bu durumda, kümenin bir kopyası döndürülür.

Örneğin,

set([1, 2]).intersection([2, 3])             # set([2])
set([1, 2, 3]).intersection([0, 1], [1, 2])  # set([1])

Parametreler

intersection_update

None set.intersection_update(*others)

s ve t kümelerse s.intersection_update(t), s &= t ile eşdeğerdir. Ancak &= artırılmış atamasının her iki tarafın da küme olmasını gerektirdiğini, intersection_update yönteminin ise dizileri ve sözlükleri de kabul ettiğini unutmayın.

intersection_update işlevini herhangi bir argüman olmadan çağırmak mümkündür. Bu durumda küme değişmez.

Örneğin,

s = set([1, 2, 3, 4])
s.intersection_update([0, 1, 2])       # None; s is set([1, 2])
s.intersection_update([0, 1], [1, 2])  # None; s is set([1])

Parametreler

isdisjoint

bool set.isdisjoint(other)

Örneğin,

set([1, 2]).isdisjoint([3, 4])  # True
set().isdisjoint(set())         # True
set([1, 2]).isdisjoint([2, 3])  # False

Parametreler

issubset

bool set.issubset(other)

Bir kümenin her zaman kendisinin bir alt kümesi olarak kabul edildiğini unutmayın.

Örneğin,

set([1, 2]).issubset([1, 2, 3])  # True
set([1, 2]).issubset([1, 2])     # True
set([1, 2]).issubset([2, 3])     # False

Parametreler

issuperset

bool set.issuperset(other)

Bir kümenin her zaman kendisinin üst kümesi olarak kabul edildiğini unutmayın.

Örneğin,

set([1, 2, 3]).issuperset([1, 2])     # True
set([1, 2, 3]).issuperset([1, 2, 3])  # True
set([1, 2, 3]).issuperset([2, 3, 4])  # False

Parametreler

pop

unknown set.pop()

Küme boşsa başarısız olur.

Örneğin,

s = set([3, 1, 2])
s.pop()  # 3; s == set([1, 2])
s.pop()  # 1; s == set([2])
s.pop()  # 2; s == set()
s.pop()  # error: empty set

remove

None set.remove(element)

Öğe sette yoksa remove başarısız olur. Mevcut olmayan bir öğeyi kaldırma girişiminde başarısız olmak istemiyorsanız bunun yerine discard kullanın. Bir gruptan birden fazla öğe kaldırmanız gerekiyorsa difference_update veya -= artırılmış atama işlemine bakın.

Parametreler

symmetric_difference

set set.symmetric_difference(other)

s ve t kümelerse s.symmetric_difference(t), s ^ t'e eşdeğerdir. Ancak ^ işleminin her iki tarafın da küme olmasını gerektirdiğini, symmetric_difference yönteminin ise bir diziyi veya sözlüğü de kabul ettiğini unutmayın.

Örneğin,

set([1, 2]).symmetric_difference([2, 3])  # set([1, 3])

Parametreler

symmetric_difference_update

None set.symmetric_difference_update(other)

s ve t kümelerse s.symmetric_difference_update(t), `s ^= t; however, note that the ^=` artırılmış atamasına eşdeğerdir. Bu atama, her iki tarafın da küme olmasını gerektirirken symmetric_difference_update yöntemi bir diziyi veya sözlüğü de kabul eder.

Örneğin,

s = set([1, 2])
s.symmetric_difference_update([2, 3])  # None; s == set([1, 3])

Parametreler

Union

set set.union(*others)

s ve t kümelerse s.union(t), s | t'e eşdeğerdir. Ancak | işleminin her iki tarafın da küme olmasını gerektirdiğini, union yönteminin ise dizileri ve sözlükleri de kabul ettiğini unutmayın.

union işlevini herhangi bir bağımsız değişken olmadan çağırmak mümkündür. Bu durumda, kümenin bir kopyası döndürülür.

Örneğin,

set([1, 2]).union([2, 3])                    # set([1, 2, 3])
set([1, 2]).union([2, 3], {3: "a", 4: "b"})  # set([1, 2, 3, 4])

Parametreler

update

None set.update(*others)

Örneğin,

s = set()
s.update([1, 2])          # None; s is set([1, 2])
s.update([2, 3], [3, 4])  # None; s is set([1, 2, 3, 4])

s ve t kümelerse s.update(t), s |= t ile eşdeğerdir. Ancak |= artırılmış atamasının her iki tarafın da küme olmasını gerektirdiğini, update yönteminin ise dizileri ve sözlükleri de kabul ettiğini unutmayın.

update işlevini herhangi bir bağımsız değişken olmadan çağırmak mümkündür. Bu durumda küme değişmez.

Parametreler