Container Python

Menyimpan Beberapa Nilai dalam Container

Pilih jenis container berdasarkan cara program akan $membaca dan mengubah data$ .

Beberapa container dapat memuat objek dari tipe yang berbeda. Namun, setiap jenis memiliki aturan sendiri. Kunci pada dict dan anggota set, misalnya, harus memiliki nilai hash yang tetap selama digunakan. Jenis container juga menentukan apakah isinya mutable atau immutable.

Python menyediakan lima container bawaan yang umum dipakai:

$String$ menyimpan urutan karakter dan bersifat immutable
$List$ menyimpan urutan elemen dan bersifat mutable
$Tuple$ menyimpan urutan elemen dan bersifat immutable
$Dictionary$ menyimpan $pasangan kunci dan nilai$
$Set$ menyimpan anggota unik tanpa indeks

List dalam Python

Tipe list menyimpan elemen $secara berurutan dan bersifat mutable$ , sehingga isinya dapat diubah setelah dibuat. Satu list boleh memuat nilai dari tipe yang berbeda, meskipun bentuk elemen yang konsisten biasanya lebih mudah diproses.

Berbeda dari array tingkat rendah yang ukurannya tetap, list Python dapat bertambah dan berkurang. Setiap elemennya menyimpan referensi ke objek Python. Jika objek bersarang diubah, perubahan itu dapat diakses melalui setiap referensi yang menunjuk objek yang sama.

Sifat List

Perhatikan $urutan, campuran tipe, dan perubahan isi$ saat memilih list. Urutan berarti setiap elemen memiliki posisi. Ini bukan berarti nilainya otomatis terurut dari kecil ke besar.

Karakteristik	Penjelasan	Contoh
Terurut	Setiap elemen memiliki posisi	`[1, 2, 3]` berbeda dengan `[3, 2, 1]`
Dapat memuat tipe campuran	Elemen tidak harus bertipe sama	`[1, 'teks', 3.14, True]`
Mutable	Isi dapat diubah setelah dibuat	Elemen dapat ditambah, dihapus, atau diganti

Membuat List

Literal list memakai $kurung siku dan koma$ sebagai pemisah elemen. Sebuah list dapat memuat tipe data yang berbeda atau bahkan list lain.

list_creation.py

# Berbagai jenis list berdasarkan tipe data
a = [True, False, True]              # list berisi bool
b = [1, 2, 3]                        # list berisi int
c = [1.5, 2.5, 3.5]                  # list berisi float
d = ['red', 'green', 'blue']         # list berisi string

# List kosong
empty1 = []                          # Hasil: []
empty2 = list()                      # Hasil: []

# List heterogen (campuran tipe data)
mixed = [False, 2, 3.5, 'blue']      # Hasil: [False, 2, 3.5, 'blue']

# List bersarang
nested = [1, [2.5, False, 'red'], 3.5, 'blue']  # Hasil: [1, [2.5, False, 'red'], 3.5, 'blue']

Indexing pada List

Indexing mengambil satu elemen dari list berdasarkan posisinya. Indeks Python dimulai dari $0$ , sehingga elemen pertama berada pada indeks $0$ .

Indexing dalam Python mengikuti aturan berikut:

$Indeks positif$ dimulai dari $0$ untuk elemen pertama
$Indeks negatif$ dimulai dari $-1$ untuk elemen terakhir
$Indeks di luar rentang$ menghasilkan IndexError

list_indexing.py

# Contoh indexing pada list bersarang
nested = [1, [2.5, False, 'red'], 3.5, 'blue']

print('nested =', nested)                    # Hasil: nested = [1, [2.5, False, 'red'], 3.5, 'blue']

# Mengakses elemen utama
print('nested[0] =', nested[0])              # Hasil: nested[0] = 1
print('nested[-1] =', nested[-1])            # Hasil: nested[-1] = blue
print('nested[1] =', nested[1])              # Hasil: nested[1] = [2.5, False, 'red']

# Mengakses elemen dalam list bersarang
print('nested[1][2] =', nested[1][2])        # Hasil: nested[1][2] = red

# Mengakses karakter melalui dua tingkat indeks
print('nested[1][2][1] =', nested[1][2][1])  # Hasil: nested[1][2][1] = e

Slicing dengan Step

