Belajar coding secara interaktif membahas tentang bahasa pemrograman Python

Belajar Coding Interaktif Pemrograman Python

Tutorial belajar Python dasar yang interaktif dan sistematis di CodePolitan, belajar Python dasar, belajar pemrograman dasar

List adalah sebuah senarai yang berisi elemen dengan tipe data seragam atau banyak ragam. Maksudnya kamu dapat mengisi sebuah *list* dengan angka saja atau campuran dari angka, *string*, objek, bahkan suatu *list*. Untuk membuat *list* kamu dapat menggunakan tanda "[" dan "]" dan menggunakan tanda koma untuk memisahkan setiap elemennya.

Salah satu karakteristik *list* adalah kamu dapat mengubah isinya setelah *list* dibuat. Berbeda dengan *tuple* yang tidak dapat diubah setelah *tuple* tersebut dibuat.

Sekarang kita akan membuat berbagai macam *list* yang diisi oleh berbagai tipe data.

List Introduction

Setelah membuat *list* kamu dapat melakukan operasi pertama terhadap sebuah *list* yaitu mengakses isinya. Kamu dapat mengaksesnya melalui indeks atau mengakses setiap isi *list* dengan menggunakan *looping*. 

Kamu juga dapat mengakses sebuah *list* dengan menggunakan *built-in function* **map()**, **filter()**, dan **reduce()** dengan memanfaatkan *lambda function* yang dimiliki Python. Kamu akan merasakan sensasi *functional programming* saat menggunakan *lambda function*.

Accessing List

