Mempelajari Lebih Lanjut Tentang Python List Untuk Pemula

Warning: Berikut ini adalah tutorial Python untuk pemula yang sengaja dibuat untuk dokumentasai penulis agar mempermudah dalam mempelajari hal baru.

Setelah sebelumnya kita mempelajari tentang Python Lists dasar, kali ini kita akan coba mempelajari lebih dalam tentang List itu sendiri.

Python List

Table of Content

List are mutable

Kita dapat memodify / merubah / mengupdate list value sesuai dengan keinginan kita.

contoh :

>>> company = []
>>> company
[]

>>> company.extend(["Google", "Twitter", "Uber", "Microsoft"])
>>> company
['Google', 'Twitter', 'Uber', 'Microsoft']

>>> company[2] = "Facebook"
>>> company
['Google', 'Twitter', 'Facebook', 'Microsoft']

Pada table di atas, pertama kita membuat list kosong, lalu kemudian memasukkan beberapa value menggunakan metode extend(), dan mencoba merubah value yang sudah ada (uber) menjadi (facebook).

List are ordered

List tidak hanya digunakan untuk menampung sebuah object. Tetapi berbagai macam karakter complex, dsb. Urutan index saat kita membuat list adalah keys yang bisa digunakan pada list tersebut dan seterusnya.

>>> vocal = []
>>> vocal
[]

>>> vocal.extend("aiueo")
>>> vocal
['a', 'i', 'u', 'e', 'o']

>>> lacov = []
>>> lacov
[]

>>> lacov.extend("oeuia")
>>> lacov
['o', 'e', 'u', 'i', 'a']

>>> vocal == lacov
False
>>> vocal is lacov
False

>>> 'a' in vocal
True

>>> 'a' in lacov
True

>>> [1, 2, 3, 4] == [4, 2, 3, 1]
False

List can contain any arbitrary objects

List dapat menyimpan bermacam-macam object didalamnya

List dapat berisi bermacam-macam object.

Contoh di bawah ini list dapat berisi data yang sama :

>>> x = [1,10,20,3]
>>> x
[1, 10, 20, 3]

Maupun data yang berbeda-beda seperti di bawah ini :

>>> y = [100.1, "what", 10, "the", 0.98, "heck", True, False]
>>> y
[100.1, 'what', 10, 'the', 0.98, 'heck', True, False]

Dan seperti contoh di bawah ini kita akan mencoba menyimpan data / object yang complex kedalam list serpti function, classes, dan modules yang akan coba kita pelajari pada tutorial selanjutnya.

>>> # sebuah function
>>> len
<built-in function len>

>>> # sebuah operation
>>> int
<class 'int'>


>>> # kita mencoba membuat class
>>> def cool():
...     pass
... 
>>> cool
<function cool at 0x7f30bc33b598>

>>> # dibawah ini kita akan mencoba mengimport module bawaah / buil-in python
>>> import math
>>> math
<module 'math' from '/home/username/anaconda3/lib/python3.6/lib-dynload/math.cpython-36m-x86_64-linux-gnu.so'>

>>> # di bawah ini kita memasukkan semua data di atas ke dalam sebuah list seperti di bawah ini.
>>> x = []
>>> x.extend([len, int, cool, math])
>>> x
[<built-in function len>, <class 'int'>, <function cool at 0x7f30bc33b598>, <module 'math' from '/home/icoldplayer/anaconda3/lib/python3.6/lib-dynload/math.cpython-36m-x86_64-linux-gnu.so'>]

And, see? awesome isn’t it?

Pada contoh di atas kita coba menyimpan berbagai macam data complex ke dalam sebuah list (x) dan berhasil, dan saat kita memanggil si variable x maka dia akan memunculkan type data yang ada pada variable list x tersebut. so freakin awesome huh?

List juga dapat berisi angka dari sebuah object, dari 0 hingga sebanyak 1000 atau sebanyak apapun yang kita inginkan.

>>> nomor = []
>>> nomor
[]
>>> nomor.extend([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
... 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
... 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
... 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
... 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
... 97, 98, 99, 100,0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
... 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
... 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
... 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
... 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
... 97, 98, 99, 100,])


>>> nomor
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]

List are dynamic

Setelah kita belajar beberapa metode lists seperti di atas, di bawah ini kita akan mencoba mempelajari tentang metode yang dapat kita gunakan untuk menambahkan value pada list tersebut.