Slicing mengambil sebagian elemen dari list. Nilai step menentukan $jarak antarelemen yang dipilih$ .

Sintaks lengkap slicing adalah list[start:stop:step], dengan:

start sebagai indeks awal yang ikut diambil
stop sebagai indeks akhir yang tidak ikut diambil
step sebagai jarak antarindeks

list_slicing.py

# List untuk contoh slicing
x = [0, 1, 2, 3, 4, 5]
print('x =', x)                              # Hasil: x = [0, 1, 2, 3, 4, 5]

# Slicing dasar
print('x[1:4] =', x[1:4])                    # Hasil: x[1:4] = [1, 2, 3]

# Slicing dari indeks negatif sampai akhir
print('x[-3:] =', x[-3:])                    # Hasil: x[-3:] = [3, 4, 5]

# Slicing dengan step
print('x[1:4:2] =', x[1:4:2])                # Hasil: x[1:4:2] = [1, 3]

# Membalik list dengan step negatif
print('x[::-1] =', x[::-1])                  # Hasil: x[::-1] = [5, 4, 3, 2, 1, 0]

Slicing dapat memilih elemen berurutan atau elemen dengan jarak tetap. Untuk x = [0, 1, 2, 3, 4, 5], x[1:4] mengambil elemen pada indeks $1$ , $2$ , dan $3$ . Indeks akhir $4$ tidak ikut diambil. Bentuk x[1:4:2] memakai step $2$ , sehingga Python mengambil indeks $1$ dan $3$ .

Operasi dan Kesamaan dengan String

Tipe list menyediakan operasi untuk membaca dan mengubah data. Cara mengakses elemennya mirip dengan string.

list_output.py

# Berbagai cara menampilkan list
nested = [1, [2.5, False, 'red'], 3.5, 'blue']

# Menampilkan nama dan nilai
print('nested =', nested)
# Hasil: nested = [1, [2.5, False, 'red'], 3.5, 'blue']

# Menampilkan nilai saja
print(nested)
# Hasil: [1, [2.5, False, 'red'], 3.5, 'blue']

# Menampilkan dengan fungsi print
print('Isi list:', nested)
# Hasil: Isi list: [1, [2.5, False, 'red'], 3.5, 'blue']

list dan string sama-sama mendukung indexing dan slicing.

Operasi	String	List
$Indexing$	Mengambil satu karakter	Mengambil satu elemen
$Slicing dengan step$	Mengambil bagian string	Mengambil bagian `list`

Perbedaan utamanya, string bersifat immutable, sedangkan list bersifat mutable. Artinya, isi string tidak dapat diubah setelah dibuat, tetapi elemen list dapat ditambah, dihapus, atau diganti. Python menyediakan sejumlah method untuk melakukan operasi tersebut pada list.

Method pada List