Sebuah isi *list* dapat ditambah dengan *list* lain bahkan kamu juga dapat melipatgandakan isi *list* hanya dengan menggunakan tanda asterisk ( &#42; ). Kamu pun dapat menggunakan **map()** dan **filter()** dengan memadukannya bersama *lambda function* untuk memanipulasi isi *list* dengan cara yang lebih ringkas.

Kamu pun dapat mencoba menggunakan *built-in function* seperti **sum()**, **max()**, dan **min()** terhadap suatu *list* hanya saja semua isi *list* harus berupa angka.


List Operation

Sejatinya *list* adalah sebuah objek. Objek memiliki sejumlah *method* yang digunakan untuk memanipulasi objek tersebut begitu objek tersebut diciptakan. *List* mempunyai sejumlah *method* yang dapat kamu gunakan untuk melakukan operasi terhadap *list*, diantaranya:

* **reverse()**, membalik urutan isi *list*
* **sort()**, mengurutkan isi *list*
* **count()**, menghitung ada berapa elemen yang sama di dalam *list*
* **index()**, mencari *index* dari *list*
* **append()**, menambah elemen ke *list* tetap ditambahkan ke urutan terakhir
* **pop()**, menghapus elemen dari *list* dimulai dari urutan terakhir
* **insert()**, menyisipkan elemen pada indeks tertentu ke *list*
* **remove()**, menghapus suatu elemen dari *list*

Sekarang kita akan mencoba semua *method* diatas melalui kode di sebelah kanan.


List Method

Tuple adalah sebuah senarai yang berisi elemen dengan tipe data seragam atau banyak ragam. Maksudnya kamu dapat mengisi sebuah *tuple* dengan angka saja atau campuran dari angka, *string*, objek, bahkan suatu *tuple*. Untuk membuat *tuple* kamu dapat menggunakan tanda "(" dan ")" dan menggunakan tanda koma untuk memisahkan setiap elemennya.

Salah satu karakteristik *tuple* adalah kamu tidak dapat mengubah isinya atau elemennya setelah *tuple* dibuat. Berbeda dengan *list* yang dapat diubah setelah *list* tersebut dibuat. Untuk mengubah isi tuple, kamu dapat menkonversinya terlebih dahulu ke *list* kemudian diubah lagi menjadi *tuple*.

Sekarang kita akan membuat berbagai macam *tuple* yang diisi oleh berbagai tipe data.

Tuple Introduction

Setelah membuat *tuple* kamu dapat melakukan operasi pertama terhadap sebuah *tuple* yaitu mengakses isinya. Kamu dapat mengaksesnya melalui indeks atau mengakses setiap isi *tuple* dengan menggunakan *for loop*. 

Kamu juga dapat mengakses sebuah *tuple* dengan menggunakan *built-in function* **map()**, **filter()**, dan **reduce()** dengan memanfaatkan *lambda function* yang dimiliki Python.

Accessing Tuple

Sebuah isi *tuple* dapat ditambah dengan *tuple* lain bahkan kamu juga dapat melipatgandakan isi *tuple* hanya dengan menggunakan tanda asterisk ( &#42; ). Kamu pun dapat menggunakan **map()** dan **filter()** dengan memadukannya bersama *lambda function* untuk memanipulasi isi *tuple* dengan cara yang lebih ringkas.

Kamu pun dapat mencoba menggunakan *built-in function* seperti **sum()**, **max()**, dan **min()** terhadap suatu *tuple* hanya saja semua isi *tuple* harus berupa angka.


Tuple Operation

Sejatinya *tuple* adalah sebuah objek. Objek memiliki sejumlah *method* yang digunakan untuk memanipulasi objek tersebut begitu objek tersebut diciptakan. *Tuple* mempunyai sejumlah *method* yang dapat kamu gunakan untuk melakukan operasi terhadap *tuple*, diantaranya:

* **count()**, menghitung ada berapa elemen yang sama di dalam *list*
* **index()**, mencari *index* dari *list*

Sekarang kita akan mencoba semua *method* diatas melalui kode di sebelah kanan.


Tuple Method

*Dictionary* adalah sebuah tipe data bawaan Python yang dapat menyimpan *key-value* dengan *value* dapat berupa tipe data apapun termasuk *dictionary* itu sendiri. *Dictionary* dapat digunakan juga untuk merepresentasikan *tree*, *graph*, ataupun bahan mentah untuk struktur JSON. Sintaksnya pun tidak berbeda jauh dengan JSON.

Kamu dapat membuat *dict* dengan menggunakan tanda kurawal dan membuat elemen *key-value* dengan dipisahkan tanda ":". Kamu pun dapat memeriksa apakah suatu *value* adalah *dict* atau bukan dengan menggunakan *function* **type()**

Dictionary Introduction

Untuk mengakses elemen *dictionary*, kamu dapat menggunakan tanda "[" dan "]" dengan melewatkan nama *key* yang akan diakses. Bila terdapat *dictionary* yang menjadi elemennya, kamu dapat mengakses lagi *key* tersebut setelah *key* pertama.

Sedangkan bila kamu melakukan *looping* terhadap *dictionary*, kamu hanya akan mendapatkan *key*-nya saja yang dapat digunakan untuk mengakses setiap elemen *dictionary*.

Accessing Dictionary Element

Salah satu operasi pada *dict* yang dapat dilakukan adalah menghitung panjang *dict*. Kamu juga dapat mengubah isi elemen *dict* dengan mengisinya langsung.
Dan kamu dapat mencetak isi *dict* langsung ke konsol tanpa melakukan konversi apapun.

Namun sayangnya untuk mengubah isi elemen, kamu harus meng-*copy*-nya terlebih dahulu sebelum diubah. Karena bila tidak, elemen di *dict* induk pun akan ikut berubah.


Dict Operation

*Dict* memiliki beberapa *method* yang dapat digunakan langsung dari variabel yang sudah diisi *dict*. Beberapa *method* yang dapat kamu gunakan antara lain:

* **get**, untuk mengambil *value* dengan *key* tertentu
* **has_key**, untuk memeriksa apakah *dict* mempunyai suatu *key*
* **keys**, mengambil *key* saja
* **items**, mengambil *value* saja
* **update**, menambah isi *dict*
* **pop**, membuang salah satu elemen berdasarkan *dict*
* **popitem**, membuang salah satu elemen
* **clear**, mengosongkan *dict*


Various Dictionary Method

*Class* adalah suatu komposisi kode dimana kamu dapat menyimpan suatu atribut beserta *method* yang terkait dengan *class* tersebut. Suatu *class* dapat diinstansiasi dan akan menjadi objek. Objek dapat diinisialisasi melalui *constructor* yang dapat menjadi nilai awal suatu objek.

Class dapat memiliki atribut privat dan publik, juga dapat memiliki *method* privat dan publik. Begitu juga kita dapat menggunakan suatu *method* tanpa harus membuat objeknya terlebih dahulu dengan mengandalkan *static method*.


Class Introduction

Constructor adalah suatu *method* yang akan dieksekusi otomatis setelah objek dibuat. Di Python, *constructor* dibuat dengan menggunakan *built-in method* _ _ init _ _. Parameter yang dilewakan disesuaikan dengan kebutuhan saja.


Constructor

Hampir sama dengan *constructor*, *destructor* secara otomatis akan dipanggil. Hanya saja dipanggil saat objek - objek yang dibuat dari suatu *class* dihancurkan oleh *garbage collector*. Baca lebih banyak tentang [garbage collector](https://id.wikipedia.org/wiki/Pengumpulan_sampah_(ilmu_komputer))

Hal ini sangat berguna bila kamu ingin menutup sebuah koneksi ke *database* atau ke *file* setelah proses pembuatan I/O dilakukan.


Destructor

*Inheritance* adalah suatu cara agar atribut dan *method* dari suatu *class* dapat digunakan di *class* lain. Selain itu kamu juga dapat melakukan *overriding* terhadap suatu *method* dengan mengubah *method* dari *parent* dan disesuaikan di *class* turunan.

Salah satu tujuannya adalah menghemat kode program yang ditulis, yang memiliki atribut dan karakteristik yang sama. Bisa dianggap *class* adalah *struct* yang dilengkapi *function*.


Class Inheritance

Hampir mirip dengan *inheritance*, hanya saja *class* yang digunakan sebagai *parent* lebih dari satu. Mirip dengan *multiple inheritance* di C++, Python pun dapat melakukannya. Tentu saja perlu kehati - hatian lebih dalam menulis kode yang menggunakan *multiple inheritance*.


Multiple Inheritance

*Method* _ _ init _ _  dan _ _ del _ _ merupakan *magic method* yang dimiliki oleh sistem *class* di Python. Dimana kamu dapat menimpa operasi suatu *magic method* terhadap yang kita inginkan.

Misal sekarang kita akan melakukan *overriding* terhadap *magic method* yang melakukan operasi sama dengan dan tidak sama dengan.

Magic Method

Adalah suatu cara bagaimana kita dapat menggunakan suatu *method* di dalam *class* tanpa harus membuat objeknya terlebih dahulu. Di Python 3 kamu cukup menambahkan decorator @staticmethod untuk menandai bahwa *method* tersebut adalah *static method*.

Sekalipun *class* dibuat objeknya *method* tersebut tetap dapat digunakan.


Static Method

*Exception* adalah suatu cara untuk mengurung suatu baris kode yang bisa menimbulkan masalah namun tidak menghentikan *runtime* suatu eksekusi program. Misal ketika terjadi pembagian nol biasanya eksekusi program akan langsung dihentikan, namun bila kita mengurungnya dengan *exception* eksekusi akan dilanjutkan walaupun *output*-nya *error*.

Penggunaan exception menggunakan keyword *try* dan *except* 

Exception Introduction

Dalam menangkap *exception* kita bisa saja menangkapnya secara global, hanya saja akan lebih enak bila kita dapat menangkap *error* tertentu dan menampilkan penanganan *error* yang sesuai atau melakukan suatu operasi.

Misal dalam kode di sebelah kanan kita akan menangkap *error* **IndexError**, sedangkan bila kita menghapus komentar pada kode di sebelah kanan akan ditangani oleh *except* dibawahnya.

Multiple Exception Handling

Kamu juga dapat melakukan *nested try..except* di dalam *try..except* hal ini dapat dilakukan bila ingin menangani *error* di dalam kode tertentu. Tentu saja *error* yang akan ditangani adalah yang paling awal terjadi.


Nested Try Except

Ini adalah bagian pamungkas dari *exception*. *Keyword* **finally** akan selalu dieksekusi baik kode *error* ataupun tidak. Sangat cocok bila ada kode yang melibatkan I/O agar baik *error* atau tidak tetap ditangani dengan baik.

Finally

Di Python *function* dibuat dengan menggunakan *keyword* **def** diikuti dengan nama *function* yang diinginkan. Sebuah *function* dapat menerima parameter ataupun tidak.

Karena Python tidak menggunakan tanda kurawal untuk blok kode yang ada di dalam *function*. Kamu akan menggunakan indentasi untuk menentukan baris kode yang menjadi bagian dari *function* tersebut.

Untuk memanggil *function* kamu cukup memanggil nama *function*-nya saja di luar blok kode *function*. Bila memanggil suatu *function* di dalam *function* itu sendiri maka akan menjadi rekursif.

Introduction to Function

*Function* dapat menerima suatu parameter sesuai kebutuhan. Parameter tersebut dapat digunakan oleh kode yang berada di dalam suatu *function*. 

Di Python ada parameter yang disebut dengan *argument* ada juga yang disebut dengan *keyword argument*. *Keyword argument* adalah parameter yang dapat diisi dengan *default value*.

Function Parameter

*Function* pun dapat mengembalikan suatu nilai setelah melalui suatu proses di dalamnya. Python memiliki *keyword* **return** untuk mengembalikan suatu nilai dari dalam *function*.


Return Value

*Function* di Python dapat juga dibuat tanpa harus didefinisikan terlebih dahulu. *Function* jenis ini memang tidak memerlukan logika yang panjang dan rumit. *Function* ini disebut dengan *lambda function* yang biasanya diisi dengan perhitungan matematika sederhana.

*Lambda function* dapat digunakan bersama *method* **map()** dan **filter()**.


Lambda Function

*Function* di Python dapat menerima parameter yang diberi *initial value*. Urutannya pun dapat diisi secara acak karena *keyword parameter* akan mendeteksi nama parameter yang sudah ditentukan di *function* walaupun diisi secara tidak berurutan.

Keyword Parameter

Di Python, bila ada parameter yang tidak sesuai dengan parameter yang dibutuhkan. Dapat ditampung menjadi parameter tambahan yang dikenal dengan **args**. Parameter selain yang telah ditentukan akan disimpan dalam bentuk *list* dan dapat diambil di dalam kode suatu *function*.

Fitur ini memberikan fleksibilitas bagi *programmer* bila ingin menambahkan parameter diluar ketentuan.

Args Parameter

Hampir sama kegunaannya dengan **args** hanya saja **kwargs** digunakan untuk menerima *keyword parameter* yang diluar ketentuan. Kamu dapat mengakses *kwargs* sebagai *dictionary*.


Kwargs Parameter

Di Python kamu dapat melakukan operasi aritmatika dasar seperti kali, bagi, tambah, kurang. Beberapa operator aritmatika tersebut antara lain:

* +, penambahan
* *, pengalian
* -, pengurangan
* /, pembagian
* %, modulus
* **, pangkat
* //, pembagian bulat

Jika dua buah variabel berisi angka, maka operator aritmatika dapat diterapkan. Sekarang mari kita coba buat kode yang menggunakan operator aritmatika.


pemrograman python dasar, operator aritmatika

Arithmethic Operator

Operator perbandingan biasa digunakan untuk penggunaan pemilihan kondisi dan perulangan. Kamu akan mempelajarinya setelah ini. Operator perbandingan digunakan untuk membandingkan dua buah variabel dan akan menghasilkan **True** dan **False**.

Operator perbandingan di Python yang harus kamu ingat antara lain:

* ==, sama dengan. Karena tanda = digunakan untuk membentuk variabel.
* !=, tidak sama dengan
* >, lebih dari
* <, kurang dari
* >=, lebih dari sama dengan
* <=, kurang dari sama dengan

Bila kamu terbiasa dengan matematika, maka tidak akan terlalu aneh jika kamu menemukan operator diatas.

Comparison Operator

Operator logika biasa digunakan dalam pemilihan kondisi seperti **while** atau **for**. Penggunaannya biasa digabungkan dengan operator perbandingan yang sudah dibahas sebelumnya. Fungsinya untuk membentuk paduan kondisi yang akan membuat sebuah aturan yang cukup kompleks.

Operator logika di Python yang harus kamu ingat antara lain:

* **and**, artinya dan, dimana kondisi benar jika kedua nilai adalah **True**
* **or**, artinya atau, dimana kondisi salah jika kedua nilai adalah **False**
* **not**, artinya negatif, dimana nilai variabel akan dibalik menjadi lawannya. Misal **True** menjadi **False**.

Bila kamu terbiasa dengan logika matematika, hal ini bukan hal yang sulit.


Logical Operator


Operator *bitwise* digunakan untuk menangani operasi bit pada suatu bilangan dalam representasi biner. Misal seperti berikut:

```
63  // bila menjadi biner adalah 0011 1100
13  // bila menjadi biner adalah 0000 1101

# AND
0011 1100
0000 1101
---------
0000 1100

#OR 
0011 1100
0000 1101
---------
0011 1101

#XOR
0011 1100
0000 1101
---------
0011 0001

#Negasi

0011 1100
---------
1100 0011

# >> 2

0011 1100
---------
0000 1111

# 2 <<

0011 1100
---------
1111 0000

```

Operator *bitwise* yang harus kamu ingat antara lain:

* &, melakukan operasi AND terhadap dua bilangan biner
* |, melakukan operasi OR terhadap dua bilangan biner
* ~, melakukan operasi negasi terhadap bilangan biner
* ^, melakukan operasi XOR terhadap dua bilangan biner
* >>, melakukan operasi penggeseran bit ke kanan terhadap bilangan biner
* <<, melakukan operasi penggeseran bit ke kiri terhadap bilangan biner



Bitwise Operator

Operator *assignment* digunakan untuk menangani operasi seperti berikut:

```
x = x + 1;
y = y - 1;

// atau

x = 1;
y = x;
x = y + 1;
```

Dimana kamu ingin melakukan sesuatu terhadap suatu variabel tanpa harus membuat variabel baru sebagai variabel bantu. Hal ini tidak hanya digunakan untuk menghemat baris kode, digunakan juga membuat kode lebih elok.

Operator *assignment* di Python yang harus kamu ingat antara lain:

* +=, melakukan operasi penambahan terhadap variabel itu sendiri
* -=, melakukan operasi pengurangan terhadap variabel itu sendiri
* *=, melakukan operasi perkalian terhadap variabel itu sendiri
* /=, melakukan operasi pembagian terhadap variabel itu sendiri
* %=, melakukan operasi modulus terhadap variabel itu sendiri
* **=, melakukan operasi pangkat terhadap variabel itu sendiri
* //=, melakukan operasi pembagian bulat terhadap variabel itu sendiri


Assignment Operator

Operator keanggotaan digunakan untuk memeriksa apakah suatu data terdapat dalam *list*, *tuple*, atau *dictionary*. Sehingga kamu tidak perlu membuat *function* sendiri untuk hanya memeriksa apakah suatu elemen ada pada struktur dasar Python tersebut.

Operator perbandingan di Python yang harus kamu ingat antara lain:

* **in**, apakah suatu elemen ada di dalam *list* / *tuple* / *dictionary*
* **not in**, apakah suatu elemen tidak ada di dalam *list* / *tuple* / *dictionary*

Membership Operator

Operator identitas adalah cara bagaimana kita mengenali suatu variabel di dalam memori di Python. Kita dapat membandingkan isinya bila isinya identik ataupun lokasi memorinya.

Operatornya cuma ada dua yaitu:

* **is**, untuk memeriksa apakah dua variabel memiliki isi dan tipe data yang sama
* **is not**, memastikan bahwa dua variabel tidaklah sama baik isi dan tipe datanya

Lalu ada sebuah *function* yang digunakan untuk operator ini:

* **id()**, untuk mengetahui lokasi variabel / objek di memori walaupun isi dan tipe datanya sama


Identity Operator

Sekarang kita akan menggunakan **if** dan **else**. Untuk membangun sebuah kondisi kita akan menggunakan keduanya atau **if** saja. *Statement* **if** memerlukan sebuah kondisi yang dibangun dengan menggunakan operator logika dan operator relasional. Sedangkan **else** akan menerima kondisi yang tidak sesuai dengan kondisi di dalam **if** atau sebelumnya.

Di Python, untuk membentuk **if** tidak menggunakan kurawal seperti pada Java atau PHP. Tapi menggunakan titik dua, dan baris yang akan diproses setelah kondisi harus berada satu tab dibawahnya. Kamu pun dapat membuat kondisi tanpa harus dikurung oleh tanda "(" dan ")". Tapi untuk mempermudah pembacaan, lebih baik apabila kondisi yang kamu tulis dikurung saja.


If dan Else

Sekarang kita akan menggunakan **if** dan **elif** di Python. Untuk membangun sebuah kondisi yang lebih panjang dan kompleks gunakanlah **elif**. Jadi kamu dapat menambahkan beberapa kondisi jika kondisi ada banyak.

Mungkin **elif** adalah singkatan dari **else if**. Tapi kamu dapat mengakhiri sebuah kondisi dengan **else** atau tidak diakhiri oleh **else**.

If dan Elif

Bila sebuah kondisi harus memiliki kondisi lagi, Python bisa membuat *nested if* yaitu **if** di dalam **if**. Bila kondisi pertama terpenuhi, maka kondisi di dalamnya akan diperiksa dan bila kondisi di dalam kondisi pertama terpenuhi, maka kode akan dieksekusi. 

Namun sayangnya, kamu harus ekstra hati - hati dalam menulis kode Python agar tidak terjadi *IndentationError* saat *script* dijalankan nanti


Nested If

Ada juga sebuah kondisi yang bisa kamu tulis dengan lebih hemat. Hanya saja struktur yang dapat dibuat hanya **if** dan **else** saja. Kondisi tersebut dinamakan dengan *ternary operator*, dimana kamu dapat membuat sebuah kondisi hanya dengan satu baris saja.

Python memiliki *ternary operator* dengan bentuk berikut:

```
variabel = <statement 1> if <kondisi> else <statement 2>

misal:

x = 10
y = 0 if x < 50 else 1 
```

Ternary Operator

Di Python kamu dapat mengulang suatu bagian kode dengan menggunakan pengulangan **for**. Kamu akan menggunakan *built-in function* **range()** sebagai alat bantu untuk melakukan pengulangan dengan **for**. **range()** memiliki tiga parameter yaitu nilai awal, nilai akhir, dan penambah nilai untuk setiap iterasinya.

Kamu dapat melakukan pengulangan menaik dengan mengisi nilai yang lebih kecil untuk nilai awal dan nilai lebih tinggi untuk nilai akhir. Bila ingin memberikan penambah nilai di parameter ketiga dapat mengisinya dengan angka positif. Bila ingin melakukan pengulangan menurun dapat mengisi parameter ketiga dengan angka negatif.


For Loop

Di Python kamu dapat melakukan pengulangan *while*. Pengulangan tersebut memerlukan sebuah kondisi yang dapat kamu tentukan dengan kebutuhan kamu. Dan tentu saja akan berhenti setelah memenuhi suatu kondisi. Pengulangan *while* pun dapat kamu atur agar terus berjalan sampai diberhentikan secara sengaja oleh kita melalui Ctrl + C ataupun dengan menutup kode program.

Pengulangan *while* di Python hampir sama dengan bahasa pemrograman lain seperti PHP dan Java, hanya saja tidak memiliki tanda kurawal untuk mengurung blok kode yang berada di dalam *while* tersebut.

While Loop

Sejatinya pengulangan di Python di lakukan dengan mengiterasi sebuah elemen list / tuple / dictionary. Nilai yang dihasilkan oleh **range()** adalah sebuah *list* berisi angka yang berurutan sesuai dengan parameter yang ditentukan.

Bila kamu memiliki sebuah *string*, *list*, *tuple*, atau *dictionary* dapat kamu gunakan untuk melakukan proses pengulangan atau justru memroses tipe data tadi melalui pengulangan. Keempat tipe data tadi disebut dengan *iterable object*.


For Array Loop (List / Tuple / Dictionary)

Python3 merupakan versi terbaru dari Python yang akan menjadi tonggak masa depan untuk para *programmer* yang terbiasa menggunakan Python. Saat ini Python2 masih dikelola dan dikembangkan namun Python3 terus digalakkan dan dipromosikan karena akan tiba waktunya bahwa Python2 tidak akan didukung lagi pengembangannya.

Python3 lazimnya sama dengan Python2 hanya saja ada beberapa perbedaan sintaks dan *standard library* yang lebih banyak. Sekarang kita akan mencoba *hello world* terlebih dahulu di Python3.


Hello World

Python3 memiliki beberapa tipe data *built-in* atau bawaan yang cukup lengkap dan tidak sulit untuk digunakan. Beberapa tipe data yang wajib kamu ketahui di Python3 antara lain:* *int*, tipe data yang dapat kamu isi dengan bilangan bulat* *float*, tipe data yang dapat kamu isi dengan bilangan koma* *string*, tipe data yang dapat kamu isi dengan sebuah karakter atau kalimat * *complex*, tipe data yang dapat kamu isi dengan bilangan kompleks* *long*, tipe data yang dapat kamu isi dengan bilangan yang sangat besar. Bisa lebih dari 1 milyar* *boolean*, tipe data yang dapat kamu isi untuk mendukung operasi *bool*. Nilanya hanya **True** dan **False*** *list*, tipe data mirip *array* yang bisa kamu isi dengan tipe data apapun dan dapat diubah* *tuple*, tipe data mirip *list* tapi tidak dapat diubah* *dictionary*, tipe data *key-value* yang sangat berguna bila ingin membuat tipe data yang cukup terstrukturSekarang kita akan mencoba membuat beberapa variabel dengan tipe data yang telah disebutkan diatas.

Data Type

Setelah mengenal beberapa tipe data dasar di Python, kini saatnya kamu menguasai konversi tipe di Python. Suatu tipe data dapat dikonversi lagi ke tipe data lain dengan menggunakan beberapa *function* berikut:* **chr()**, mengubah angka ke karakter* **unichr()**, mengubah angka ke karakter unicode* **str()**, mengubah angka ke *string** **complex()**, mengubah angka ke bilangan kompleks* **float()**, mengubah angka ke bilangan koma* **hex()**, mengubah angka ke bentuk heksadesimal* **oct()**, mengubah angka ke bentuk octal* **int()**, mengubah tipe data lain ke angkaSekarang mari kita coba mengubah angka ke beberapa tipe data lain.

Type Conversion

*String* adalah suatu tipe data yang memiliki sederet karakter di dalamnya. Di Python kamu dapat membuat *string* dengan tiga cara.

* mengapitnya menggunakan tanda "
* mengapitnya menggunakan tanda '
* membuat *multiline string* dengan mengapitnya menggunakan tanda """

Selain itu kamu juga dapat melakukan *string formatting* dengan mencetak suatu nilai berdasarkan tipe datanya.


String Introduction

Ada beberapa operasi yang dapat dilakukan terhadap *string* di Python. 

* Menambah *string* dengan tanda "+"
* menambah *string* yang sama dengan tanda "*" sebanyak beberapa kali
* Menghitung panjang *string* dengan **len()**
* Membandingkan *string* dengan **cmp()**

String Operation

*String* memiliki sejumlah *method* yang cukup banyak dibanding tipe data lain. Oleh karena itu kita akan membaginya kedalam beberapa pembahasan.

Sekarang kita akan mengenal *method* - *method* yang digunakan untuk mengubah besar kecilnya suatu huruf. Diantaranya adalah sebagai berikut:

* **upper()**, mengubah semua huruf menjadi huruf kapital
* **lower()**, mengubah semua huruf menjadi huruf kecil
* **title()**, mengubah setiap huruf pertama di setiap kata menjadi huruf kapital
* **capitalize()**, mengubah huruf pertama menjadi huruf kapital
* **swapcase()**, mengubah huruf kecil menjadi kapital, mengubah huruf kapital menjadi huruf kecil

String Changecase

Setelah mencari potongan *string*, ada kalanya kita ingin membersikan potongan *string* dengan *string* lain atau malah menghilangkannya.

Kamu dapat menggunakan *method* berikut untuk menimpa potongan *string* lain:

* **replace()**, mengganti potongan *string* dengan potongan *string* baru
* **strip()**, menghapus spasi atau potongan *string* di bagian kiri dan kanan *string*,
* **rstrip()**, menghapus spasi atau potongan *string* di bagian kanan saja
* **lstrip()**, menghapus spasi atau potongan *string* di bagian kiri saja

String Replacement

Membelah *string* kadang dibutuhkan juga untuk melakukan operasi tertentu. Di Python kamu dapat membelah *string* berdasarkan potongan *string* tertentu atau tanda baca tertentu, atau juga membelahnya dengan berdasarkan *enter* atau baris baru suatu *string*.

* **split()**, membelah *string* berdasarkan tanda baca atau potongan *string* tertentu
* **splitlines()**, membelah *string* berdasarkan baris baru *string*

Split The String

Kamu pun dapat memeriksa suatu *string* apakah suatu angka atau bukan, suatu alfabet atau bukan, atau campuran. Juga besar kecilnya huruf dapat diperiksa.

Beberapa *method* berikut digunakan untuk memeriksa suatu *string* berdasarkan huruf atau diawali / diakhiri oleh *string* tertentu.

* **islower()**, memeriksa apakah semua huruf pada *string* adalah huruf kecil
* **isupper()**, memeriksa apakah semua huruf pada *string* adalah huruf kapital
* **istitle()**, memeriksa apakah *string* berada dalam mode **title**
* **isalnum()**, memeriksa apakah *string* mengandung angka dan huruf
* **isalfa()**, memeriksa apakah *string* hanya mengandung huruf
* **isdigit()**, memeriksa apakah *string* hanya mengandung angka
* **startswith()**, memeriksa apakah *string* diawali oleh suatu *string*
* **endswith()**, memeriksa apakah *string* diakhiri oleh suatu *string*

Belajar Coding Interaktif Pemrograman Python

Silabus

Tentang Kelas

Yang akan kamu dapat

Web Development

Mobile Development

Studi Kasus

Fundamental

Pemula

Menengah

Framework

Front End

Back End

Laravel

PHP

Kotlin

Android

Javascript

Wordpress

Database

Java

Go-Lang

Kelas Terbaru

Kelas Gratis

Populer

Roadmap

PlaygroundNEW

Belajar Coding Interaktif Pemrograman Python

Silabus

Sintaks Dasar

Operator

Pemilihan Kondisi

Perulangan

Array

String

Fungsi

Class dan Objek

Exception

Tentang Kelas

Yang akan kamu dapat