>>> va = []
>>> va.extend(["Python", "Erlang", "Go", "Rust", "Serverless", "R"])
>>> va
['Python', 'Erlang', 'Go', 'Rust', 'Serverless', 'R']

>>> # kita akan mencoba memasukkan value baru ke dalam list pada index ke 4.
>>> va[3:3] = [10, 11, 12]
>>> va
['Python', 'Erlang', 'Go', 10, 11, 12, 'Rust', 'Serverless', 'R']

>>> # dan di bawah ini kita kan menambahkan sebuah value baru ke 'akhir' list.
>>> va += [0.123456789]
>>> va
['Python', 'Erlang', 'Go', 10, 11, 12, 'Rust', 'Serverless', 'R', 0.123456789]

Kenapa list disebut dynamic?

Dibawah ini adalah contoh shrink yang dapat kita gunakan untuk remove item / value pada list tersebut.

>>> # setelah sebelumnya kita memasukkan value (10, 11, 12) kedalam list yang kita miliki, mari kita coba menghapusnya kembali.
>>> va
['Python', 'Erlang', 'Go', 10, 11, 12, 'Rust', 'Serverless', 'R', 0.123456789]

>>> len(va)
10
>>> type(va)
<class 'list'>

>>> # mari kita coba untuk menghapus value ke-4 hinggal 5 yaitu (10 dan 11)
>>> va[3:5] = []
>>> va
['Python', 'Erlang', 'Go', 12, 'Rust', 'Serverless', 'R', 0.123456789]

>>> # di atas tersebut kita telah berhasil menghapusnya dan coba untuk menghitung value list tersebut.
>>> len(va)
8

>>> # di bawah ini kita akan mencoba menghapus value terdepan yaitu 'Python'
>>> del va[0]
>>> va
['Erlang', 'Go', 12, 'Rust', 'Serverless', 'R', 0.123456789]

Berikut ini adalah alasan kedua mengapa list pada python disebut dynamic.

Setelah sebelumnya kita menghapus value terdepan yaitu python, mari kita memasukkannya kembali menjadi value terdepan.

>>> va
['Erlang', 'Go', 12, 'Rust', 'Serverless', 'R', 0.123456789]

>>> # memasukkan python menjadi value terdepan pada list.
>>> va.insert(0, "Python")
>>> va
['Python', 'Erlang', 'Go', 12, 'Rust', 'Serverless', 'R', 0.123456789]

>>> # mari kita coba memasukkan value yang lain kedalam list.
>>> va.insert(1, "Kotlin")
>>> va
['Python', 'Kotlin', 'Erlang', 'Go', 12, 'Rust', 'Serverless', 'R', 0.123456789]

And, you see? it’s amazing isn’t it?

Keren bukan?. well, untuk yang sudah pro terkesan biasa saja. tetapi untuk yang masih belajar seperti saya mungkin akan terasa, that’s cool dude, how did u know that?.

List elements can be accessed by index

Pada dasarnya, element / value yang ada pada list dapat kita akses dengan menggunakan metode index.

Berikut ini mari kita coba pelajari bersama contoh / analogi untuk mengakses karakter / string value pada list tersebut.

Indexing dalam pemrograman dimulai dengan nilai 0 / zero.

>>> fruits = []
>>> fruits.extend(["apple", "banana", 'watermelon', 'kiwi'])
>>> fruits
['apple', 'banana', 'watermelon', 'kiwi']
source : dev.notnoob.com

+-------------------------------------------------+
| +--------+  +---------+ +------------+ +------+ |
| | apple  |  | banana  | | watermelon | | kiwi | |
| +---+----+  +----+----+ +------+-----+ +---+--+ |
|     ^            ^             ^           ^    |
|     |            |             |           |    |
|     |            |             |           |    |
|     +            +             +           +    |
|     0            1             2           3    |
|                                                 |
+-------------------------------------------------+
apple = value pertama dalam indexing adalah 0
banana = value kedua dalam indexing adalah 1
watermelon = value ketiga dan seterusnya adalah 2, dst.

Berikut ini adalah contoh untuk mengakses index dalam python list.

>>> fruits
['apple', 'banana', 'watermelon', 'kiwi']
>>> fruits[0]
'apple'
>>> fruits[-1]
'kiwi'
>>> fruits[3]
'kiwi'
>>> fruits[2]
'watermelon'

Secara garis besar, semua yang berhubungan dengan indexing string juga dapat kita terapkan dalam list ini.

Sebagai contoh, apabila kita menggunakan negative (-1) maka akan meng-index dari bagian paling belakang.

Contoh :

