For AI agents: use /llms.txt for the Nakafa content index.
Container mengelompokkan nilai dan menentukan cara kode mengaksesnya. Sequence mempertahankan posisi, mapping menghubungkan kunci dengan nilai, sedangkan set merepresentasikan anggota unik. Memilihnya berarti memilih perilaku, bukan sekadar bentuk kurung.
Sebagian container dapat mencampur tipe objek, tetapi masing-masing memiliki batasan. Kunci dictionary dan anggota set harus hashable, string berisi teks, dan sifat mutability berbeda antar-container.
Pelajaran ini membandingkan lima bentuk collection bawaan:
List adalah sequence yang terurut dan mutable. List dapat memuat nilai dari tipe berbeda, walaupun collection dengan bentuk elemen yang jelas biasanya lebih mudah dipahami.
Berbeda dengan array tingkat rendah yang ukurannya tetap, list Python dapat bertambah dan berkurang. List menyimpan rujukan ke objek Python, sehingga mutasi objek bersarang dapat terlihat melalui setiap rujukan ke objek tersebut.
| Karakteristik | Penjelasan | Contoh |
|---|---|---|
| Ordered | Elemen memiliki urutan tetap | [1, 2, 3] berbeda dengan [3, 2, 1] |
| Heterogeneous | Dapat menampung berbagai tipe data | [1, 'text', 3.14, True] |
| Mutable | Isi dapat diubah setelah dibuat | Dapat menambah, menghapus, atau mengubah elemen |
List dibuat menggunakan tanda kurung siku dengan elemen dipisahkan koma. List dapat berisi item dengan tipe data berbeda atau bahkan list lain.
# Berbagai jenis list berdasarkan tipe data
a = [True, False, True] # Output: [True, False, True] # list of bools
b = [1, 2, 3] # Output: [1, 2, 3] # list of ints
c = [1.5, 2.5, 3.5] # Output: [1.5, 2.5, 3.5] # list of floats
d = ['red', 'green', 'blue'] # Output: ['red', 'green', 'blue'] # list of strings
# List kosong
empty1 = [] # Output: []
empty2 = list() # Output: []
# List heterogen (campuran tipe data)
mixed = [False, 2, 3.5, 'blue'] # Output: [False, 2, 3.5, 'blue']
# List bersarang (nested list)
nested = [1, [2.5, False, 'red'], 3.5, 'blue'] # Output: [1, [2.5, False, 'red'], 3.5, 'blue']Indexing adalah cara mengakses elemen individual dalam list menggunakan nomor posisi. Python menggunakan zero-based indexing, artinya elemen pertama memiliki indeks .
Indexing dalam Python memiliki aturan khusus yang perlu dipahami:
# Contoh indexing pada list bersarang
nested = [1, [2.5, False, 'red'], 3.5, 'blue']
print('nested =', nested) # Output: nested = [1, [2.5, False, 'red'], 3.5, 'blue']
# Indexing elemen utama
print('nested[0] =', nested[0]) # Output: nested[0] = 1
print('nested[-1] =', nested[-1]) # Output: nested[-1] = blue
print('nested[1] =', nested[1]) # Output: nested[1] = [2.5, False, 'red']
# Indexing elemen dalam list bersarang
print('nested[1][2] =', nested[1][2]) # Output: nested[1][2] = red
# Indexing karakter dalam string (double indexing)
print('nested[1][2][1] =', nested[1][2][1]) # Output: nested[1][2][1] = eSlicing adalah teknik untuk mengambil sebagian elemen dari list. Stride memungkinkan kita mengambil elemen dengan interval tertentu, bukan hanya elemen berurutan.
Sintaks lengkap slicing adalah list[start:stop:step] dimana:
start adalah indeks awal (inclusive)stop adalah indeks akhir (exclusive)step adalah interval pengambilan elemen# List untuk contoh slicing
x = [0, 1, 2, 3, 4, 5]
print('x =', x) # Output: x = [0, 1, 2, 3, 4, 5]
# Slicing dasar
print('x[1:4] =', x[1:4]) # Output: x[1:4] = [1, 2, 3]
# Slicing dari indeks negatif sampai akhir
print('x[-3:] =', x[-3:]) # Output: x[-3:] = [3, 4, 5]
# Slicing dengan step (stride)
print('x[1:4:2] =', x[1:4:2]) # Output: x[1:4:2] = [1, 3]
# Membalik list dengan step negatif
print('x[::-1] =', x[::-1]) # Output: x[::-1] = [5, 4, 3, 2, 1, 0]Slicing memilih bagian list yang berurutan atau berjarak tetap. Untuk x = [0, 1, 2, 3, 4, 5], x[1:4] mengambil elemen pada indeks , , dan . Indeks akhir tidak ikut diambil. Jika langkah ditambahkan melalui x[1:4:2], Python mengambil setiap indeks kedua, yaitu indeks dan .
List mendukung berbagai operasi untuk menampilkan dan memanipulasi data. List juga memiliki kesamaan dengan string dalam hal pengaksesan elemen.
# Berbagai cara menampilkan list
nested = [1, [2.5, False, 'red'], 3.5, 'blue']
# Menampilkan dengan assignment
print('nested =', nested)
# Output: nested = [1, [2.5, False, 'red'], 3.5, 'blue']
# Menampilkan tanpa assignment
print(nested)
# Output: [1, [2.5, False, 'red'], 3.5, 'blue']
# Menampilkan dengan fungsi print
print('List content:', nested)
# Output: List content: [1, [2.5, False, 'red'], 3.5, 'blue']List dan string memiliki kesamaan dalam hal pengaksesan elemen. Keduanya mendukung indexing dan slicing dengan pola yang sama.
| Operasi | String | List |
|---|---|---|
| Indexing | Mengambil karakter individual | Mengambil elemen individual |
| Slicing with stride | Mengambil substring | Mengambil sub-list |
Perbedaan utama adalah string bersifat immutable (tidak dapat diubah) sedangkan list bersifat mutable (dapat diubah). Karena sifat mutable ini, list memiliki berbagai method untuk manipulasi data.
| Method | Deskripsi | Contoh Penggunaan |
|---|---|---|
append(element) | Menambah elemen di akhir list | Menambah item baru |
extend(list2) | Menggabung dengan elemen dari list lain | Menggabung dua list |
insert(index, element) | Menyisipkan elemen di posisi tertentu | Menambah di tengah list |
index(element) | Mencari indeks pertama dari elemen | Mencari posisi item |
pop() | Menghapus dan mengembalikan elemen terakhir | Mengambil item terakhir |
reverse() | Membalik urutan list secara langsung | Membalik urutan |
remove(element) | Menghapus kemunculan pertama elemen | Menghapus item tertentu |
sort() | Mengurutkan list secara langsung | Mengurutkan data |
copy() | Membuat salinan list | Menduplikasi list |
count(element) | Menghitung jumlah kemunculan elemen | Menghitung frekuensi |
# Demonstrasi berbagai method list
my_list = [1, 2, 3]
print('Original list:', my_list) # Output: Original list: [1, 2, 3]
# Adding elements
my_list.append(4)
print('After append(4):', my_list) # Output: After append(4): [1, 2, 3, 4]
my_list.extend([5, 6])
print('After extend([5, 6]):', my_list) # Output: After extend([5, 6]): [1, 2, 3, 4, 5, 6]
my_list.insert(0, 0)
print('After insert(0, 0):', my_list) # Output: After insert(0, 0): [0, 1, 2, 3, 4, 5, 6]
# Searching elements
idx = my_list.index(3)
print('Index of 3:', idx) # Output: Index of 3: 3
my_list.append(3)
count = my_list.count(3)
print('Count of 3:', count) # Output: Count of 3: 2
# Removing elements
my_list.remove(3)
print('After remove(3):', my_list) # Output: After remove(3): [0, 1, 2, 4, 5, 6, 3]
popped = my_list.pop()
print('Popped element:', popped) # Output: Popped element: 3
print('After pop():', my_list) # Output: After pop(): [0, 1, 2, 4, 5, 6]
# Organizing elements
my_list.reverse()
print('After reverse():', my_list) # Output: After reverse(): [6, 5, 4, 2, 1, 0]
my_list.sort()
print('After sort():', my_list) # Output: After sort(): [0, 1, 2, 4, 5, 6]
copied = my_list.copy()
print('Copied list:', copied) # Output: Copied list: [0, 1, 2, 4, 5, 6]Python mendukung beberapa jenis list khusus yang memiliki karakteristik dan kegunaan berbeda:
List Kosong
List kosong berguna sebagai wadah awal yang akan diisi data kemudian. Ada dua cara membuat list kosong dengan hasil yang sama.
List Heterogen
List heterogen dapat menampung elemen dengan tipe data berbeda dalam satu container. Ini memberikan fleksibilitas tinggi dalam penyimpanan data.
List Bersarang
List bersarang adalah list yang mengandung list lain sebagai elemennya. Konsep ini memungkinkan pembuatan struktur data multidimensi seperti matriks atau tabel.
# List kosong - dua cara pembuatan
a = [] # Output: []
b = list() # Output: []
# List heterogen - berbagai tipe data
mixed = [False, 2, 3.5, 'blue'] # Output: [False, 2, 3.5, 'blue']
# List bersarang - list dalam list
nested = [1, [2.5, False, 'red'], 3.5, 'blue'] # Output: [1, [2.5, False, 'red'], 3.5, 'blue']
print('Empty list 1:', a)
print('Empty list 2:', b)
print('Mixed types:', mixed)
print('Nested structure:', nested)List bersarang dapat merepresentasikan baris, tree, atau struktur kecil yang menyerupai tabel. Bentuknya tidak otomatis menjadi matriks persegi panjang, dan rujukan berulang dapat menunjuk inner list yang sama. Multiple indexing seperti nested[1][2] mengikuti satu container pada setiap langkah.
Selain list, Python menyediakan tiga jenis container lainnya yang memiliki karakteristik dan kegunaan berbeda.
Tuple adalah struktur data yang mirip dengan list namun bersifat immutable. Tuple mendukung operasi packing dan unpacking yang berguna untuk pertukaran data. Meskipun tuple immutable, tuple dapat berisi referensi ke objek mutable seperti list.
Konsep penting dalam tuple adalah perbedaan antara immutable tuple itu sendiri dengan objek mutable yang dikandungnya. Tuple tidak bisa diubah strukturnya, tapi isi objek mutable di dalamnya masih bisa dimodifikasi.
| Aspek | Tuple | List |
|---|---|---|
| Mutability | Immutable | Mutable |
| Sintaks | () atau tanpa kurung | [] |
| Kegunaan | Data tetap, koordinat | Data yang berubah |
# Tuple syntax - dua cara pembuatan
t1 = (0, 1, 2) # Output: t1 = (0, 1, 2)
t2 = 3, 4, 5 # Output: t2 = (3, 4, 5)
print('t1 =', t1)
print('t2 =', t2)
# Tuple unpacking - memisahkan nilai
a, b, c = t2
print('a, b, c =', a, b, c) # Output: a, b, c = 3 4 5
# Error handling untuk unpacking
try:
a, b = (0, 1, 2) # Terlalu banyak nilai
except ValueError as e:
print('ValueError:', e) # Output: ValueError: too many values to unpack (expected 2)
try:
a, b, c, d = 0, 1, 2 # Nilai tidak cukup
except ValueError as e:
print('ValueError:', e) # Output: ValueError: not enough values to unpack (expected 4, got 3)
# Tuple dengan objek mutable
t = (0, [1, 2, 3], 4)
print('Original t =', t) # Output: Original t = (0, [1, 2, 3], 4)
t[1][0] = 'x' # Mengubah isi list dalam tuple
print('After modifying inner list:', t) # Output: After modifying inner list: (0, ['x', 2, 3], 4)
# Tuple immutable tapi objek di dalamnya bisa mutable
# t[1] = [9, 8, 7] # Error: tidak bisa ganti referensi
# t[1][0] = 'y' # OK: bisa ubah isi objek mutableDictionary menyimpan pasangan kunci-nilai. Setiap kunci harus unik dan hashable, sedangkan nilainya boleh berulang dan mutable. Literal dictionary memakai {} dengan titik dua di antara setiap kunci dan nilai.
# Membuat dictionary
kontak = {'Alice': 'alice@example.com', 'Bob': 'bob@example.com'}
print('kontak =', kontak)
# Output: kontak = {'Alice': 'alice@example.com', 'Bob': 'bob@example.com'}
# Mengakses nilai berdasarkan kunci
print("kontak['Alice'] =", kontak['Alice']) # Output: kontak['Alice'] = alice@example.com
# Menambahkan pasangan kunci-nilai baru
kontak['David'] = 'david@example.com'
print('After adding David:', kontak)
# Output: After adding David: {'Alice': 'alice@example.com', 'Bob': 'bob@example.com', 'David': 'david@example.com'}Set menyimpan elemen unik yang hashable dan mendukung operasi himpunan matematika. Set tidak memiliki posisi semantik atau jaminan urutan insertion. Literal set yang tidak kosong memakai {}, sedangkan set kosong harus dibuat dengan set() karena {} menghasilkan dictionary kosong.
# Membuat set
angka = {1, 2, 3, 4, 5}
print('angka =', sorted(angka)) # Output: angka = [1, 2, 3, 4, 5]
# Menambahkan elemen ke set
angka.add(6)
print('Setelah menambah 6:', sorted(angka)) # Output: Setelah menambah 6: [1, 2, 3, 4, 5, 6]
# Operasi himpunan
genap = {2, 4, 6, 8}
ganjil = {1, 3, 5, 7}
# Union (gabungan)
print('genap | ganjil =', sorted(genap | ganjil))
# Output: genap | ganjil = [1, 2, 3, 4, 5, 6, 7, 8]
# Intersection (irisan)
print('genap & ganjil =', genap & ganjil) # Output: genap & ganjil = set()| Container | Sintaks | Ordered | Mutable | Duplikasi | Kegunaan Utama |
|---|---|---|---|---|---|
| List | [1, 2, 3] | Ya | Ya | Ya | Data yang perlu diubah |
| Tuple | (1, 2, 3) | Ya | Tidak | Ya | Data tetap, koordinat |
| Dictionary | {'a': 1} | Ya* | Ya | Tidak (kunci) | Mapping kunci-nilai |
| Set | {1, 2, 3} | Tidak | Ya | Tidak | Elemen unik, operasi himpunan |
Iterasi dictionary mempertahankan urutan insertion sebagai jaminan bahasa sejak Python
3.7. Memperbarui kunci yang ada mempertahankan posisinya; menghapus lalu memasukkannya kembali menempatkan kunci itu di akhir.