Method	Deskripsi	Contoh Penggunaan
`append(element)`	Menambah elemen di akhir `list`	Menambah elemen baru
`extend(list2)`	Menambahkan semua elemen dari `list` lain	Menggabungkan dua `list`
`insert(index, element)`	Menyisipkan elemen pada posisi tertentu	Menambah elemen 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` yang sama	Mengurutkan data
`copy()`	Membuat shallow copy	Menyalin `list` tanpa menyalin objek bersarang
`count(element)`	Menghitung jumlah kemunculan elemen	Menghitung frekuensi

list_methods.py

# Demonstrasi berbagai method list
my_list = [1, 2, 3]
print('List awal:', my_list)                # Hasil: List awal: [1, 2, 3]

# Menambah elemen
my_list.append(4)
print('Setelah append(4):', my_list)        # Hasil: Setelah append(4): [1, 2, 3, 4]

my_list.extend([5, 6])
print('Setelah extend([5, 6]):', my_list)   # Hasil: Setelah extend([5, 6]): [1, 2, 3, 4, 5, 6]

my_list.insert(0, 0)
print('Setelah insert(0, 0):', my_list)     # Hasil: Setelah insert(0, 0): [0, 1, 2, 3, 4, 5, 6]

# Searching elements
idx = my_list.index(3)
print('Indeks nilai 3:', idx)               # Hasil: Indeks nilai 3: 3

my_list.append(3)
count = my_list.count(3)
print('Jumlah nilai 3:', count)             # Hasil: Jumlah nilai 3: 2

# Menghapus elemen
my_list.remove(3)
print('Setelah remove(3):', my_list)        # Hasil: Setelah remove(3): [0, 1, 2, 4, 5, 6, 3]

popped = my_list.pop()
print('Elemen yang diambil:', popped)       # Hasil: Elemen yang diambil: 3
print('Setelah pop():', my_list)            # Hasil: Setelah pop(): [0, 1, 2, 4, 5, 6]

# Menyusun elemen
my_list.reverse()
print('Setelah reverse():', my_list)        # Hasil: Setelah reverse(): [6, 5, 4, 2, 1, 0]

my_list.sort()
print('Setelah sort():', my_list)           # Hasil: Setelah sort(): [0, 1, 2, 4, 5, 6]

copied = my_list.copy()
print('Salinan list:', copied)              # Hasil: Salinan list: [0, 1, 2, 4, 5, 6]

Method copy() membuat $list luar yang baru$ , tetapi objek bersarang tetap dipakai bersama. Mengubah salinan[0][0] terlihat pada kedua list, sedangkan menambahkan baris hanya mengubah list luar salinan.

shallow_copy.py

original = [[1, 2], [3, 4]]
salinan = original.copy()
salinan[0][0] = 99
print(original)  # Output: [[99, 2], [3, 4]]
print(salinan)   # Output: [[99, 2], [3, 4]]

salinan.append([5, 6])
print(len(original), len(salinan))  # Output: 2 3

Bentuk List yang Umum

Sebuah list dapat kosong, memuat tipe campuran, atau bersarang:

$List kosong$

[] dan list() sama-sama membuat list kosong yang dapat diisi kemudian.
$List dengan tipe campuran$

Satu list dapat berisi nama, umur, dan nilai bool. Gunakan bentuk campuran hanya jika setiap posisi memang memiliki arti yang jelas.
$List bersarang$

list bersarang memuat list lain sebagai elemen. Jika setiap bagian dalam memiliki panjang yang sama, susunan ini dapat mewakili baris pada tabel atau matriks.

special_lists.py

# List kosong - dua cara pembuatan
a = []                                       # Hasil: []
b = list()                                   # Hasil: []

# List heterogen - berbagai tipe data
mixed = [False, 2, 3.5, 'blue']             # Hasil: [False, 2, 3.5, 'blue']

# List bersarang - list dalam list
nested = [1, [2.5, False, 'red'], 3.5, 'blue']  # Hasil: [1, [2.5, False, 'red'], 3.5, 'blue']

print('List kosong 1:', a)
print('List kosong 2:', b)
print('Tipe campuran:', mixed)
print('Struktur bersarang:', nested)

list bersarang dapat mewakili baris, pohon, atau struktur kecil yang menyerupai tabel. Susunan list bersarang tidak otomatis menjadi matriks persegi panjang. Beberapa elemen juga dapat merujuk ke list bagian dalam yang sama. Indexing bertingkat seperti nested[1][2] memilih satu elemen pada setiap tingkat.

Container Lain

Tiga container lain yang sering dipakai memiliki aturan berbeda tentang urutan, duplikat, dan perubahan isi. tuple menetapkan posisinya, dict memetakan setiap key unik ke satu nilai, dan set hanya menyimpan $item yang unik$ tanpa menjanjikan urutan.

Tuple Python

Tipe tuple menyerupai list, tetapi $elemen pada setiap posisinya tidak dapat diganti$ setelah tuple dibuat. Beberapa nilai dapat dikemas ke dalam satu tuple, lalu di-unpack ke beberapa variabel.

Posisi dalam tuple tidak dapat diubah. Namun, sebuah posisi dapat merujuk ke objek seperti list yang isinya masih dapat berubah.

Aspek	Tuple	List
$Perubahan isi$	Posisi tidak dapat diubah	Posisi dan isi dapat diubah
$Sintaks$	`()` atau tanpa kurung	`[]`
$Kegunaan$	Data dengan posisi tetap, seperti koordinat	Data yang perlu ditambah atau diubah

tuple_operations.py

# Tuple syntax - dua cara pembuatan
t1 = (0, 1, 2)                               # Hasil: t1 = (0, 1, 2)
t2 = 3, 4, 5                                 # Hasil: t2 = (3, 4, 5)
print('t1 =', t1)
print('t2 =', t2)

# Unpacking tuple ke beberapa variabel
a, b, c = t2
print('a, b, c =', a, b, c)                  # Hasil: a, b, c = 3 4 5

# Menangani error saat jumlah variabel tidak sesuai
try:
  a, b = (0, 1, 2)                         # Terlalu banyak nilai
except ValueError as e:
  print('ValueError:', e)                  # Hasil: 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)                  # Hasil: ValueError: not enough values to unpack (expected 4, got 3)

# Tuple dengan objek yang dapat diubah
t = (0, [1, 2, 3], 4)
print('Nilai awal t =', t)                 # Hasil: Nilai awal t = (0, [1, 2, 3], 4)
t[1][0] = 'x'                               # Mengubah isi list dalam tuple
print('Setelah list di dalamnya diubah:', t)  # Hasil: Setelah list di dalamnya diubah: (0, ['x', 2, 3], 4)

# Posisi tuple tetap, tetapi objek di dalamnya masih dapat berubah
# t[1] = [9, 8, 7]  # Error: tidak bisa ganti referensi
# t[1][0] = 'y'     # Bisa mengubah isi objek tersebut

Dictionary Python

Tipe dict menyimpan pasangan kunci dan nilai. Setiap kunci harus $unik dan memiliki nilai hash yang tetap$ selama digunakan. Nilai dalam pasangan boleh berulang dan dapat merujuk ke objek mutable. Literal dict memakai {} dengan titik dua di antara kunci dan nilai.

dictionary_examples.py

# Membuat dictionary
kontak = {'Alice': 'alice@example.com', 'Bob': 'bob@example.com'}
print('kontak =', kontak)
# Hasil: kontak = {'Alice': 'alice@example.com', 'Bob': 'bob@example.com'}

# Mengakses nilai berdasarkan kunci
print("kontak['Alice'] =", kontak['Alice'])  # Hasil: kontak['Alice'] = alice@example.com

# Menambahkan pasangan kunci-nilai baru
kontak['David'] = 'david@example.com'
print('Setelah menambah David:', kontak)
# Hasil: Setelah menambah David: {'Alice': 'alice@example.com', 'Bob': 'bob@example.com', 'David': 'david@example.com'}

Set Python

Tipe set menyimpan anggota unik yang memiliki nilai hash tetap dan mendukung operasi himpunan matematika. set tidak menyediakan indeks dan $tidak menjamin urutan iterasi$ . Literal set yang tidak kosong memakai {}, sedangkan himpunan kosong harus dibuat dengan set() karena {} menghasilkan dict kosong.

set_examples.py

# Membuat set
angka = {1, 2, 3, 4, 5}
print('angka =', sorted(angka))              # Hasil: angka = [1, 2, 3, 4, 5]

# Menambahkan elemen ke set
angka.add(6)
print('Setelah menambah 6:', sorted(angka))  # Hasil: Setelah menambah 6: [1, 2, 3, 4, 5, 6]

# Operasi himpunan
genap = {2, 4, 6, 8}
ganjil = {1, 3, 5, 7}

# Gabungan
print('genap | ganjil =', sorted(genap | ganjil))
# Hasil: genap | ganjil = [1, 2, 3, 4, 5, 6, 7, 8]

# Irisan
print('genap & ganjil =', genap & ganjil)    # Hasil: genap & ganjil = set()

Perbandingan Container

Keempat tipe koleksi bawaan berbeda pada $urutan, sifat yang dapat diubah, dan penanganan nilai kembar$ . Tabel berikut membandingkannya supaya kamu bisa memilih sesuai kebutuhan.

Container	Sintaks	Terurut	Mutable	Duplikasi	Kegunaan Utama
$List$	`[1, 2, 3]`	Ya	Ya	Ya	Data yang perlu diubah
$Tuple$	`(1, 2, 3)`	Ya	Tidak pada tiap posisi	Ya	Data dengan posisi tetap
$Dictionary$	`{'a': 1}`	Ya	Ya	Kunci harus unik	Pasangan kunci dan nilai
$Set$	`{1, 2, 3}`	Tidak	Ya	Tidak	Anggota unik dan operasi himpunan

Sejak Python 3.7, iterasi dict mengikuti urutan penyisipan kunci. Memperbarui kunci tidak mengubah posisinya. Jika kunci dihapus lalu dimasukkan kembali, posisinya berpindah ke akhir.