+-------------------------------------------------+
|                  dev.notnoob.com                |
|                                                 |
|    -4           -3            -2          -1    |
|     +            +             |           +    |
|     |            |             |           |    |
|     |            |             |           |    |
|     |            |             |           |    |
|     v            v             v           v    |
| +---+----+  +----+-------------+-----+ +---+--+ |
| | apple  |  | banana   || watermelon | | kiwi | |
| +---+----+  +----+-------------+-----+ +---+--+ |
|     ^            ^             ^           ^    |
|     |            |             |           |    |
|     |            |             |           |    |
|     +            +             +           +    |
|     0            1             2           3    |
|          Negative List Indexing                 |
+-------------------------------------------------+

Mari perhatikan contoh table di atas, nilai -1 akan memulai index dari bagian paling belakang pada sebuah list yaitu (kiwi).

Contoh :

>>> fruits
['apple', 'banana', 'watermelon', 'kiwi']
>>> fruits[-3]
'banana'
>>> fruits[-4]
'apple'
>>> fruits[-2]
'watermelon'
>>> fruits[-1]
'kiwi'

Kita juga dapat melakukan slicing pada list tersebut seperti di bawah ini :

>>> fruits
['apple', 'banana', 'watermelon', 'kiwi']
>>> fruits[1:3]
['banana', 'watermelon']
>>> fruits[1:2]
['banana']

>>> # Contoh slicing secara terbalik
>>> fruits[-2:3]
['watermelon']
>>> fruits[-3:4]
['banana', 'watermelon', 'kiwi']
>>> fruits[-4:-1]
['apple', 'banana', 'watermelon']

negatif & positif slice

Apabila metode slice yang digunakan (positif dan negatif)adalah menghasilkan output yang sama maka akan menjadi True, seperti contoh di bawah ini

>>> fruits
['apple', 'banana', 'watermelon', 'kiwi']
>>> fruits[-4:-1]
['apple', 'banana', 'watermelon']

>>>  
>>> fruits[-3:-1] == fruits[1:3]
True

Another Method

Metode lainnya yang bisa kita gunakan apabila kita ingin meng-copy list yang sudah ada menjadi satu.

>>> fruits
['apple', 'banana', 'watermelon', 'kiwi']

>>> # cara pertama
>>> fruits[:4], fruits[:4]
(['apple', 'banana', 'watermelon', 'kiwi'], ['apple', 'banana', 'watermelon', 'kiwi'])

>>> # cara kedua
>>> fruits[:4], fruits[0:4]
(['apple', 'banana', 'watermelon', 'kiwi'], ['apple', 'banana', 'watermelon', 'kiwi'])

>>> # cara ketiga
>>> fruits[1:], fruits[1:len(fruits)]
(['banana', 'watermelon', 'kiwi'], ['banana', 'watermelon', 'kiwi'])

>>> # contoh keempat
>>> fruits[:3] + fruits[3:]
['apple', 'banana', 'watermelon', 'kiwi']
>>> fruits[:3] + fruits[3:] == fruits
True
  • Pada cara pertama dan kedua, kita meng-copy list pertama dan list kedua dari awal list (apple) hingga akhir list (kiwi).

  • Pada cara ketiga kita meng-copy dimulai dengan index pertama yaitu (banana) pada list pertama dan pada list kedua kita melakukan paste pada list kedua.

  • Pada cara keempat kita melakukan pencarian persamaan irisan, apabila irisan pertama dan irisan kedua digabungkan dan hasilnya sama seperti list awal maka hasilnya adalah true.

Mengakses list secara lebih spesifik

Dalam suatu bahasa pemrograman, kita harus dapat mengakses suatu tipe data secara spesifik agar hasil yang dikeluarkan sesuai keinginan.

Berikut ini adalah cara untuk mengakses list secara spesifik pada python untuk mendapatkan hasil yang dibutuhkan.

stride—either (melompati value) menggunakan metode positif maupun negatif

  • Melompat per 1 value dimulai dari index 0 yaitu python kita mengakses sebuah value pada list dan melompati per 1 value ke value selanjutnya, dimulai dari index 0 (‘python’)

    >>> x = ["python", "erlang", "go", "F#", "rust", "kotlin", "R"]
    >>> x
    ['python', 'erlang', 'go', 'F#', 'rust', 'kotlin', 'R']
    >>> len(x)
    7

x[:7:2]['python', 'go', 'rust', 'r']

