set

Jenis set bawaan. Set adalah kumpulan nilai unik yang dapat diubah dan dapat diiterasi – elemen set. Nama jenis set adalah "set".

Set menyediakan operasi waktu konstan untuk menyisipkan, menghapus, atau memeriksa keberadaan nilai. Set diimplementasikan menggunakan tabel hash, dan oleh karena itu, seperti kunci kamus, elemen set harus dapat di-hash. Nilai dapat digunakan sebagai elemen set jika dan hanya jika nilai tersebut dapat digunakan sebagai kunci kamus.

Set dapat dibuat menggunakan fungsi bawaan set(), yang menampilkan set baru yang berisi elemen unik dari argumen opsionalnya, yang harus berupa iterable. Memanggil set() tanpa argumen akan membuat set kosong. Set tidak memiliki sintaksis literal.

Operasi in dan not in memeriksa apakah suatu nilai ada (atau tidak ada) dalam kumpulan:

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

Set dapat diiterasi, sehingga dapat digunakan sebagai operand loop for, pemahaman daftar, dan berbagai fungsi bawaan yang beroperasi pada iterable. Panjangnya dapat diambil menggunakan fungsi bawaan len(), dan urutan iterasi adalah urutan saat elemen pertama kali ditambahkan ke set:

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"

Set yang digunakan dalam konteks Boolean bernilai benar jika dan hanya jika tidak kosong.

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

Set dapat dibandingkan untuk kesetaraan atau ketidaksetaraan menggunakan == dan !=. Kumpulan s sama dengan t jika dan hanya jika t adalah kumpulan yang berisi elemen yang sama; urutan iterasi tidak signifikan. Secara khusus, set tidak sama dengan daftar elemennya. Set tidak diurutkan berdasarkan set lainnya, dan upaya untuk membandingkan dua set menggunakan <, <=, >, >=, atau untuk mengurutkan urutan set, akan gagal.

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

Operasi | pada dua set menampilkan gabungan dari kedua set tersebut: set yang berisi elemen yang ditemukan di salah satu atau kedua set asli.

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

Operasi & pada dua set menampilkan persimpangan kedua set: set yang hanya berisi elemen yang ditemukan di kedua set asli.

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

Operasi - pada dua set menampilkan perbedaan kedua set: set yang berisi elemen yang ditemukan di set sisi kiri, tetapi tidak di set sisi kanan.

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

Operasi ^ pada dua set menampilkan selisih simetris dari kedua set: set yang berisi elemen yang ditemukan tepat di salah satu dari dua set asli, tetapi tidak di keduanya.

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

Dalam setiap operasi di atas, elemen set yang dihasilkan mempertahankan urutannya dari dua set operand, dengan semua elemen yang diambil dari sisi kiri diurutkan sebelum elemen yang hanya ada di sisi kanan.

Penugasan yang ditingkatkan yang sesuai, |=, &=, -=, dan ^=, mengubah set sebelah kiri di tempatnya.

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])

Seperti semua nilai yang dapat diubah di Starlark, set dapat dibekukan, dan setelah dibekukan, semua operasi berikutnya yang mencoba memperbaruinya akan gagal.

Anggota

• tambahkan
• hapus
• perbedaan
• difference_update
• buang
• intersection
• intersection_update
• isdisjoint
• issubset
• issuperset
• pop
• hapus
• symmetric_difference
• symmetric_difference_update
• union
• update

tambahkan

None set.add(element)

Anda dapat add nilai yang sudah ada dalam set; hal ini tidak akan mengubah set.

Jika Anda perlu menambahkan beberapa elemen ke set, lihat update atau operasi penetapan yang di-augment |=.

Parameter

hapus

None set.clear()

selisih

set set.difference(*others)

Jika s dan t adalah set, s.difference(t) setara dengan s - t; namun, perhatikan bahwa operasi - mengharuskan kedua sisi berupa set, sedangkan metode difference juga menerima urutan dan dict.

difference dapat dipanggil tanpa argumen apa pun; hal ini akan menampilkan salinan set.