* apabila kita merubahnya `'x[:7:2]'` seperti di bawah ini maka output yang dihasilkan adalah memunculkan kembali seluruh list.
```python
>>> x
['python', 'erlang', 'go', 'F#', 'rust', 'kotlin', 'R']

>>> x[:7:1]
['python', 'erlang', 'go', 'F#', 'rust', 'kotlin', 'R']
  • apabila kita kembali merubah value yang ingin kita keluarkan seperti di bawah ini (melompati per 2 value sekaligus) di mulai dari index awal yaitu (python)
>>> x
['python', 'erlang', 'go', 'F#', 'rust', 'kotlin', 'R']

>>> x[:7:3]
['python', 'F#', 'R']
  • Contoh lainnya adalah dengan menggunakan metode negatif (-). perhatikan contoh dibawah ini :
>>> x
['python', 'erlang', 'go', 'F#', 'rust', 'kotlin', 'R']

>>> x[::-3]
['R', 'F#', 'python']

>>> x[7:0:-3]
['R', 'F#']

Untuk lebih mempermudah pemahaman kita mari kita menggambar sebuah diagram.

+--------------------------------------------------------------+
|     dev.notnoob.com                                          |
|                                                              |
|                             x[:7:2]                          |
|                                |                             |
|                                |                             |
|                                |                             |
|                                v                             |
|       +-----------------+------+-----+----------------+      |
|       |                 |            |                |      |
|                                                              |
|   ['python', 'erlang', 'go', 'F#', 'rust', 'kotlin', 'R']    |
|                                                              |
|       |          |      |      |     |        |       |      |
|       +----------+------+------------+--------+-------+      |
|                                ^                             |
|                                |                             |
|                                |                             |
|                                |                             |
|                                |                             |
|                            x[:7:1]                           |
|                                                              |
+--------------------------------------------------------------+

Penjelasan : Pada table di atas kita menggunakan perintah x[:7:2] apa artinya? x adalah nama variable list yang telah kita buat.

>>> x = ["python", "erlang", "go", "F#", "rust", "kotlin", "R"]

Sedangkan [:7:2] adalah (:) adalah awal dimulainya metode indexing yang akan digunakan, yaitu 0 dan 7 adalah jumlah / panjang list yang kita miliki, perhatikan perintah di atas : len(x). Sedangkan :2 adalah perintah yang ingin kita jalankan yaitu melompati / melangkai per 1 value.

Contoh : a, b, c, d, e, f, g, kita hanya ingin membaca huruf a, c, e, g maka digunakanlah metode :2 seperti di atas.

Membalikkan value pada list

Sejauh ini apakah mengalami kesulitan? pastinya iya!. Tidak mungkin tidak. Tetapi dengan terus belajar dan berlatih maka akan terbiasa.

Selanjutnya kita akan mencoba membalikkan isi dari list yang akan kita buat dibawah ini :

>>> y = ["budi", "joko", "desy", "cindy", "romlah"]
>>> y
['budi', 'joko', 'desy', 'cindy', 'romlah']

>>> # [::-1] adalah perintah untuk memulai menghitung dari bagian akhir list dan mengeluarkannya sebagai output.
>>> y[::-1]
['romlah', 'cindy', 'desy', 'joko', 'budi']

Penggunakan syntax [:] pada lists dan string

Syntax [:] akan sering kita gunakan pada list, akan tetapi ada perbedaan penggunaan [:] pada list dan string.

Contoh : jika variable string adalah string (str), string[:] akan menghasilkan output object yang sama

>>> string = "data string"
>>> string
'data string'
>>> string[:]
'data string'
>>> string[:] is string
True

Sebaliknya, jika x adalah sebuah list, maka x[:] akan menghasilkan sebuah object baru hasil dari (copy paste) list x

Contoh :

>>> x
['python', 'erlang', 'go', 'F#', 'rust', 'kotlin', 'R']

>>> x[:]
['python', 'erlang', 'go', 'F#', 'rust', 'kotlin', 'R']
>>> x[:] is x
False

Dikarenakan sudah sepanjang ini dan masih banyak yang perlu kita pelajari mengenai python list maka kita akan coba membahas tentang nested lists pada python di tutorial selanjutnya.

Thanks’s for reading guys!.

next step >>> nested list pada python

Note :Tutorial ini dibuat hanya untuk dokumentasi semata oleh penulis agar mudah dalam mempelajari sesuatu hal yang baru berdasarkan pemahaman penulis!.

Get it? take it easy and keep reading and practice slowly but sure!.


Tags: #python, #python-lists, #Blog