Misalnya,

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

Parameter

difference_update

None set.difference_update(*others)

Jika s dan t adalah set, s.difference_update(t) setara dengan s -= t; namun, perhatikan bahwa penetapan tambahan -= memerlukan kedua sisi berupa set, sedangkan metode difference_update juga menerima urutan dan dict.

Anda dapat memanggil difference_update tanpa argumen; hal ini membuat set tidak berubah.

Misalnya,

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])

Parameter

hapus

None set.discard(element)

Nilai yang tidak ada dalam set boleh discard; hal ini tidak mengubah set. Jika Anda ingin gagal saat mencoba menghapus elemen yang tidak ada, gunakan remove. Jika Anda perlu menghapus beberapa elemen dari set, lihat difference_update atau operasi penetapan yang di-augment -=.

Misalnya,

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

Parameter

irisan

set set.intersection(*others)

Jika s dan t adalah set, s.intersection(t) setara dengan s & t; namun, perhatikan bahwa operasi & mengharuskan kedua sisi berupa set, sedangkan metode intersection juga menerima urutan dan dict.

intersection dapat dipanggil tanpa argumen apa pun; hal ini akan menampilkan salinan set.

Misalnya,

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

Parameter

intersection_update

None set.intersection_update(*others)

Jika s dan t adalah set, s.intersection_update(t) setara dengan s &= t; namun, perhatikan bahwa penetapan augmented &= mengharuskan kedua sisi berupa set, sedangkan metode intersection_update juga menerima urutan dan dict.

Anda dapat memanggil intersection_update tanpa argumen; hal ini membuat set tidak berubah.

Misalnya,

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])

Parameter

isdisjoint

bool set.isdisjoint(other)

Misalnya,

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

Parameter

issubset

bool set.issubset(other)

Perhatikan bahwa set selalu dianggap sebagai subset dari dirinya sendiri.

Misalnya,

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

Parameter

issuperset

bool set.issuperset(other)

Perhatikan bahwa himpunan selalu dianggap sebagai superset dari dirinya sendiri.

Misalnya,

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

Parameter

pop

unknown set.pop()

Gagal jika set kosong.

Misalnya,

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

hapus

None set.remove(element)

remove akan gagal jika elemen tidak ada dalam set. Jika Anda tidak ingin gagal saat mencoba menghapus elemen yang tidak ada, gunakan discard. Jika Anda perlu menghapus beberapa elemen dari set, lihat difference_update atau operasi penetapan yang di-augmentasi -=.

Parameter

symmetric_difference

set set.symmetric_difference(other)

Jika s dan t adalah set, s.symmetric_difference(t) setara dengan s ^ t; namun, perhatikan bahwa operasi ^ mengharuskan kedua sisi berupa set, sedangkan metode symmetric_difference juga menerima urutan atau dict.

Misalnya,

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

Parameter

symmetric_difference_update

None set.symmetric_difference_update(other)

Jika s dan t adalah set, s.symmetric_difference_update(t) setara dengan penetapan yang ditambah `s ^= t; however, note that the ^=` memerlukan kedua sisi berupa set, sedangkan metode symmetric_difference_update juga menerima urutan atau dict.

Misalnya,

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

Parameter

Union

set set.union(*others)

Jika s dan t adalah set, s.union(t) setara dengan s | t; namun, perhatikan bahwa operasi | mengharuskan kedua sisi berupa set, sedangkan metode union juga menerima urutan dan dict.

union dapat dipanggil tanpa argumen; hal ini akan menampilkan salinan set.

Misalnya,

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])

Parameter

update

None set.update(*others)

Misalnya,

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])

Jika s dan t adalah set, s.update(t) setara dengan s |= t; namun, perhatikan bahwa penetapan augmented |= memerlukan kedua sisi berupa set, sedangkan metode update juga menerima urutan dan dict.

Anda dapat memanggil update tanpa argumen apa pun; hal ini tidak akan mengubah set.

Parameter