Kategori
Python

Pemecahan Masalah

Setelah sebelumnya kita telah mengeksplorasi berbagai bagian bahasa Python, sekarang kita coba untuk menggabungkan bagian-bagian tadi menjadi satu kesatuan, dengan mendesain dan membuat program yang benar-benar berguna. Idenya adalah belajar bagaimana Anda menulis skrip Python sendiri.

Permasalahan

Permasalahan yang ingin dipecahkan adalah “Saya ingin membuat sebuah program yang membackup semua berkas-berkas saya yang penting.”.

Meskipun ini masalah sederhana, namun tidak ada informasi yang cukup bagi kita untuk mulai dengan pemecahannya. Hal ini membutuhkan sedikit analisis lanjutan. Sebagai contoh, bagaimana kita menentukan berkas mana yang penting sehingga perlu dibackup? Bagaimana berkas-berkas tersebut disimpan? Di mana tempat penyimpanannya?

Setelah menganalisis masalah tersebut secara lebih mendalam, kita mulai mendesain program kita. Kita bisa mulai dengan membuat daftar bagaimana program kita akan berjalan nantinya. Dalam kasus ini, Saya telah membuat daftar berikut tentang bagaimana Saya ingin program tersebut bekerja. Jika Anda melakukan sendiri desainnya, mungkin Anda akan membuat analisis berbeda mengingat setiap orang punya pendekatan berbeda tentang bagaimana cara mereka melakukan pekerjaannya. Dan ini sama sekali bukan masalah. Tidak apa-apa.

  • Berkas dan direktori akan disimpan dalam berkas pendukung (backup) secara khusus dalam list.
  • Berkas pendukung harus disimpan dalam direktori pendukung utama.
  • Semua berkas disimpan dalam berkas pendukung dengan format zip.
  • Penamaan dalam berkas arsip berformat zip dibuat dalam tanggal dan waktu sekarang.
  • Kita menggunakan perintah baku zip yang sudah tersedia dalam setiap distribusi Linux/Unix. Pengguna Windows dapat memasang dari Halaman Proyek GnuWin32 and add C:\Program Files\GnuWin32\bin ke dalam variabel lingkungan yang dikenal oleh PATH sistem, sama seperti cara kita mengenal perintah python sendiri. Perhatikan bahwa perintah untuk mengarsipkan berkas dapat Anda gunakan selama aplikasi tersebut tersedia dan bisa diakses melalui baris perintah.

Solusi

Mengingat desain program kita relatif sudah komplet dan stabil, sekarang kita dapat menuliskan kode sebagai implementasi dari solusi kita.

Simpan sebagai backup_ver1.py:

import os
import time

# 1. Berkas dan direktori akan disimpan dalam berkas pendukung (_back up_) secara khusus dalam list.
source = ['"C:\\My Documents"', 'C:\\Code']
# Perhatikan bahwa kita harus menggunakan petik dua di dalam string yang memiliki spasi di dalamnya.

# 2. Berkas pendukung harus disimpan dalam direktori pendukung utama.
target_dir = 'E:\\Backup' # Ingat bahwa ini harus diganti dengan direktori yang benar-benar Anda gunakan

# 3. Semua berkas disimpan dalam berkas pendukung dengan format zip.
# 4. Penamaan dalam berkas arsip berformat zip  dibuat dalam tanggal dan waktu sekarang.
target = target_dir + os.sep + time.strftime('%Y%m%d%H%M%S') + '.zip'

# 5. Kita gunakan perintah zip untuk memasukkan berkas ke dalam arsip zip
zip_command = "zip -qr {0} {1}".format(target, ' '.join(source))

# Jalankan backup
if os.system(zip_command) == 0:
    print('Backup berhasil dilakukan ke', target)
else:
    print('Backup GAGAL')

Keluaran:

$ python backup_ver1.py
Backup berhasil dilakukan ke E:\Backup\20080702185040.zip

Sekarang, kita dalam fase testing untuk menguji apakah program yang kita buat dapat berjalan dengan baik. Jika tidak berjalan sesuai harapan, kita harus melakukan debug terhadap program kita, yakni dengan memperbaiki bus (kesalahan) dari program.

Jika kode program di atas tidak berjalan, buat satu baris perintah print(zip_command) di atas baris `os.system’, dan jalankan program kembali. Kemudian, salin/tempel hasil keluaran print zip_command yang ada di layar, dan lihat apakah tulisan yang tampil sudah menunjukkan bahwa program sudah berjalan dengan benar. Jika perintah tersebut gagal, cek kembali petunjuk perintah zip dan cari kemungkinan-kemungkinan kekeliruan. Jika perintah ini berhasil dijalankan, lihat kembali program Python Anda apakah keluarannya sesuai dengan apa yang tertulis di atas.

Bagaimana Cara Kerjanya

Anda akan memahami bahwa kita telah mengonversi desain menjadi kode program langkah demi langkah.

Kita menggunakan modul os dan time dengan cara mengimpornya terlebih dahulu. Kemudian, kita tentukan berkas dan direktori yang akan dibackup ke dalam direktori yang kita namakan lewat variabel target_dir. Nama file arsip zip yang akan kita buat, terdiri dari tanggal dan waktu saat perintah tersebut dijalankan dengan menggunakan fungsi time.strftime(). Pembuatan berkas tersebut juga akan menambahkan ekstensi .zip dan akan disimpan pada direktori target_dir.

Perhatikan bahwa variabel os.sep – yang akan memberikan pemisah antar direktori yang sesuai dengan sistem operasi Anda, yakni '/' jika berada dalam lingkungan Linux dan Unix, atau '\\' di Windows dan ':' di Mac OS. Penggunaan fungsi os.sep daripada menuliskan langsung karakter pemisahnya akan membuat program kita portabel dan berjalan di sistem yang heterogen.

Fungsi time.strftime() akan mengambil karakter tertentu yang sudah ditentukan untuk kita gunakan di program di atas. Karakter spesifik %Y akan diganti dengan tahun. Sedangkan %m akan diganti nama bulan dengan format desimal antara 01 hingga 12 dan seterusnya. Spesifikasi lengkap terhadap hal ini bisa dilihat di Manual Referensi Python.

Kita membuat nama dari file arsip yang dituju dengan tambahan operator yang menggabungkan/concatenates string, yakni dengan menggabungkan dua string untuk menjadi satu string gabungan. Kemudian kita juga membuat string zip_command yang berisi seluruh perintah yang akan kita eksekusi. Anda dapat mengecek apakah perintah ini berjalan atau tidak dengan menjalankannya di shell (baik di terminal Linux atau prompt DOS).

Perintah zip yang kita gunakan memiliki opsi dan parameter yang bisa dimasukkan. Opsi -q digunakan sebagai indikasi bahwa perintah zip haraus berjalan secara diam-diam (quietly). Opsi -r menunjukkan bahwa perintah zip harus dijalankan secara rekursif di dalam direktori, yakni dengan memasukkan seluruh sub direktori dan berkas di bawahnya. Kedua parameter tersebut dapat digabung menjadi satu parameter -qr. Opsi tersebut diikuti nama berkas arsip zip yang didalamnya akan diisi arsip seluruh berkas dan direktori yang akan dibackup. Kita mengonversi list source menjadi string lewat metode yang sudah pernah kita lihat penggunaannya sebelumnya, yakni join string.

Lalu kita benar-benar menjalankan perintah tersebut lewat fungsi os.system di mana fungsi tersebut akan menjalankan perintah seolah-olah dijalankan oleh sistem, yakni akan memberikan kembalian 0 jika berhasil, dan jika gagal akan memberikan nomor pesan kesalahan yang sesuai dengan sistem operasinya.

Tergantung dari keluaran perintah di atas, kita akan mencetak pesan pelaksanaan backup tersebut apakah gagal atau berhasil.

Itu saja, kita telah membuat skrip untuk membackup seluruh berkas-berkas penting kita!Catatan untuk pengguna Windows

Selain menggunakan backslash (garis miring kiri) untuk lepas dari urutan (sequences), Anda bisa menggunakan string dasar. Sebagai contoh 'C:\\Documents' atau r'C:\Documents'. Meskipun demikian jangan menggunakan 'C:\Documents' karena nantinya akan dianggap sebagai string urutan lepas (escape sequence\D.

Sekarang kita sudah memiliki skrip backup yang berjalan dengan baik, dan kita bisa menggunakannya setiap saat kita butuhkan untuk membuat backup berkas. Pengguna Linux/Unix sangat disarankan untuk menggunakan metode yang bisa dieksekusi sebagaimana yang telah kita diskusikan sebelumnya, sehingga kita dapat menjalankan skrip backup kapan saja dan di mana saja. Hal ini sering disebut fase operasi atau fase deployment dari sebuah perangkat lunak.

Meskipun program di atas dapat berjalan sebagaimana mestinya, tapi (biasanya) program pertama kali dijalankan tidak sesuai dengan yang diinginkan. Sebagai conth, mungkin akan ada masalah jika Anda tidak mendesain program dengan layak, atau Anda melakukan kesalahan saat mengetikkan kode sintaks, dan sebagainya. Selayaknya, kita harus kembali ke fase desain atau nanti Anda harus debug program yang Anda buat.

Versi Kedua

Versi pertama dari program yang kita buat telah berjalan sebagaimana mestinya. Meskipun demikian, kita bisa saja membuat beberapa perbaikan sehingga dapat berjalan lebih baik setiap harinya. Ini disebut sebagai fase pemeliharaan dari pengembangan perangkat lunak.

Salah satu perbaikan yang saya pikir akan berguna lebih baik adalah mekanisme penamaan berkas – dengan menggunakan waktu sebagai bagian dari nama berkas di dalam direktori backup utama. Keuntungan pertama adalah, backup Anda akan disimpan dalam format yang hierarkis sehingga lebih mudah untuk diatur. Keuntungan kedua, nama berkas jauh lebh pendek. Keuntungan ketiga, direktori yang terpisah akan membantu Anda jika Anda mambuat backup tiap hari, dan direktori yang terbuat adalah direktori yang memang benar-benar dibuat di hari itu.

Simpan sebagai backup_ver2.py:

import os
import time

# 1. Berkas dan direktori yang dibackup disebut secara khusus dalam daftar(_list_).
sumber = ['"C:\\My Documents"', 'C:\\Code']
# Perhatikan bahwa kita menggunakan tanda petik dua di dalam string untuk nama yang memiliki spasi.

# 2. Backup harus disimpan di dalam direktori backup utama
target_dir = 'E:\\Backup' # Mohon diingat untuk ganti ini dengan folder yang akan Anda gunakan

# 3. Berkas akan dibackup ke dalam berkas zip.
# 4. Nama sub direktori dengan nama hari ini di dalam direktori utama 
today = target_dir + os.sep + time.strftime('%Y%m%d')
# Waktu hari ini adalah nama dari arsip zip 
now = time.strftime('%H%M%S')

# Buat sub direktori jika belum ada di sana 
if not os.path.exists(today):
    os.mkdir(today) # make directory
    print('Berhasil membuat direktori', today)

# Nama berkas zip 
target = today + os.sep + now + '.zip'

# 5. Sekarang kita gunakan perintah zip untuk memasukkan berkas ke dalam arsip zip
zip_command = "zip -qr {0} {1}".format(target, ' '.join(source))

# Jalankan backup 
if os.system(zip_command) == 0:
    print('Berhasil backup ke dalam ', target)
else:
    print('Backup GAGAL')

Keluaran:

$ python3 backup_ver2.py
Berhasil membuat direktori E:\Backup\20080702
Berhasil backup ke dalam E:\Backup\20080702\202311.zip

$ python3 backup_ver2.py
Berhasil backup ke dalam E:\Backup\20080702\202325.zip

Bagaimana Cara Kerjanya

Hampir sebagian besar program sama dengan yang sebelumnya. Perbedaannya hanya ketika saat kita mengecek apakah sudah ada direktori yang namanya sama dengan nama hari ini di dalam direkotri backup utama dengan fungsi os.path.exists. Jika tidak ada, kita akan buat direktori dengan fungsi os.mkdir

Versi Ketiga

Versi kedua berjalan baik saat saya melakukan backup, tapi saat ada banyak berkas yang perlu dibackup, saya kesulitan untuk membedakan berkas-berkas yang saya backup! Misalnya saya membuat perubahan besar dalam program atau presentasi, lalu saya ingin mengasosiasikan perubahan tersebut dalam nama berkas atau nama arsip zip. Ini dapat diperoleh dengan mudah dengan memberikan komentar ddi dalam nama berkas arsip zip-nya.Catatan

Program berikut ini tidak akan jalan, jadi tidak perlu khawatir. Mohon ikuti karena ada pelajaran di sini.

Simpan sebagai backup_ver3.py:

import os
import time

# 1. Berkas-berkas dan direktori akan dibackup dalam list 
sumber = ['"C:\\My Documents"', 'C:\\Code']
# Perhatikan bahwa kita menggunakan petik dua di dalam string untuk nama yang memiliki spasi.

# 2. Backup harus disimpan dalam direktori backup utama 
target_dir = 'E:\\Backup' # Ingat untuk mengganti ini dengan direktori yang akan Anda gunakan

# 3. Berkas akan dibackup dalam format zip
# 4. Hari ini adalah nama sub direktori di bawah direktori utama

hari_ini = target_dir + os.sep + time.strftime('%Y%m%d')
# Waktu sekarang digunakan sebagai nama dalam arsip zip
sekarang = time.strftime('%H%M%S')

# Simpan komentar dari pengguna untuk membuat nama yang digunakan dalam berkas zip
komentar = input('Masukkan komentar --> ')
if len(komentar) == 0: # cek apakah komentar sudah diisikan
    target = hari_ini + os.sep + sekarang + '.zip'
else:
    target = hari_ini + os.sep + sekarang + '_' +
        komentar.replace(' ', '_') + '.zip'

# Buat sub direktori dulu jika belum ada
if not os.path.exists(hari_ini):
    os.mkdir(hari_ini) # membuat direktori 
    print('Berhasil membuat direktori ', hari_ini)

# 5. Selanjutnya kita gunakan perintah zip untuk memasukkan berkas ke dalam arsip zip
zip_command = "zip -qr {0} {1}".format(target, ' '.join(sumber))

# Jalankan backup 
if os.system(zip_command) == 0:
    print('Berhasil membuat backup di ', target)
else:
    print('Backup GAGAL')

Keluaran:

$ python3 backup_ver3.py
  File "backup_ver3.py", line 25
    target = hari_ini + os.sep + sekarang + '_' +
                                        ^
SyntaxError: invalid syntax

Kenapa ini (tidak) Berjalan:

Program ini tidak berjalan! Python mengatakan ada kesalahan sintaks, yang berarti bahwa skirp tidak sesuai dengan struktur yang diharapkan oleh Python. Ketika kita melihat pesan kesalahan yang diberikan oleh Python, pesan tersebut juga mengatakan di mana sebetulnya letak kesalahannya. Jadi kita memulai proses debugging untuk pemecahan masalah dari program kita di baris tersebut.

Saat melihat lebih dalam, kita lihat ada satu baris yang secara fisik satu, namun dipisah menjadi dua baris, namun kita tidak menetukan bahwa dua baris yang berbeda ini merupakan satu kesatuan. Pada dasarnya, Python telah menemukan bahwa operator tambahan (+) tanpa operand dalam baris tersebut, sehingga tidak tahu bagaimana harus melanjutkan. Ingat bahwa kita bisa menentukan satu bagis logis di dalam dua baris fisik namun tetap menjadi satu kesatuan. Jadi kita akan perbaiki program kita. Perbaikan program saat kita menemukan pesan kesalahan semacam ini dinamakan bug fixing.

Versi ke Empat

Simpan sebagai backup_ver4.py:

import os
import time

# 1. Berkas-berkas dan direktori akan dibackup dalam list 
sumber = ['"C:\\My Documents"', 'C:\\Code']
# Perhatikan bahwa kita menggunakan petik dua di dalam string untuk nama yang memiliki spasi.

# 2. Backup harus disimpan dalam direktori backup utama 
target_dir = 'E:\\Backup' # Ingat untuk mengganti ini dengan direktori yang akan Anda gunakan

# 3. Berkas akan dibackup dalam format zip
# 4. Hari ini adalah nama sub direktori di bawah direktori utama

hari_ini = target_dir + os.sep + time.strftime('%Y%m%d')
# Waktu sekarang digunakan sebagai nama dalam arsip zip
sekarang = time.strftime('%H%M%S')

# Simpan komentar dari pengguna untuk membuat nama yang digunakan dalam berkas zip
komentar = input('Masukkan komentar --> ')
if len(komentar) == 0: # cek apakah komentar sudah diisikan
    target = hari_ini + os.sep + sekarang + '.zip'
else:
    target = hari_ini + os.sep + sekarang + '_' + \
        komentar.replace(' ', '_') + '.zip'

# Buat sub direktori dulu jika belum ada
if not os.path.exists(hari_ini):
    os.mkdir(hari_ini) # membuat direktori 
    print('Berhasil membuat direktori ', hari_ini)

# 5. Selanjutnya kita gunakan perintah zip untuk memasukkan berkas ke dalam arsip zip
zip_command = "zip -qr {0} {1}".format(target, ' '.join(sumber))

# Jalankan backup 
if os.system(zip_command) == 0:
    print('Berhasil membuat backup di ', target)
else:
    print('Backup GAGAL')

Keluaran:

$ python3 backup_ver4.py
Masukkan komentar --> tambah contoh baru 
Berhasil membuat backup di E:\Backup\20080702\202836_tambah_contoh_baru.zip

$ python3 backup_ver4.py
Masukkan komentar -->
Berhasil membuat backup di E:\Backup\20080702\202839.zip

Bagaimana Cara Kerjanya

Sekarang program ini berjalan sesuai dengan yang kita harapkan! Mari kita lihat bersama, di sebelah mana yang kita perbaiki dari versi 3. Kita meminta komentar/masukan dengan menggunakan fungsi input, kemudian kita cek kembali apakah pengguna memasukkan komentar sesuai dengan panjang yang kita tentukan lewat fungsi len. Jika pengguna menekan tombol enter tanpa memasukkan apapun (mungkin hanya backup rutin atau tidak ada perubahan berkasnya), kita langsung memproses sesuai langkah yang telah kita lakukan sebelumnya.

Meskipun demikian, jika ada komentar yang dituliskan, komentar ini akan dimasukkan ke dalam nama berkas, sebelum ekstensi .zip. Perhatikan bahwa kita mengganti spasi yang ada dalam komentar dengan garis bawah _. Alasannya adalah karena lebih mudah mengatur berkas-berkas dengan nama tanpa spasi.

Perbaikan Lebih Lanjut

Versi ke empat merupakan skrip yang berjalan secara memuaskan bagi banyak pengguna, namun selalu ada ruang untuk perbaikan. Sebagai contoh, Anda dapat menambahkan level verbosity (lebih banyak kata/informasi yang ditampilkan oleh skrip) dengan menambahkan opsi -v agar program Anda lebih berbicara.

Kemungkinan perbaikan lainnya misalkan dengan memperbolehkan berkas-berkas tambahan dan direktori untuk diumpankan pada baris perintah. Kita dapat memperoleh informasi pilihan kata yang diumpankan ini lewat fungsi sys.argv yang berupa list, sehingga kita dapat menambahkan metode extend yang telah diberikan oleh class list.

Perbaikan terbaik yang bisa Anda lakukan adalah dengan tidak menggunakan cara os.system untuk membuat berkas arsip, namun menggunakan modul yang secara baku sudah ada, yakni zipfile atau tarfile. Keduanya merupakan bagian dari pustaka standar dan langsung tersedia tanpa memerlukan dependensi program zip eksternal yang mengharuskan program zip tersedia terlebih dahulu di komputer Anda.

Namun, saya menggunakan cara os.system dalam membuat backup di program di atas untuk kepentingan pembelajaran, sehingga contoh yang diberikan cukup sederhana untuk dipahami oleh setiap orang, namun juga nyata karena dapat dijalankan untuk diambil manfaatnya.

Dapatkah Anda coba membuat versi ke lima yang menggunakan modul zipfile daripada fungsi sistem os.system?

Proses Pengembangan Perangkat Lunak

Kita telah melakukan beberapa fase dalam proses pengembangan perangkat lunak. Fase ini dapat diringkas sebagai berikut:

  1. Apa (Analisis)
  2. Bagaimana (Desain)
  3. Mengerjakan (Implementasi)
  4. Uji coba (Uji coba dan debugging)
  5. Menggunakan (Operasi atau Pemasangan)
  6. Perawatan (Perbaikan terus menerus)

Salah satu prosedur menulis perangkat lunak yang direkomendasikan sudah kita ikuti satu demi satu dalam membuat skrip backup sebelumnya: Dimulai dengan analisis dan desain. Lalu Mulai dengan implementasi untuk program yang sederhana. Kemudian kita lakukan ujicoba dan debug. Kita gunakan programnya agar berjalan sesuai dengan yang diharapkan. Sekarang, kita menambahkan fitur-fitur yang diinginkan, kemudian melakukan kembali proses dari siklus Kerjakan-Ujicoba-Gunakan sebanyak yang dibutuhkan. Ingat bahwa Perangkat lunak tidak tumbuh, namun dibangun.

Ringkasan

Kita telah melihat bagaimana membuat program/skrip Python kita sendiri, dan berbagai tahapan yang dibutuhkan dalam menulis sebuah perangkat lunak. Anda mungkin dapat memanfaatkannya untuk menulis program Anda sendiri sebagaimana yang sudah Anda kerjakan di bab ini hingga Anda nyaman dengan Python sebagaimana Anda nyaman dengan pemecahan-masalah.

Selanjutnya, kita akan diskusikan pemrograman berbasis-objek.

Kategori
Python

Struktur Data

Struktur data pada dasarnya merupakan struktur yang dapat menyimpan data secara bersama-sama. Dengan kata lain, mereka digunakan untuk menyimpan koleksi data yang berkaitan satu sama lain.

Ada empat struktur data built-in di Python – list, tuple, dictionary dan set. Kita akan lihat bagaimana penggunaan masing-masing dan bagaimana struktur data tersebut dapat mempermudah hidup kita.

List

list adalah struktur data yang meyimpan koleksi item yang ditempatkan secara berurut. Misalnya Anda dapat menyimpan item berurut(sequence) di dalam list. Hal itu sangat mudah dimengerti jika Anda dapat membayangkan daftar belanja, di mana Anda punya daftar item yang harus dibeli. Namun jika di daftar belanja Anda membariskan item dengan baris baru, di Python Anda cukup meletakkan koma di antaranya.

Penulisan list harus diapit dalam tanda kurung kotak (square bracket), sehingga Python dapat memahami bahwa Anda sedang membuat list. Sekali Anda buat list, Anda dapat menambah, menghapus atau mencari item di dalam list. Karena kita bisa menambah dan menguranginya, kita dapat katakan bahwa list termasuk tipe data mutable – yang berarti nilainya bisa diganti.

Pengenalan Singkat Object (Objek) dan Classes (Kelas)

Meskipun saya menunda pembahasan tentang object dan class hingga sekarang, saat ini penjelasan sedikit dibutuhkan sehingga Anda dapat memahami list secara lebih baik. Kita akan mengeksplorasi topik ini secara lebih detail di bab berikutnya.

List adalah contoh yang bisa dipahami tentang penggunaan object dan class. Ketika kita menggunakan variabel bernama i dan memberi nilai terhadap variabel tersebut, misalnya integer 5, Anda dapat berpikir membuat object (berupa instance) i dari class (berupa tipe) int. Sebagai bantuan, Anda dapat membaca help(int) untuk memahaminya lebih baik.

Sebuah class juga memiliki methods/metode berupa fungsi yang didefinisikan khusus hanya untuk class tersebut. Anda dapat menggunakan fungsi bagian ini, jika dan hanya jika Anda mendeklarasikan objek dari class tersebut. Sebagai contoh, Python memberikan metode append untuk class list yang memungkinkan Anda menambah item di akhir list. Misalnya listku.append('sesuatu') yang akan menambahkan string tersebut (sesuatu) di akhirlistku`. Perhatikan penggunaan notasi bertitik untuk mengakses method dari sebuah object.

Sebuah class juga punya fields yang merupakan variabel tapi hanya digunakan untuk class tersebut. Anda dapat menggunakan variabel atau nama ini, hanya ketika Anda mendeklarasikan objek dari kelas tersebut. Fields juga diakses lewat notasi bertiti, sebagai contoh, listku.field.

Contoh (simpan dengan nama menggunakan_list.py):

# Berikut adalah daftar belanja saya
daftarbelanja = ['apel', 'mangga', 'wortel', 'pisang']

print('Saya memiliki ', len(daftarbelanja), ' barang untuk dibeli.')

print('Barang tersebut adalah:', end=' ')
for item in daftarbelanja:
    print(item, end=' ')

print('\nSaya juga harus membeli beras.')
daftarbelanja.append('beras')
print('Daftar belanja saya sekarang', shoplist)

print('Saya akan mengurutkan daftar saya sekarang')
daftarbelanja.sort()
print('Daftar belanja yang sudah diurutkan adalah', shoplist)

print('Barang pertama yang akan saya beli adalah', shoplist[0])
olditem = daftarbelanja[0]
del daftarbelanja[0]
print('Saya telah membeli', olditem)
print('Daftar belanja saya sekarang ', daftarbelanja)

Keluaran:

$ python3 menggunakan_list.py
Saya memiliki 4 barang untuk dibeli.
Barang tersebut adalah: apel mangga wortel pisang
Saya juga harus membeli beras.
Daftar belanja saya sekarang ['apel', 'mangga', 'wortel', 'pisang', 'beras']
Saya akan mengurutkan daftar saya sekarang
Daftar belanja yang sudah diurutkan adalah ['apel', 'beras', 'mangga', 'pisang', 'wortel']
Barang pertama yang akan saya beli adalah apel
Saya telah membeli apel
Daftar belanja saya sekarang ['beras', 'mangga', 'pisang', 'wortel']

Bagaimana Cara Kerjanya:

Variabel daftarbelanja adalah daftar belanja seseorang yang akan pergi ke pasar. Di dalam daftarbelanja, kita hanya menyimpan nama string yang akan dibeli, tapi Anda dapat menambahkan segala macam jenis objek ke dalam daftar, termasuk angka, bahkan bisa juga list lainnya.

Kita juga dapat menggunakan putaran for..in untuk mengulangi seluruh item di dalam list. Sekarang, harusnya Anda juga sudah mulai memahami bahwa list juga merupakan urutan (sequence). Kekhususan dari sequence akan didiskusikan di bagian berikutnya.

Perhatikan bahwa argumen keyword end di dalam fungsi print mengindikasikan bahwa kita ingin outputnya diakhiri dengan spasi daripada baris baru seperti biasanya.

Berikutnya, kita menambahkan item ke dalam list dengan menggunakan metode append ke dalam object list, sebagaimana telah didiskusikan sebelumnya. Lalu kita periksa apakah itemnya sudah dimasukkan ke dalam list atau belum dengan mencetaknya ke layar dengan rapi, cukup dengan memberikan perintah print.

Lalu kita sortir listnya dengan menggunakan metode sort. Penting untuk dipahami bahwa metode ini akan berpengaruh ke dalam listnya sendiri, dan tidak akan mengembalikan list yang telah dimodifikasi. Hal ini berbeda dengan cara kerja string. Ini kenapa list disebut sebagai mutable sedangkan string disebut immutable.

Selanjutnya, ketika kita selesai belanja di pasar, kita akan menghapus item yang sudah dibeli dari daftar. Ini dapat dilakukan dengan menggunakan perintah del. Di sini cukup dimasukkan item-item yang akan dihapus, statemen del akan menghapuskannya untuk kita. Kita menentukan item pertama dari daftar yang akan dihapus mulai dari 0, sehingga perintahnya adalah del shoplist[0] (ingat bahwa Python selalu mulai penghitungan dari 0).

Jika Anda ingin tahu semua metode yang didefinisikan oleh object list, ketikkan help(list) dari konsol python untuk detailnya.

Tuple

Tuples digunakan untuk menyimpan object lebih dari satu secara bersamaan. Bayangkan hal ini mirip dengan list, tapi tanpa fungsi yang diberikan class list untuk Anda. Salah satu fitur tuples adalah immutable seperti string. Dengan kata lain Anda tidak bisa modifikasi tuples.

Tuples didefinisikan dengan menentukan item dipisahkan oleh koma, dengan tambahan pilihan dalam kurung (tidak wajib).

Tuples biasanya digunakan dalam kasus di mana sebuah statemen atau fungsi yang didefinisikan sendiri dapat berasumsi bahwa nilai di dalamnya tidak berubah. Atau dengan kata lain nilai dari sebuah tuple tidak akan pernah berubah.

Contoh (simpan dengan nama menggunakan_tuple.py):

bonbin = ('piton', 'gajah', 'penguin') # ingat bahwa tanda kurung tidak wajib
print('Hewan di kebon binatang berjumlah ', len(bonbin))

bonbin_baru = 'monyet', 'onta', bonbin
print('Kerangkeng di kebun binatang baru berjumlah ', len(bonbin_baru))
print('Semua binatang di kebun binatang terdiri', bonbin_baru)
print('Binatang yang dibawa dari kebun binatang lama adalah ', bonbin_baru[2])
print('Binatang terakhir yang dibawa dari kebun binatang lama adalah', bonbin_baru[2][2])
print('Jumlah seluruh binatang adalah', len(bonbin_baru)-1+len(bonbin_baru[2]))

Keluaran:

$ python3 using_tuple.py
Hewan di kebon binatang berjumlah 3
Kerangkeng di kebun binatang baru berjumlah 3
Semua binatang di kebun binatang terdiri ('monyet', 'onta', ('piton', 'gajah', 'penguin'))
Binatang yang dibawa dari kebun binatang lama adalah  ('piton', 'gajah', 'penguin')
Binatang terakhir yang dibawa dari kebun binatang lama adalah penguin
Jumlah seluruh binatang adalah 5

Bagaimana Cara Kerjanya:

Variabel bonbin merujuk pada sebuah tuple. Kita lihat bahwa fungsi len dapat digunakan untuk mencari panjang sebuah tuple. Ini juga mengindikasikan bahwa tuple juga merupakan sequence.

Kita sekarang memindahkan binatang-binatang ini ke dalam kebun binatang baru mengingat kebun binatang lama sudah ditutup. Sehingga, tuple bonbin_baru berisi binatang-binatang yang sebelumnya sudah ada, dan binatang yang dibawa dari kebon binatang lama. Kembali ke dunia nyata, catat bahwa tuple di dalam tuple tidak pernah kehilangan identitas.

Kita dapat mengakses item di dalam tuple, dengan menyebutkan posisi item di dalam tanda kurung kotak sebagaimana yang telah kita lakukan terhadap lists. Ini dinamakan operator indexing. Kita mengakses item ketiga dari bonbin_baru dengan menyebutkan bonbin_baru[2] dan kita mengakses item ketiga di dalam item ketiga tuple bonbin_baru dengan menyebutkan bonbin_baru[2][2]. Ini cukup mudah jika Anda memahami idiomnya.Tanda Dalam Kurung (parentheses)

Meskipun dalam kurung tidak bersifat wajib, Saya lebih anjurkan untuk selalu menggunakannya, untuk menunjukkan hal tersebut adalah tuple. Hal ini menghindari ambiguitas. Sebagai contoh print(1,2,3) dan print( (1,2,3) ) memiliki arti yang berbeda – di mana print yang pertama menetak tiga angka, sedangkan print kedua mencetak sebuah tuple (yang berisi tiga angka).Tuple dengan item 0 atau 1

Sebuah tuple kosong dibuat dari tanda kurung kosong, seperti misalnya kosong = (). Bagaimanapun juga, tuple dengan satu item tidak sesederhana itu. Anda harus menyebutkannya dengan koma diikuti dengan item pertama (dan satu-satunya) sehingga Python dapat membedakan antara tuple dengan tanda kurung berpasangan yang mengelilingi ekspresi objek. Anda harus menyebutkan singleton = (2,) jika Anda ingin membuat sebuah tuple yang berisi angka 2.Catatan untuk programmer Perl

Sebuah list di dalam list tidak akan kehilangan identitas, dengan kata lain list tidak disatukan sebagaimana di dalam Perl. Ini juga berlaku untuk tuple di dalam tuple, atau list di dalam tuple dan seterusnya. Sejauh yang diperhatikan oleh Python, mereka hanyalah objects yang menyimpan objects lainnya. Tidak ada pertimbangan lain.

Pustaka (dictionary)

Pustaka seperti buku-alamat di mana Anda dapat menemukan alamat atau detail kontak seseorang hanya dengan mengetahui namanya. Dengan kata lain kita asosiasikan kunci atau keys (nama) dengan nilai atau value (informasi detail). Perlu dicatat bahwa kunci dalam sebuah pustaka haruslah unik dan Anda tidak dapat menemukan informasi yang benar jika dua orang punya nama yang sama.

Mohon dicatat bahwa Anda hanya dapat menggunakan immutable objects (objek yang tidak bisa dimutasi/diubah jenisnya seperti string) untuk kunci sebuah pustaka namun Anda dapat menggunakan objek yang bisa berubah bentuk (mutable object) maupun objek yang tidak bisa berubah bentuk (immutable objects). Dengan kata lain Anda seharusnya menggunakan objek yang sederhana untuk kunci.

Pasangan kunci dan nilainya yang digunakan dalam pustaka mengunakan notasi d = {kunci1: nilai1, kunci2:nilai2}. Perhatikan bahwa pasangan kunci-nilai dipisahkan dengan titik dua dan pasangan tersebut dipisahkan dengan koma hingga ditutup dengan kurung kurawal penutup.

Perlu diingat bahwa pasangan kunci-nilai di dalam pustaka tidak bisa diurutkan. Jika Anda ingin mengurutkannya secara khusus, Anda harus malkukan pengurutan (sort) sebelum menggunakannya.

Pusaka yang Anda gunakan merupakan instance/objek dari kelas dict.

Contoh (simpan dengan nama menggunakan_pustaka.py):

# 'ba' adalah kepanjangan dari 'b'uku 'a'lamat 

ba = {  'Swaroop'   : 'swaroop@swaroopch.com',
        'Larry'     : 'larry@wall.org',
        'Matsumoto' : 'matz@ruby-lang.org',
        'Spammer'   : 'spammer@hotmail.com'
    }

print("Alamat email Swaroop adalah ", ba['Swaroop'])

# Menghapus pasangan kunci-nilai
del ba['Spammer']

print('\nAda {0} kontak di buku alamat\n'.format(len(ba)))

for nama, alamat in ba.items():
    print('Kontak {0} memiliki alamat {1}'.format(name, address))

# Menambahkan pasangan kunci-nilai
ba['Guido'] = 'guido@python.org'

if 'Guido' in ba:
    print("\nAlamat email Guido adalah ", ab['Guido'])

Keluaran:

$ python3 menggunakan_pustaka.py
Alamat email Swaroop adalah swaroop@swaroopch.com

Ada 3 kontak di buku alamat

Kontak Swaroop memiliki alamat swaroop@swaroopch.com
Kontak Matsumoto memiliki alamat matz@ruby-lang.org
Kontak Larry memiliki alamat larry@wall.org

Alamat email Guido adalah guido@python.org

Bagaimana Cara Kerjanya

Kita membuat pustaka ba dengan notasi yang telah kita diskusikan sebelumnya. Lalu kita mengakses pasangan nilai-kunci dengan menyebutkan kunci dengan menggunakan operator indeks sesuai yang telah didiskusikan dalam konteks lists dan tuples. Coba teliti sintaks sederhananya.

Kita dapat menghapus pasangan kunci-nilai dengan menggunakan teman lama kita, statemen del. Kita cukup menyebut nama pustaka dan operator indeks sebagai kunci dan memberikannya pada statemen del. Nilainya tidak perlu kita ketahui untuk menjalankan perintah ini.

Berikutnya, kita mengakses pasangan kunci-nilai dari pustaka dengan menggunakan metode items yang mengembalikan daftar tuples, di mana masing-masing tuple berisi pasangan dari item tersebut – kunci diikuti dengan nilainya. Kita ambil pasangan tersebut dan menyematkan variabel nama dan alamat pada setiap pasangan lewat putaran for..in dan mencetak nilai di dalam blok-for.

Kita dapat menambahkan pasangan kunci-nilai, cukup dengan operator indeks untuk mengakses kunci dan memberikan nilainya, sebagaimana kita lakukan terhadap Guido dalam kasus di atas.

Kita dapat mengecek apakah pasangan kunci-nilai ada, dengan menggunakan operator in.

Untuk daftar metode dalam class dict, lihat lewat help(dict).Argumen Kata Kunci dan Pustaka

Dalam catatan yang lain, jika Anda harus menggunakan argumen kata kunci dalam fungsi Anda, maka Anda sudah menggunakan pustaka! Coba pikirkan kembali – pasangan kunci-nilai yang Anda tentukan dalam daftar parameter definisi fungi dan ketika Anda mengakses variabel dalam fungsi Anda, itu hanyalah sebuah kunci akses dari pustaka yang bersangkutan (biasanya disebut sebagai tabel simbol dalam terminologi desain kompiler).

Urutan (Sequence)

Listtuple dan string adalah contoh dari urutan(sequence), namun apa itu urutan dan apa yang khusus tentangnya?

Fitur utamanya adalah ujian keberadaan, (seperti ekspresi di in dan not in) dan operasi mengindeks, yang memungkinkan untuk mengambil item tertentu di dalam urutan secara langsung.

Ada tiga jenis urutan sebagaimana disebut di atas – list, tuple dan string, yang juga punya operasi mengiris yang memungkinkan kita untuk mengambil irisan dari urutan atau bagian dari urutan.

Contoh (simpan sebagai seq.py):

daftarbelanja = ['apel', 'mangga', 'wortel', 'pisang']
nama = 'swaroop'

# Operasi 'mengindeks' atau 'berlangganan'
print('Item 0 adalah', daftarbelanja[0])
print('Item 1 adalah', daftarbelanja[1])
print('Item 2 adalah', daftarbelanja[2])
print('Item 3 adalah', daftarbelanja[3])
print('Item -1 adalah', daftarbelanja[-1])
print('Item -2 adalah', daftarbelanja[-2])
print('Character 0 is', nama[0])

# Mengiris sebuah _list_
print('Item 1 ke 3 adalah', shoplist[1:3])
print('Item 2 ke end adalah', shoplist[2:])
print('Item 1 ke -1 adalah', shoplist[1:-1])
print('Item dari awal hingga akhir adalah', shoplist[:])

# Mengiris _string_
print('karakter 1 ke 3 adalah', nama[1:3])
print('karakter 2 ke terakhir adalah', nama[2:])
print('karakter 1 ke -1 adalah', nama[1:-1])
print('karakter dari awal hingga akhir adalah', nama[:])

Keluaran:

$ python3 seq.py
Item 0 adalah apel
Item 1 adalah mangga
Item 2 adalah wortel
Item 3 adalah pisang
Item -1 adalah pisang
Item -2 adalah wortel
Karakter 0 adalah s
Item 1 ke 3 adalah ['mangga', 'wortel']
Item 2 ke terakhir adalah ['wortel', 'pisang']
Item 1 ke -1 adalah ['mangga', 'wortel']
Item dari awal hingga akhir adalah ['apel', 'mangga', 'wortel', 'pisang']
karakter 1 ke 3 adalah wa
karakter 2 ke terakhir adalah aroop
karakter 1 ke -1 adalah waroo
karakter dari awal hingga akhir adalah swaroop

Bagaimana Cara Kerjanya

Pertama, kita lihat bagaimana menggunakan indeks untuk mengambil item satuan dari sebuah urutan. Ini juga bisa disebut sebagai operasi berlangganan. Saat Anda menyebutkan sebuah angka ke urutan dalam tanda kurung kotak sebagaimana yang ditampilkan di atas, Python akan mengambilkan untuk Anda, item yang berada dalam posisi bersangkutan dalam sebuah urutan. Ingat bahwa Python mulai menghitung angka dari 0. Sehingga daftarbelanja[0] akan mengambil item pertama dan daftarbelanjap3[ akan mengambil item ke empat dalam urutan daftarbelanja.

Indeks juga bisa berupa angka negatif, dalam kasus ini, posisinya akan dihitung dari akhir urutan. Sehingga daftarbelanja[-1] akan merujuk pada item terakhir dari sebuah urutan dan daftarbelanja[-2] mengambil angka kedua terakhir dalam urutan.

Operasi pengirisan digunakan dengan menyebut nama urutan dan bisa ditambahkan (tidak harus) angka atau pasangan angka yang dipisah dengan titik dua dalam tanda kurung kotak. Mohon dicatat bahwa ini sangat mirip dengan operasi mengindeks yang sudah Anda gunakan hingga sekarang. Dan perlu diingat bahwa angka tersebut tidak harus, namun titik dua adalah keharusan.

Angka pertama (sebelum titik dua) dalam operasi pengirisan merujuk pada posisi di mana irisan dimulai dan angka kedua (setelah titik dua) menunjukkan pada angka keberapa urutan akan berhenti. Jika angka kedua tidak diisi, Python akan menghentikannya hingga angka terakhir. Catat bahwa irisan akan mengembalikan angka awal pada posisi start dan akan berakhir satu angka sebelum posisi terakhir. Atau dengan kata lain posisi awal akan ikut dikembalikan namun posisi terakhir tidak akan diikutkan dalam potongan urutan.

Sehingga, daftarbelanja[1:3] akan mengembalikan iritasn yang dimulai pada posisi 1, termasuk psosisi dua namun berhenti di posisi tiga sehingga hanya dua irisan yang dikembalikan. Mirip dengan itu, daftarbelanja[:] akan mengembalikan seluruh urutan.

Anda juga dapat memotong dengan posisi negatif. Angka negatif digunakan untuk posisi dari akhir urutan. Sebagai contoh daftarbelanja[:-1] akan mengembalikan irisan dari urutan yang mengecualikan item terakhir dari urutan, namun menampilkan semua yang lainnya.

Anda juga dapat memberikan argumen ketiga dari potonga, merupakan langkah dari irisan (secara baku, langkah urutannya adalah 1):

>>> daftarbelanja = ['apel', 'mangga', 'wortel', 'pisang']
>>> daftarbelanja[::1]
['apel', 'mangga', 'wortel', 'pisang']
>>> daftarbelanja[::2]
['apel', 'wortel']
>>> daftarbelanja[::3]
['apel', 'pisang']
>>> daftarbelanja[::-1]
['pisang', 'wortel', 'mangga', 'apel']

Perhatikan bahwa ketika langkahnya 2, kita mengambil item dengan posisi 0, 2, … Dan ketika langkahnya 3, kita mengambil item pada posisi 0, 3, dan seterusnya.

Cobalah beberapa kombinasi dengan penggunaan sesuai spesifikasi urutan dengan menggunakan Python interpreter yang interaktif atau prompt sehingga Anda dapat melihat keluarannya secara langsung. Hal yang bagus pada urutan adalah bahwa Anda bisa mengakses tuple,list dan string dengan cara yang sama!

Set

Set adalah koleksi objek sederhana yang tidak berurut. Ini digunakan ketika keberadaan objek dalam sebuah koleksi lebih penting daripada urutannya atau berapa kali muncul.

Dengan menggunakan set Anda dapat mengetes keanggotaan, apakah dia merupakan subset dari set yang lain, menemukan interseksi dari dua set dan lainnya.

>>> bri = set(['brazil', 'rusia', 'india'])
>>> 'india' in bri
True
>>> 'usa' in bri
False
>>> bric = bri.copy()
>>> bric.add('china')
>>> bric.issuperset(bri)
True
>>> bri.remove('russia')
>>> bri & bric # ATAU bri.intersection(bric)
{'brazil', 'india'}

Bagaimana Cara Kerjanya:

Contoh berikut ini bisa menjelaskan-sendiri sebab melibatkan set dasar teori matematika yang diajarkan di sekolah.

Referensi

Ketika Anda membuat objek dan menyematkannya pada variable, variable tersebut hanya mereferensikan pada objek dan tidak merepresentasikan objek itu sendiri! Dengan kata lain, itu hanyalah nama variabel yang menunjukkan bagian dari memori komputer tempat di mana objek tersebut diletakkan. Ini disebut sebagai binding atau mengikat nama kepada objek tersebut.

Secara umum, Anda tidak perlu khawatir tentang hal ini, namun ada beberapa efek ringan atas referensi yang perlu Anda perhatikan:

Contoh (simpan sebagai referensi.py):

print('Tugas Sederhana')
daftarbelanja = ['apel', 'mangga', 'wortel', 'pisang']
daftarku = daftarbelanja # daftarku hanya sekadar nama yang merujuk pada objek yang sama!

del daftarbelanja[0] # Saya membeli item pertama, sehingga saya perlu menghapusnya dari daftar

print('daftar belanja ', daftarbelanja)
print('daftarku', daftarku)
# perhatikan bahwa daftarbelanja dan daftarku, keduanya mencetak hal yang sama 
# tanpa 'apel' mengonfirmasi bahwa keduanya merujuk pada objek yang sama

print('Salin dengan membuat irisan penuh')
daftarku = daftarbelanja[:] # membuat salinan lewat irisan penuh
del daftarku[0] # menghapus item pertama

print('daftar belanja ', daftarbelanja)
print('daftarku', daftarku)
# perhatikan perbedaan kedua list tersebut sekarang

Keluaran:

$ python3 referensi.py
Tugas Sederhana
daftar belanja ['mangga', 'wortel', 'pisang']
daftarku ['mangga', 'wortel', 'pisang']
Salin dengan membuat irisan penuh
daftar belanja ['mangga', 'wortel', 'pisang']
daftarku ['wortel', 'pisang']

Bagaimana Cara Kerjanya

Hampir semua penjelasan sudah ditulis di komentar.

Mohon diingat jika Anda ingin membuat salinan sebuah daftar (list) atau sejenis urutan (sequence) atau objek yang sedikit rumit (bukan objek sederhana seperti integer), Anda harus membuat operasi irisan untuk membuat salinan. Jika Anda hanya menyebut nama dengan nama variabel lain, keduanya akan ‘’merujuk’’ pada objek yang sama dan ini bisa menimbulkan masalah jika Anda tidak hati-hati.Catatan untuk programmer Perl

Ingat bahwa statemen penugasan seperti daftar (listtidak membuat salinan. Anda harus gunakan operasi irisan untuk menyalin sebuah urutan.

Lebih banyak tentang String

Kita telah mendiskusikan string secara lebih detail sebelumnya. Apa lagi yang bisa kita eksplorasi dari situ? Jika Anda tahu string adalah sebuah objek dan memiliki semua metode untuk melakukan berbagai operasi, seperti mengecek bagian atau bahkan menghapus spasi!

String yang Anda gunakan di dalam program merupakan objek dari kelas str. Beberapa metode yang bermanfaat didemonstrasikan dalam contoh berikut. Untuk daftar lengkap dari metode ini, lihat help(str).

Contoh (simpan dengan nama metode_str.py):

nama = 'Swaroop' # Ini adalah objek string

if name.startswith('Swa'):
    print('Ya, string dimulai dengan "Swa"')

if 'a' in name:
    print('Ya, string memiliki huruf "a"')

if name.find('war') != -1:
    print('Ya, string memiliki kata "war"')

delimiter = '_*_'
daftarku = ['Brazil', 'Russia', 'India', 'China']
print(delimiter.join(daftarku))

Keluaran:

$ python3 metode_str.py
Ya, string dimulai dengan "Swa"
Ya, string memiliki huruf "a"
Ya, string memiliki kata "war"
Brazil_*_Russia_*_India_*_China

Bagaimana Cara Kerjanya

Di sini kita lihat banyak metode string kita gunakan. Metode startswith digunakan untuk mengecek apakah objek tersebut dimulai dengan string sebagaimana dimaksud. Operator in digunakan untuk mengecek apakah suatu string (misal kata atau kumpulan huruf/angka) merupakan bagian dari string.

Metode find digunakan untuk mencari posisi substring di dalam string; find memberikan kembalian -1 jika tidak berhasil. Kelas str juga punya metode keren seperti join untuk menggabungkan item dari sebuah urutan dengan menggunakan string tertentu sebagai delimiter dari tiap item sehingga menghasilkan string baru yang lebih besar.

Ringkasan

Kita telah mengeksplorasi banyak struktur data built-in yang ada di Python secara detail Struktur data ini esensial dalam menulis program dalam ukuran apa saja.

Sekarang kita sudah memahami dasar-dasar Python, kita akan lihat bagaimana mendesain dan menulis program Python yang digunakan di dunia nyata.

Kategori
Python

Modul Python

Anda sudah lihat bagaimana Anda dapat menggunakan kembali kode di dalam program dengan membuat fungsi sekali saja. Bagaimana jika ingin menggunakan beberapa fungsi di program lain yang Anda tulis. Sebagaimana sudah ditebak, jawabannya adalah modul Python.

Ada beberapa metode dalam menulis modul, tapi cara yang paling mudah adalah membuat file dengan ekstensi .py yang berisi fungsi dan variabel.

Metode lain untuk menulis modul adalah dengan menulis modul di bahasa ibu di mana interpreter Python ditulis. Sebagai contoh, Anda dapat menulis modul di bahasa pemrograman C dan saat selesai dikompilasi, modul tersebut dapat digunakan dalam kode Python Anda dengan menggunakan interpreter Python standar.

Contoh Modul

Sebuah modul dapat diimpor oleh program lain dan menggunakan fungsinya. Cara ini juga kita pakai dalam memanfaatkan pustaka standar Python. Pertama, akan kita lihat dulu bagaimana menggunakan modul pustaka standar.

Contoh (simpan dengan nama pakai_sys.py):

import sys

print('Argumen baris perintahnya adalah:')
for i in sys.argv:
    print(i)

print('\n\n PYTHONPATH yang ditentukan adalah ', sys.path, '\n')

Keluaran:

$ python3 pakai_sys.py ini argumen kami
Argumen baris perintahnya adalah:
pakai_sys.py
ini
argumen
kami

PYTHONPATH yang ditentukan adalah [<nowiki>''</nowiki>, 'C:\\Windows\\system32\\python30.zip',
'C:\\Python30\\DLLs', 'C:\\Python30\\lib',
'C:\\Python30\\lib\\plat-win', 'C:\\Python30', 
'C:\\Python30\\lib\\site-packages']

Bagaimana Cara Kerjanya

Pertama, kita melakukan import modul sys lewat statemen import. Pada dasarnya, ini bisa diterjemahkan sebagai keinginan kita kepada Python bahwa kita ingin menggunakan modul ini. Modul sys berisi fungsi yang berkaitan dengan interpreter Python dan lingkungannya, antara lain system.

Saat Python mengeksekusi statemen import sys, dia akan mencari modul sys. Dalam hal ini, modul tersebut merupakan modul built-in, sehingga Python langsung tahu di mana mencarinya.

Jika modul yang diinginkan bukan modul terkompilasi, atau modul yang ditulis di Python, maka interpreter Python akan mencari direktori yang terdaftar dalam variabel sys.path. Jika modul ditemukan, maka isi modul tersebut dijalankan dan modul akan tersedia untuk Anda gunakan. Catat bahwa inisialisasi dilakukan saat pertama kali kita mengimpor modul.

Variabel argv di dalam modul sys akan diakses dengan notasi titik, misal sys.argv. Ini secara jelas mengindikasikan bahwa nama tersebut merupakan bagian dari modul sys. Keuntungan lain dari pendekatan ini adalah bahwa nama fungsi tersebut tidak akan bentrok dengan variabel argv yang digunakan di dalam program Anda.

Variabel sys.argv berisi list string (lists dijelaskan lebih detail di bab berikutnya). Secara lebih khusus sys.argv berisi list dari seluruh argumen baris perinta yakni seluruh argumen yang dituliskan pada program Anda saat menjalankannya di baris perintah.

Jika Anda menggunakan IDE untuk menulis dan menjalankan program ini, cari cara untuk menambahkan argumen program dari menu.

Di sini, ketika kita mengeksekusi python pakai_sys ini argumen kami, kita menjalankan modul pakai_sys.py lewat perintah python dan kata-kata yang ditulis setelahnya adalah argumen yang dilemparkan ke dalam program. Python menyimpan baris argumen di variabel sys.argv untuk dapat kita manfaaatkan.

Ingat, nama dari skrip yang dijalankan akan selalu menjadi argumen pertama dalam list sys.argv. Sehingga dalam kasus ini 'pakai_sys.py' sebagai sys.argv[0]'ini' sebagai sys.argv[1]'argumen' sebagai sys.argv[2] dan 'kami' sebagai sys.argv[3]. Perhatikan bahwa Python menghitung dari 0, dan bukan 1.

sys.path berisi daftar nama direktori tempat di mana modul-modul diimpor. Coba perhatikan bahwa string pertama dari sys.path tidak ada isinya – string kosong ini mengindikasikan bahwa direktori program tersebut dijalankan juga merupakan bagian dari sys.path, yang sama dengan environment variable PYTHONPATH. Ini berarti Anda dapat mengimpor modul secara langsung dari direktori tempat file berada saat ini. Jika tidak maka Anda harus meletakkan modul di dalam salah satu direktori yang terdaftar dalam sys.path.

Catat bahwa direktori saat ini adalah direktori tempat program ini dijalankan. Jalankan import os; print(os.getcwd()) untuk mencari direktori program Anda saat ini.

Berkas Byte-compiled .pyc

Mengimpor modul relatif sangat mahal sumber daya, sehingga Python punya trik untuk membuatnya lebih cepat. Salah satu cara adalah membuat berkas byte-compiled (terkompilasi dalam bahasa mesin) dengan ekstensi .pyc. Berkas .pyc ini merupakan bentuk lanjut yang diubah oleh Python ke dalam bahasa yang lebih dekat dengan mesin (ingat bagian pengenalan bagaimana Python bekerja?). Berkas .pyc ini berguna saat Anda lain kali mengimpor modul dari program yang berbeda – modul tersebut akan dijalankan lebih cepat mengingat bagian dari proses yang dibutuhkan untuk mengimpor modul sudah pernah dilaksanakan. Juga, berkas byte-compiled ini tidak tergantung terhadap platform (platform-independent).Catatan

Berkas .pyc biasanya dibuat di dalam direktori yang sama dari berkas .py. Jika Python tidak punya izin untuk menulis berkas ke dalam direktori tersebut, maka berkas .pyc tidak akan dibuat.

Statemen from … import

Jika Anda secara langsung mengimport argv ke dalam program Anda (untuk menghindari sys. setiap kali akan menggunakannya), maka Anda dapat menggunakan statemen from sys import argv.

Secara umum, Anda sebisa mungkin menghindari penggunaan statemen ini dan gunakan statemen import agar program Anda dapat menghindari bentrokan nama modul dan program lebih mudah dibaca.

Contoh:

from math import sqrt
print("Akar dari 16 adalah ", sqrt(16))

name di Dalam Modul

Setiap modul memiliki nama dan statemen yang dapat memberikan informasi nama modul. Hal ini bermanfaat untuk kepentingan khusus apakah modul tersebut jalan sendiri atau berjalan lewat import. Sebagaimana telah disebutkan sebelumnya, saat sebuah modul diimpor pertama kali, kode di dalamnya akan dieksekusi terlebih dahulu. Kita dapat menggunakan hal ini untuk membuat modul memberikan keluaran yang berbeda tergantung apakah modul tersebut digunakan secara sendiri, atau diimpor lewat modul lain. Ini dapat dicapai dengan atribut __name__ di dalam modul.

Contoh (simpan dengan nama pakai_nama.py):

if __name__ == '__main__':
    print('Program ini dijalankan sendiri')
else:
    print('Saya diimpor dari modul lain')

Keluaran:

$ python3 pakai_nama.py
Program ini dijalankan sendiri

$ python3
>>> import pakai_nama
Saya diimpor dari modul lain
>>>

Bagaimana Cara Kerjanya

Setiap modul python memiliki definisi __name__ di dalamnya. Jika saat ini program berjalan sama dengan nilai definisi '__main', maka hal tersebut menunjukkan bahwa modul dijalankan secara sendirian (standalone) oleh pengguna, dan kita dapat menuliskan tindak lanjut yang sesuai dari kondisi tersebut.

Membuat Modul Python Anda Sendiri

Membuat modul Anda sendiri relatif mudah, Anda sudah melakukannya selama ini! Hal ini terjadi karena setiap program Python adalah sebuah modul. Anda hanya perlu memastikan program tersebut memiliki ekstensi .py. Gambaran lebih jelas dapat dilihat dalam contoh berikut.

Contoh (simpan dengan nama modulku.py):

def katakanhai():
    print('Hai, ini modulku berbicara.')

__version__ = '0.1'

Baris kode di atas adalah contoh modul. Sebagaimana Anda lihat, tidak ada yang khusus tentangnya dibandingkan dengan program Python yang biasa kita buat. Kita akan lihat berikutnya, bagaimana menggunakan modul tersebut di dalam program Python yang lain.

Ingat bahwa modul harus diletakkan pada direktori yang sama dengan program yang mengimpornya, atau salah satu dari direktori yang terdaftar di sys.path.

Modul lain (simpan dengan nama demo_modulku.py):

import modulku

modulku.katakanhai()
print ('Versi', modulku.__version__)

Keluaran:

$ python3 demo_modulku.py
Hai, ini modulku berbicara.
Versi 0.1

Bagaimana Cara Kerjanya

Perhatikan bahwa kita menggunakan notasi bertitik yang sama untuk mengakses anggota modul. Python membuat penggunaan kembali secara baik dengan notasi yang sama untuk memberikan rasa ‘Pythonic’ sehingga kita tidak harus belajar cara baru untuk mengerjakan hal-hal lainnya.

Berikut versi yang menggunakan sintaks from..import (simpan dengan nama demo2_modulku.py):

from modulku import katakanhai, __version__

katakanhai()
print('Versi', __version__)

Keluaran demo2_modulku.py sama dengan keluaran demo_modulku.py.

Perhatikan bahwa jika ada __version__ yang dideklarasikan sebelumnya oleh demo_modulku.py atau demo2_modulku.py maka akan terjadi bentrok. Ini juga karena praktik yang umum pada setiap modul untuk mendeklarasikan versi dengan menggunakan namanya. Sehingga, selalu direkomendasikan untuk statemen import meskipun hal itu membuat program Anda sedikit lebih lama.

Anda dapat juga menggunakan:

from modulku import *

Ini akan mengimpor seluruh nama publik seperti katakanhai tapi tidak akan mengimpor __version__ karena nama tersebut diawali dengan dua garis bawah.Zen of Python

Salah satu prinsip panduan Python adalah bahwa “Eksplisit lebih baik daripada Implicit”. Jalankan import this untuk mempelajari prinsip-prinsip lainnya dan lihat diskusi di StackOverflow tentang hal ini yang membuat daftar contoh dari masing-masing prinsip.

Fungsi dir

Anda dapat menggunakan fungsi built-in (sudah ada secara otomatis) dir untuk melihat daftar seluruh nama yang didefinisikan oleh objek (dalam hal ini didefinisikan oleh sebuah modul). Dalam hal modul, fungsi dir() akan memuat daftar seluruh fungsi, kelas dan variabel yang didefinisikan oleh modul tersebut.

Jika Anda memberikan nama modul untuk fungsi dir(), akan memberikan daftar nama yang didefinisikan dalam modul yang dimasukkan tersebut. Jika tidak memasukkan argumen, maka akan mengembalikan nama yang didefinisikan oleh modul yang dipakai saat ini.

Contoh:

$ python3

>>> import sys # mengambil seluruh atribut, dalam kasus ini, dari modul sys

>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__package__', '__s
tderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_compact_freelists',
'_current_frames', '_getframe', 'api_version', 'argv', 'builtin_module_names', '
byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle'
, 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable',
'exit', 'flags', 'float_info', 'getcheckinterval', 'getdefaultencoding', 'getfil
esystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof',
'gettrace', 'getwindowsversion', 'hexversion', 'intern', 'maxsize', 'maxunicode
', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platfor
m', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setprofile', 'setrecursionlimit
', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_in
fo', 'warnoptions', 'winver']

>>> dir() # menampilkan daftar seluruh atribut dari modul yang sedang dijalankan
['__builtins__', '__doc__', '__name__', '__package__', 'sys']

>>> a = 5 # membuat variabel baru 'a'

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'a', 'sys']

>>> del a # menghapus nama a

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'sys']

>>>

Bagaimana Cara Kerjanya:

Pertama, kita lihat penggunaan dir dari modul sys yang telah diimpor sebelumnya. Kita lihat banyak sekali daftar atribut yang ada di dalamnya.

Selanjutnya, kita menggunakan fungsi dir tanpa memasukkan parameter. Secara baku, fungsi tersebut mengembalikan daftar seluruh atribut dari modul yang sedang dijalankan. Perhatikan bahwa daftar modul yang diimpor juga merupakan bagian dari daftar ini.

Dalam rangka observasi dir, kita mendefinisikan variabel baru dengan nama a lalu memberinya nilai. Saat kita cek dengan dir kita akan melihat baris tambahan dari daftar yang sama. Kita menghapus variabel/atribut dari modul saat ini dengan statemen del dan perubahan tersebut akan langsung terlihat dalam keluaran fungsi dir.

A note on del – this statement is used to delete a variable/name and after the statement has run, in this case del a, you can no longer access the variable a – it is as if it never existed before at all.

Catat bahwa fungsi dir() dapat dijalankan dalam setiap objek. Sebagai contoh, jalankan dir('print') untuk mempelajari fungsi print, atau dir(str) untuk atribut-atribut yang ada dalam kelas str.

Paket

Hingga saat ini, Anda seharusnya sudah mulai belajar mengobservasi hierarki dari struktur program Anda. Variabel biasanya ada di dalam fungsi. Fungsi dan variabel global biasanya ada di dalam modul. Bagaimana jika Anda ingin mengatur modul supaya lebih terorganisir? Saatnya kita berkenalan dengan struktur baru bernama paket.

Paket hanyalah berupa folder yang didalamnya berisi modul, dengan satu tambahan berkas khusus bernama __init__.py, yang mengindikasikan kepada Python bahwa folder tersebut khusus berisi modul Python.

Sebagai contoh Anda ingin membuat paket bernama ‘world’ dengan sub paket bernama ‘asia’, ‘afrika’, dan seterusnya, dan sub paket ini berisi modul dengan nama ‘india’, ‘madagaskar’ dan seterusnya.

Begini seharusnya struktur di dalam folder:

- <salah satu folder yang ada dalam sys.path>/
    - world/
        - __init__.py
        - asia/
            - __init__.py
            - india/
                - __init__.py
                - foo.py
        - afrika/
            - __init__.py
            - madagaskar/
                - __init__.py
                - bar.py

Paket hanyalah berupa cara yang nyaman untuk menata modul secara lebih teroganisir. Anda dapat lihat contoh-contohnya dalam pustaka standar.

Ringkasan

Sebagaimana fungsi yang merupakan bagian dari program yang dapat digunakan kembali, modul adalah program yang dapat digunakan kembali. Paket adalah hierarki di atasnya untuk membuat modul dapat lebih tertata. Pustaka standar yang ada di dalam Python adalah contoh yang dapat dilihat bagaimana hierarki dari paket dan modul.

Kita telah melihat bagaimana menggunakan modul ini dan membuat modul kita sendiri.

Berikutnya, kita akan belajar konsep menarik lainnya yang bernama struktur data.

Kategori
Python

Fungsi

Fungsi merupakan bagian di dalam program yang dapat digunakan kembali. Fungsi tersebut memungkinkan Anda memberi nama terhadap blok statemen, yang memungkinkan Anda menjalankan blok tersebut di program Anda kapan saja berkali-kali dengan memanggil namanya. Ini dinamakan pemanggilanterhadap fungsi. Kita sudah pernah menggunakan beberapa fungsi yang sudah tertanam secara baku seperti len dan range.

Konsep tentang fungsi ini mungkin merupakan struktur pembangun perangkat lunak yang paling penting (dalam bahasa pemrograman apapun), dan dalam bab ini kita akan mengeksplorasi bermacam aspek dari fungsi.

Fungsi ditentukan dengan menggunakan kata kunci def. Setelah kata kunci, dilanjutkan dengan nama penanda dari fungsi tersebut, diikuti pasangan dalam kurung yang di dalamnya ada nama variabel. Setelah tanda kurung, akan ditutup dengan titik dua di akhir baris. Kemudian di baris baru akan diikuti blok statemen yang merupakan bagian dari fungsi tersebut. Contoh yang menunjukkan betapa sederhananya sebuah fungsi:

Contoh (simpan dengan nama fungsi1.py):

def apaKabar():
    print('Apa kabar dunia!') # blok ini milik fungsi apaKabar()
# Akhir fungsi

apaKabar() # memanggil fungsi
apaKabar() # memanggil fungsi sekali lagi

Keluaran:

$ python3 fungsi1.py
Apa kabar dunia!
Apa kabar dunia!

Bagaimana Cara Kerjanya

Kita mendefinisikan fungsi bernama apaKabar dengan menggunakan sintaks sebagaimana yang telah dijelaskan di atas. Fungsi ini tidak mengambil satu parameterpun, sehingga tidak perlu ada variabel yang dideklarasikan di dalam kurung. Parameter merupakan masukan yang hanya digunakan di dalam fungsi, sehingga kita dapat memasukkan nilai yang berbeda untuk memperoleh hasil yang diinginkan.

Perhatikan bahwa kita dapat memanggil fungsi dua kali, yang artinya kita tidak perlu menuliskan kode yang sama lagi untuk menginginkan keluaran sama.

Parameter Fungsi

Fungsi dapat menerima parameter. Parameter adalah nilai yang Anda masukkan ke dalam fungsi, sehingga fungsi dapat melakukan sesuatu terhadap nilai tersebut. Parameter ini seperti variabel, namun Anda harus mendefinisikan nilainya dulu sebelum dimasukkan ke dalam fungsi, dan sudah memiliki nilai ketika fungsi tersebut dijalankan.

Parameter ditentukan di dalam tanda kurung saat fungsi didefinisikan, dipisahkan dengan koma. Saat kita memanggil fungsinya, kita memasukkan nilai terhadap parameter tersebut dengan jumlah dan cara yang sama. Sebagai catatan terhadap terminologi yang digunakan – nama yang diberikan ke dalam definisi fungsi dinamakan parameter sedangkan nilai yang diberikan dalam pemanggilan fungsi disebut argumen.

Contoh (simpan dengan nama func_param.py):

def printMaks(a, b):
    if a > b:
        print(a, 'adalah angka tertinggi')
    elif a == b:
        print(a, 'adalah sama dengan', b)
    else:
        print(b, 'adalah angka tertinggi')

printMaks(3, 4) # langsung diberikan nilai terhadap parameter a dan b saat fungsi dipanggil

x = 5
y = 7

printMax(x, y) # memberi variabel sebagai argumen. Variabel ini harus didefinisikan dulu sebelumnya.

Keluaran:

$ python3 func_param.py
4 adalah angka tertinggi 
7 adalah angka tertinggi

Bagaimana Cara Kerjanya

Di sini, kita mendefinisikan fungsi dengan nama printMaks yang menggunakan dua parameter yang disebut a dan b. Kita mencari angka yang lebih besar dengan menggunakan statemen if..else sederhana, lalu mencetak angka yang lebih besar.

Saat pertama kali kita panggil fungsi printMaks, kita secara langsung memasukkan angka sebagai argumen. Dalam kasus kedua, kita memanggil fungsi dengan argumen berupa variabel. printMaks(x,y) membuat nilai argumen x dimasukkan dalam parameter a dan nilai argumen y dimasukkan dalam parameter b. Fungsi printMaks berfungsi sama saja di kedua kasus tersebut.

Variabel Lokal

Saat Anda mendeklarasikan variabel di dalam definisi fungsi, mereka tidak berhubungan dengan variabel lain dengan nama yang sama di luar fungsi – dengan kata lain nama variabel ini hanya berlaku secara lokal di dalam fungsi. Ini dinamakan skup (scope) dari variabel. Semua variabel memiliki blok skup saat dideklarasikan pertama kali.

Contoh (simpan dengan nama func_local.py):

x = 50

def func(x):
    print('x adalah', x)
    x = 2
    print('Mengganti nilai lokal x ke ', x)

func(x)
print('x masih tetap', x)

Keluaran:

$ python3 func_local.py
x adalah 50
Mengganti nilai lokal x ke 2
x masih tetap 50

Bagaimana Cara Kerjanya

Saat pertama kita mencetak nilai dari x di baris pertama badan fungsi, Python menggunakan nilai dari parameter yang dideklarasikan di blok utama, di atas definisi fungsi.

Lalu, kita memberikan nilai 2 kepada x. Jadi nama x hanya bernilai di lokal, di dalam fungsi. Saat kita mengganti nilai x yang berada di dalam fungsi, nilai x yang berada di blok utama tetap tidak terpengaruh.

Dengan pemanggilan fungsi print di baris terakhir, kita menampilkan nilai x yang berasal dari blok utama, sehingga hal ini dapat mengonfirmasi bahwa nilai tersebut benar-benar tidak terpengaruh oleh nilai lokal yang diganti dalam fungsi sebelumnya.

Menggunakan Statemen Global

Jika Anda ingin memberi nilai terhadap satu variabel yang didefinisikan di level tertinggi dalam satu program (atau dengan kata lain tidak berada di dalam skup apapun, baik fungsi maupun class), Anda harus memberitahu Python bahwa nama tersebut bukan local, tapi global. Kita melakukannya dengan statemen global. Tidak mungkin memberikan nilai di dalam variabel di luar fungsi tanpa statemen global.

Anda dapat menggunakan nilai dari variabel yang didefinisikan di luar fungsi (asumsikan bahwa tidak ada nama variabel yang sama di dalam fungsi). Bagaimanapun juga, ini sangat tidak disarankan dan Anda harus menghindarinya mengingat hal tersebut akan membingungkan pembaca program tentang di mana definisi variabelnya. Menggunakan statemen global membuatnya jelas bahwa variabel yang bersangkutan didefinisikan di luar blok.

Contoh (simpan dengan nama func_global.py):

x = 50

def func():
    global x

    print('x adalah ', x)
    x = 2
    print('Mengganti nilai global x ke', x)

func()
print('Nilai dari x adalah ', x)

Keluaran:

$ python3 func_global.py
x adalah 50
Mengganti nilai global x ke 2
Nilai dari x adalah 2

Bagaimana Cara Kerjanya

Statemen global digunakan untuk mendeklarasikan x – membuatnya menjadi variabel global – sehingga, saat kita mengganti nilai x di dalam fungsi, perubahan tersebut akan berlaku juga pada saat kita menggunakan nilai x di blok utama.

Anda dapat menentukan lebih dari satu variabel global, dengan menggunakan statemen global yang sama, misalnya global x, y, z.

Nilai Argumen Baku

Untuk beberapa fungsi, Anda mungkin ingin membuat beberapa parameter tidak wajib diisi, dan menggunakan nilai baku pada saat pengguna tidak ingin memberikan nilai terhadapnya. Ini dapat dilakukan dengan bantuan nilai argumen baku. Anda dapat menentukan nilai arguman baku untuk parameter yang diberikan, dengan menambahkan nilai baku lewat operator sama dengan (=).

Catat bahwa nilai argumen baku haruslah berupa konstanta. Lebih tepatnya, nilai argumen baku harus bersifat immutable – ini akan dijelaskan di bab berikutnya. Untuk sekarang Anda hanya perlu mengingatnya.

Contoh (simpan dengan nama func_default.py):

def katakan(pesan, kali = 1):
    print(pesan * kali)

katakan('Apakabar')
katakan('Dunia', 5)

Keluaran:

$ python3 func_default.py
Apakabar
DuniaDuniaDuniaDuniaDunia

Bagaimana Cara Kerjanya

Fungsi yang bernama katakan digunakan untuk menampilkan string sebanyak yang ditentukan. Jika pengalinya tidak ditentukan, maka secara baku, string akan ditampilkan sebanyak sekali. Kita dapat melakukan ini dengan menentukan nilai argumen baku ke 1 untuk parameter kali.

Jika dalam penggunaan katakan pertama, kita hanya mengisi string dan menampilkannya sekali, maka dalam penggunaan katakan kedua, kita mengisikan string dan sebuah arguman 5 yang menyatakan bahwa kita ingin mengatakan string tersebut sebanyak 5 kali.Penting

Hanya parameter yang berada di akhir daftar parameter yang dapat diberikan nilai argumen baku, dengan kata lain Anda tidak boleh menentukan nilai argumen baku di depan parameter yang tidak memiliki nilai argumen baku.

Ini karena nilai disematkan ke dalam parameter berdasarkan posisi. Sebagai contoh, def fun(a, b=5) dianggap valid, sedangkan def func(a=5, b) tidak valid.

Argumen Kata Kunci

Jika Anda memiliki fungsi dengan banyak parameter dan Anda hanya ingin menentukan beberapa saja, Anda dapat memberikan nilai terhadap parameter, dengan memberikan nama terhadapnya – ini disebut sebagai argumen kata kunci – kita gunakan kata kunci daripada posisi (yang selalu kita gunakan selama ini) untuk menentukan argumen terhadap fungsi.

Ada dua keuntungan – satu, menggunakan fungsi akan lebih mudah sebab kita tidak perlu khawatir terhadap urutan argumen. Kedua, kita dapat memberikan nilai hanya terhadap parameter yang kita inginkan, sebab parameter lain telah memiliki nilai baku.

Contoh (simpan dengan nama func_key.py):

def func(a, b=5, c=10):
    print('a adalah ', a, ' dan b adalah ', b, ' dan c adalah ', c)

func(3, 7)
func(25, c=24)
func(c=50, a=100)

Keluaran:

$ python3 func_key.py
a adalah 3 dan b adalah 7 dan c adalah 10
a adalah 25 dan b adalah 5 dan c adalah 24
a adalah 100 dan b adalah 5 dan c adalah 50

Bagaimana Cara Kerjanya

Fungsi tersebut bernama func dan hanya punya satu parameter tanpa nilai argumen baku, diikuti oleh dua parameter dengan nilai argumen baku.

Pada penggunaan pertama, func(3, 7), parameter a memperoleh nilai 3, parameter b memeperoleh nilai 7 dan c memperoleh nilai baku 10.

Pada penggunaan kedua, func(25, c=24), parameter a memperoleh nilai 25 mengingat posisinya di dalam argumen. Kemudian parameter c memperoleh nilai 24 berkaitan dengan penamaan argumen kata kunci. Variabel b akan memperoleh nilai baku 5.

Dalam penggunaan ketiga func(c=50, a=100), kita menggunakan argumen untuk seluruh nilai yang ditentukan. Perhatikan bahwa kita menentukan nilai untuk parameter c sebelum a didefinisikan.

Parameter VarArgs

Kadang Anda ingin mendefinisikan fungsi yang dapat mengambil parameter dalam jumlah berapapun, ini dapat dilakukan dengan menggunakan tanda bintang (simpan dengan nama total.py):

def total(awal=5, *angkas, **kuncis):
    hitung = awal
    for angka in angkas:
        hitung += angka
    for kunci in kuncis:
        hitung += kuncis[kunci]
    return hitung

print(total(10, 1, 2, 3, sayur=50, buah=100))

Keluaran:

$ python3 total.py
166

Bagaimana Cara Kerjanya

Ketika kita mendefinisikan parameter bintang seperti *param, maka seluruh argumen setelahnya akan dikumpulkan ke dalam tuple yang disebut param.

Mirip dengan itu, ketika kita mendeklarasikan parameter dua-bintang seperti **param, maka semua argumen dengan kata kunci akan dikumpulkan ke dalam dictionary yang disebut param.

Kita akan eksplorasi tentang tuples dan dictionaries di bab berikutnya.

Parameter Hanya-Kata-kunci

Jika kita ingin menentukan parameter kata kunci tertentu, tersedia dalam bentuk hanya kata kunci (keyword-only) dan bukan argumen yang bersifat posisional, hal tersebut dapat dideklarasikan setelah parameter berbintang (simpan dengan nama keyword_only.py):

def total(awal=5, *angkas, angka_tambahan):
    hitung = awal
    for angka in angkas:
        hitung += angka
    hitung += angka_tambahan
    print(hitung)

total(10, 1, 2, 3, angka_tambahan=50)
total(10, 1, 2, 3)
# Akan menampilkan pesan kesalahan, karena kita tidak memberikan argumen baku untuk nilai `angka_tambahan`

Keluaran:

$ python3 keyword_only.py
66
Traceback (most recent call last):
  File "keyword_only.py", line 12, in <module>
total(10, 1, 2, 3)
TypeError: total() needs keyword-only argument extra_number

Bagaimana Cara Kerjanya

Mendeklarasikan parameter setelah parameter bintang akan menghasilkan argumen hanya-kata-kunci (hanya berupa kata kunci). Jika argumen ini tidak diberi nilai, maka pemanggilan fungsi akan menghasilkan pesan error sebagaimana terlihat di atas.

Catat bahwa penggunaan += merupakan jalan pintas. Jadi untuk mengatakan x = x + y, Anda dapat menuliskan x += y.

Jika Anda ingin memiliki argumen hanya-kata-kunci, tapi tidak ingin menentukan nilai baku, cukup menggunakan bintang tanpa nama. contoh def total(nilai_awal=5, *, nomor_tambahan).

Statemen return

Statemen return digunakan untuk mengembalikan nilai dari sebuah fungsi, juga merupakan pemotong/akhir dari sebuah fungsi. Nilai return juga dapat digunakan untuk mengembalikan nilai dari sebuah fungsi.

Contoh (simpan dengan nama func_return.py):

def maximum(x, y):
    if x > y:
        return x
    elif x == y:
        return 'Nilai angkanya sama'
    else:
        return y

print(maximum(2, 3))

Keluaran:

$ python3 func_return.py
3

Bagaimana Cara Kerjanya

Fungsi maximum mengembalikan angka tertinggi dari seluruh parameter yang diberikan, dalam hal ini seluruh angka yang dimasukkan ke dalam fungsi tersebut. Fungsi ini menggunakan statemen if..else yang sederhana untuk mencari nilai lebih besar dari seluruh nilai, lalu mengembalikan hasilnya.

Catat bahwa statemen return tanpa nilai sama dengan return NoneNone adalah jenis yang sangat khusus di Python yang mewakili kosong. Sebagai contoh, None digunakan untuk mengindikasikan bahwa sebuah variabel tidak memiliki nilai, jika nilai yang dimilikinya None.

Setiap fungsi secara implisit memiliki return None meskipun Anda tidak menuliskannya. Kecuali Anda mendefinisikan sendiri nilai dari statemen return. Anda dapat melihat ini dengan menjalankan print(sebuahFungsi()) dimana sebuahFungsi tersebut tidak memiliki statemen return, seperti:

def sebuahFungsi():
    pass

Statemen pass digunakan di Python untuk mengindikasikan blok statemen yang kosong.Catatan

Ada fungsi tertanam yang bernama max yang sudah mengimplementasikan fungsi ‘find maximum’, jadi gunakan fungsi tertanam sebisa mungkin.

DocStrings

Python memiliki fungsi yang keren bernama documentation strings, biasanya dirujuk dengan nama yang lebih pendek, yakni docstrings. DocStrings sangat penting dan Anda harus menggunakannya karena fungsi tersebut dapat mendokumentasikan program secara lebih baik dan lebih mudah untuk dipahami. Kerennya, kita bisa mengambil docstring dari sebuah fungsi, meskipun program tersebut masih berjalan!

Contoh (simpan dengan nama func_doc.py):

def printMax(x, y):
    '''Mencetak nilai tertinggi dari dua angka.

    Kedua angka yang diberikan harus berupa integer.'''
    x = int(x) # konversi ke integer, jika memungkinkan
    y = int(y)

    if x > y:
        print(x, ' adalah nilai paling tinggi')
    else:
        print(y, ' adalah nilai paling tinggi')

printMax(3, 5)
print(printMax.__doc__)

Output:

$ python3 func_doc.py
5 adalah nilai paling tinggi
Mencetak nilai maksimal dari dua angka.

        Kedua angka yang diberikan harus berupa integer.

Bagaimana cara kerjanya

String dari baris logis pertama dari sebuah fungsi adalah docstring dari fungsi tersebut. Catat bahwa DocStrings juga berlaku untuk Modules dan classes yang akan kita pelajari di bab berikutnya.

Konvensi yang harus diikuti untuk sebuah docstring, adalah bahwa dia string dengan baris lebih dari satu di mana kata pertama dimulai dengan huruf besar dan diakhiri dengan tanda titik. Kemudian baris kedua dikosongkan, diikuti dengan penjelasan detail di baris ketiga. Anda sangat disarankan untuk mengikuti aturan ini untuk semua docstring bagi semua fungsi rumit Anda.

Kita dapat mengakses docstring dari fungsi printMax dengan menggunakan atribut __doc__ (perhatikan dua garis bawah) yang merupakan milik dari fungsi tersebut. Ingat bahwa Python memperlakukan semuanya sebagai object, termasuk fungsi ini. Kita akan belajar tentang object di bab berikutnya di classes.

Jika Anda telah menggunakan help() di python, Anda sudah pernah melihat penggunaan docstring! Apa yang dilakukan oleh help() hanyalah mengambil atribut __doc__ dan menampilkannya dalam format yang bagus untuk Anda. Silakan Anda coba fungsi di atas – cukup masukkan help(printMax) di program Anda. Selalu ingat untuk menekan tombol d untuk keluar dari help.

Beberapa program bantu otomatis dapat mengambil dokumentasi dari program dengan cara ini. Sehingga, saya sangat menyarankan Anda untuk menggunakan docstrings untuk fungsi-fungsi rumit yang Anda tulis. Perintah pydoc yang tersedia di distribusi Python Anda, cara kerjanya mirip help()menggunakan docstrings.

Selanjutnya kita belajar tentang Modul Python.

Kategori
Python

Alur Kontrol

Di dalam program yang kita lihat hingga saat ini, selalu saja ada beberapa urutan statemen yang dijalankan secara saklak oleh Python, berurutan dari atas ke bawah. Bagaimana jika Anda ingin mengubah alur kerjanya? Di sinilah kita belajar alur kontrol.

Sebagai contoh Anda ingin program untuk mengambil keputusan dan bertindak secara berbeda tergantung keputusan yang diambil. Sebagai contoh, misalnya mencetak ‘Selamat Pagi’ atau ‘Selamat Sore’ tergantung waktu yang ada saat itu?

Sebagaimana yang Anda bisa tebak, ini dapat dilakukan lewat statemen alur kontrol. Ini yang perlu Anda kuasai setelah belajar operator dan ekspresi. Ada tiga macam statemen alur kontrol di Python – iffor dan while.

Statemen if

Alur kontrol statemen if digunakan untuk mengecek kondisi: jika kondisi if bernilai benar, maka kita akan menjalankan satu blok statemen (disebut if-block), selain itu diteruskan dengan statemen else kita gunakan untuk memproses blok statemen yang lain (dinamakan else-block). Klausul else tersebut sifatnya tidak wajib.

Contoh (simpan dengan nama if.py):

angka = 23
tebakan = int(input('Masukkan sebuah angka : '))

if tebakan == angka:
    print('Selamat Anda telah menebaknya') # Blok baru mulai di sini
    print('(Tapi tidak ada satu hadiahpun untuk Anda!)') # Blok baru berakhir di sini
elif tebakan < angka:
    print('Tidak, angkanya sedikit lebih besar lagi') # Blok lainnya 
    # Anda dapat melakukan apapun di blok ini ...
else:
    print('Tidak, angkanya lebih kecil lagi')
    # Pesan ini keluar jika Anda menebak angka yang lebih besar

print('Selesai')
# Statemen terakhir ini selalu dieksekusi, setelah statemen if tersebut dijalankan.

Keluaran:

$ python3 if.py
Masukkan sebuah angka : 50
Tidak, angkanya lebih kecil lagi 
Selesai

$ python3 if.py
Masukkan sebuah angka : 22 
Tidak, angkanya sedikit lebih besar lagi 
Selesai

$ python3 if.py
Masukkan sebuah angka : 23
Selamat, Anda telah menbaknya
(Tapi tidak ada satu hadiahpun untuk Anda!)
Selesai

Bagaimana Cara Kerjanya

Dalam program ini, kita menebak dari pengguna dan mengeceknya dengan nomor yang kita punya. Di awal, kita sudah mengeset variabel angka ke dalam nilai integer yang kita inginkan, misalnya 23. Lalu, kita gunakan tebakan dari pengguna lewat fungsi input(). Fungsi adalah bagian dari program yang dapat digunakan kembali. Kita akan membaca tentang hal ini di bagian berikutnya.

Kita memasukkan sebuah string ke dalam fungsi built-in bernama input yang akan mencetak di layar sesuai dengan masukan yang diketikkan oleh pengguna di layar. Sekali dimasukkan, dan pengguna menekan tombol enter, maka fungsi input() akan mengembalikan apapun yang dimasukkan oleh pengguna, sebagai sebuah string. Lalu kita mengkonversi string ini ke dalam integer dengan menggunakan int lalu menyimpannya ke dalam variabel bernama tebakan. Sebetulnya, int merupakan class, tapi yang Anda perlu tahu saat ini adalah Anda dapat menggunakannya untuk mengonversi sebuah string ke dalam integer (asumsikan string tersebut berisi integer yang valid di dalamnya).

Berikutnya, kita bandingkan tebakan dari pengguna dengan nomor yang telah kita tentukan sebelumnya. Jika mereka bernilai sama, kita tampilkan pesan berhasil. Perhatikan bahwa kita menggunakan level indentasi untuk memberitahu Python, statemen mana ikut ke dalam blok mana. Inilah mengapa indentasi sangat penting di Python. Saya harap Anda menggunakan aturan “indentasi yang konsisten”. Betul kan?

Pengingat

Perhatikan bahwa dalam alur kontrol ini, jika statemen if berisi titik koma di akhir kalimat 0 kita mengindikasikan kepada Python bahwa blok statemen tersebut akan mengikuti.

Lalu kita cek lagi, apakah tebakan tersebut lebih kecil atau lebih besar dari angka yang kita tentukan, dan jika memang demikian kasusnya, kita informasikan kepada pengguna bahwa mereka harus menebak angka yang lebih tinggi daripada itu. Apa yang kita gunakan di sini adalah klausul elif yang sebenarnya bertugas untuk membandingkan dua statemen if else-if else yang berhubungan satu sama lain. Ini akan membuat program lebih mudah, dan mengurangi jumlah indentasi yang dibutuhkan.

Statemen elif dan else juga harus punya titik koma di akhir baris logis diikuti oleh blok statemen terkait (dengan indentasi yang benar tentu saja)

Anda dapat menambahkan statemen if yang lain di dalam blok statemen if dan seterusnya – ini dinamakan statemen if tergabung (nested).

Ingat bahwa bagian elif dan else sifatnya tidak wajib. Statemen if yang valid, minimal:

if True:
    print('Yak, itu benar')

Setelah Python menyelesaikan eksekusi dan melengkapi statemen if termasuk klausul elif dan else terkait, maka statemen berikutnya adalah print('Selesai'). Setelah ini, Python akan melihat bahwa program sudah selesai dan berhenti.

Meskipun program ini sangat sederhana, Saya telah menunjukkan banyak hal yang harus Anda perhatikan. Semua ini sangat langsung (dan sangat mudah jika Anda memiliki latar belakang C/C++). Anda hanya perlu menyadari ini di depan, dan setelah praktik beberapa kali Anda akan merasa nyaman dengan itu, sehingga terasa ‘natural’ untuk Anda.Catatan untuk programer C/C++

Tidak ada statemen switch di Python. Anda dapat menggunakan if..elif..else untuk melakukan hal yang sama (dalam beberapa kasus dapat menggunakan dictionary untuk mengerjakannya dengan cepat)

Statemen While

Alur kontrol statemen while memungkinkan Anda untuk mengeksekusi blok statemen berkali kali sepanjang kondisinya true. Statemen while adalah sebuah contoh terhadap apa yang dinamakan statemen looping. Statemen while dapat memiliki klausul opsional else.

Contoh (simpan dengan namawhile.py):

angka = 23
jalankan = True

while lari:
    tebak = int(input('Masukkan sebuah angka: '))
    if tebak == angka:
        print('Selamat, Anda telah menebaknya.')
        jalankan = False # ini akan menyebabkan loop while-nya berhenti
    elif tebak < angka:
        print('Tidak, sedikit lebih besar dari itu.')
    else:
        print('Tidak, sedikit lebih kecil dari itu.')
else:
    print('Loop while-nya telah selesai.')
    # Kerjakan hal lain yang Anda inginkan di sini.

print('Selesai')

Output:

$ python3 while.py
Masukkan sebuah angka: 50
Tidak, sedikit lebih kecil dari itu.
Masukkan sebuah angka: 22
Tidak, sedikit lebih besar dari itu.
Masukkan sebuah angka: 23
Selamat, Anda telah menebaknya.
Loop while-nya telah selesai.
Selesai

Bagaimana Cara Kerjanya

Dalam program ini, kita masih bermain dengan program tebakan, tapi dibanding yang sebelumnya, dalam program ini pengguna dapat terus menebak hingga dia menebak secara benar – pengulangan program pada setiap tebakan tidak dibutuhkan, sebagaimana yang sudah kita kerjakan pada bagian sebelumnya. Ini secara jelas mendemonstrasikan bagaimana statemen while bekerja.

Kita pindahkan statemen input dan if ke dalam putaran while dan kita tentukan variabel bernama jalankan dengan nilai True sebelum putaran while di mulai. Pertama jalan, kita cek dulu apakah vaiabel jalankan bernilai True lalu lanjut mengeksekusi while-block terkait. Setelah blok ini dieksekusi, program akan mengecek kembali apakah nilai variabel jalankan. Jika nilainya masih True, maka while-block akan dieksekusi kembali, begitu seterusnya.

Blok else akan dieksekusi ketika kondisi putaran while menemukan nilai False – bahkan ini bisa juga terjadi pada putaran pertama. Jika ada klausul else dalam putaran while, klausul tersebut akan selalu dieksekusi kecuali Anda menghentikannya dengan statemen break.

Nilai True dan False dianggap sebagai tipe Boolean, dan Anda dapat menganggapnya memiliki nilai 1 untuk True dan 0 untuk False.Catatan untuk Programmer C/C++

Selalu ingat bahwa Anda dapat menyisipkan klausul else dalam putaran while

alur kontrol

Putaran For

Ada lagi statemen putaran yang mengulang urutan objek seperti menjalankan tiap item dalam urutan (sequence). Statemen ini disebut for..in. Kita akan lihat tentang urutan di bab berikutnya secara detail. Apa yang pelru Anda ketahui sekarang bahwa urutan/sequence hanyalah kumpulan item berurut.

Contoh (simpan dengan nama for.py):

for i in range(1, 5):
    print(i)
else:
    print('Putaran telah selesai')

Keluaran:

$ python3 for.py
1
2
3
4
Putaran telah selesai

Bagaimana Cara Kerjanya

Dalam program ini, kita akan menampilkan urutan angka. Kita akan menghasilkan urutan angka ini dalam fungsi built-in dengan nama range.

Apa yang akan kita lakukan di sini adalah memberikan dua angka dan range akan mengembalikan urutan mulai dari angka yang paling kecil hingga angka yang paling besar. Sebagai contoh, range(1,5) akan memberikan urutan [1, 2, 3, 4]. Secara baku, range memulai langkah dalam hitungan 1. Jika kita memberikan angka ketiga ke dalam range, maka angka tersebut akan menjadi hitungan langkah. Contohnya, range(1,5,2) akan memberikan urutan [1,3]. Ingat bahwa range hanya memperluas hingga angka kedua, dengan kata lain tidak memasukkan angka kedua.

Sebagai catatan, range() menghasilkan urutan angka, tapi hanya satu angka dalam satu waktu, ketika menjalankan permintaan for loop dalam item berikutnya. Jika Anda ingin melihat urutan angka secara penuh dengan cepat, gunakan list(range()). Lists dijelaskan di bagian tentang struktur data.

for loop akan melakukan iterasi dalam range ini – for i in range(1,5) adalah sama dengan for i in [1, 2, 3, 4] yang akan menugaskan setiap angka (atau objek) di dalam urutan ke dalam variabel i, sekali dalam satu waktu, dan mengeksekusi statemn blok dari tiap nilai i. Dalam kasus ini kita akan mencetak statemen blok.

Pengingat

Ingat bahwa bagian else sifatnya tidak wajib. Jika dimasukkan, bagian tersebut hanya akan dijalankan setelah putaran for selesai, kecuali ketemu statemen break.

Ingat bahwa putaran for..in bisa berjalan di urutan appaun. Di sini, kita memiliki daftar angka yang dihasilkan oleh fungsi range secara built-in, namun secara umum kita dapat menggunakan segala macam urutan dari berbagai jenis objek! Kita akan mengeksplorasi ide ini secara detail di bab berikutnya.Catatan untuk Programmer /C++/Java/C#

Putaran for di Python secara radikal berbeda dengan putaran for di C/C++. Programmer C# akan mencatat bahwa putaran for di dalam Python mirip dengan putaran foreach di C#. Sedangkan programmer Java bisa mencatat bahwa hal ini sama dengan for (int i : IntArray) di JAva 1.5.

Di C/C++, jika Anda ingin menulis for (int i = 0; i &lt; 5; i++), maka di Python cukup tuliskan for i in range(0,5). Sebagaimana yang Anda lihat, putaran for di Python lebih sederhana, lebih ekspresif dan lebih kecil kemungkinan salahnya.

Statemen break

Statemen break digunakan untuk menghentikan statemen dalam sebuah loop (putaran), dengan kata lain akan menghentikan eksekusi dari statemen yang berputar, meskipun kondisinya tidak bernilai False atau item urutannya belum dijalankan secara keseluruhan.

Sebagai catatan yang cukup penting, jika Anda menghentikan putaran for atau while, setiap blok else yang terkait tidak akan dieksekusi.

Contoh (simpan dengan nama break.py):

while True:
    s = input('Masukkan sesuatu: ')
    if s == 'berhenti':
        break
    print('Panjang hurufnya adalah ', len(s))
print('Selesai')

Keluaran:

$ python3 break.py
Masukkan sesuatu:  Programming sangat menyenangkan
Panjang hurufnya adalah  31
Masukkan sesuatu:  Saat pekerjaan selesai
Panjang hurufnya adalah  22
Masukkan sesuatu:  jika Anda ingin pekerjaan Anda menyenangkan:
Panjang hurufnya adalah  44
Masukkan sesuatu:  gunakan Python!
Panjang hurufnya adalah  15
Masukkan sesuatu:  berhenti
Selesai

Bagaimana Cara Kerjanya

Dalam program ini, kita berulangkali minta masukan dari pengguna, dan menampilkan jumlah panjang seluruh input yang dimasukkan. Kita memberikan kondisi khusus untuk menghentikan program dengan mengecek apakah masukan dari pengguna adalah 'berhenti'. Kita menghentikan program dengan berhenti dari putaran (loop) dan menuju akhir dari program.

Panjang dari string yang dimasukkan dapat dicari dengan menggunakan fungsi built-in bernama len

Ingat bahwa statemen break dapat digunakan dalam putaran for juga.

Puisi Python dari Swaroop

Input yang saya gunakan di sini adalah puisi mini yang saya tulis dengan nama Puisi Python Swaroop:

Programming sangat menyenangkan
Saat pekerjaan selesai
jika Anda ingin pekerjaan Anda menyenangkan:
    gunakan Python!

Statemen Continue (Lanjutkan)

Statemen continue digunakan untuk memberitahu Python agar mengabaikan statemn yang tersisa dari blok putaran yang ada saat ini, dan melanjutkan blok putaran berikutnya.

Contoh (simpan dengan nama continue.py):

while True:
    s = input('Masukkan sesuatu: ')
    if s == 'berhenti':
        break
    if len(s) < 3:
        print('Terlalu kecil')
        continue
    print('Nilai yang Anda masukkan memiliki panjang yang cukup')
    # Lakukan pemrosesan lainnya di sini...

Output:

$ python3 continue.py
Masukkan sesuatu:  a
Terlalu kecil
Masukkan sesuatu:  12
Terlalu kecil
Masukkan sesuatu:  abc
Nilai yang Anda masukkan memiliki panjang yang cukup
Masukkan sesuatu:  quit

Bagaimana Cara Kerjanya

Dalam program ini, kita menerima masukan dari pengguna, tapi kita hanya memproses masukan tersebut jika panjangnya lebih besar daripada 3. Jadi, kita menggunakan fungsi built-in len untuk memperoleh panjang masukan, dan jika panjangnya kurang dari 3, kita mengabaikan statemen berikutnya di blok yang sama dengan statemen continue. Dan selanjutnya, statemen yang tersisa dalam putaran tersebut akan dieksekusi, apapun pemrosesan yang kita inginkan di sini.

Catat bahwa statemen continue juga bisa jalan untuk putaran for.

Ringkasan Alur Kontrol

Kita telah melihat bagaimana menggunakan tiga statemen alur kontrol – ifwhile dan for lengkap dengan statemen terkait yakni break dan continue. Ini merupakan bagian yang paling sering digunakan di Python, sehingga membuat kita terbiasa dengan statemen tersebut sangatlah penting dan mendasar.

Berikutnya, kita akan melihat bagaimana membuat dan menggunakan fungsi.

Kategori
Python

Operator dan Ekspresi

Hampir semua statemen (baris logika) yang Anda tulis akan mengandung ekspresi. Contoh sederhana dari ekspresi adalah 2+3. Sebuah ekspresi dapat diturunkan menjadi operator dan operand.

Operator adalah fungsi yang menjalankan sesuatu dan direpresentasikan oleh simbol, seperti + atau simbol-simbol lain secara khusus. Operator butuh data untuk bisa dioperasikan dan data ini disebut operand. Dalam kasus ini 2 dan 3 adalah operand.

Operator

Kita akan melihat operator secara singkat dan bagaimana penggunaannya:

Catat bahwa Anda dapat mengecek dan memperbaiki ekspresi yang diberikan di contoh ini dengan menggunakan interpreter secara interaktif. Sebagai contoh, untuk menguji ekspresi 2+3, gunakan prompt interpreter interaktif Python:

>>> 2 + 3
5
>>> 3 * 5
15
>>>

+ (tambah)

Menambahkan dua objek

3 + 5 menghasilkan 8'a' + 'b' menghasilkan 'ab'.

- (minus)

Mengurangi satu angka terhadap angka lainnya. Jika operand pertama tidak ada, diasumsikan nol.

-5.2 memberikan angka negatif dan 50 - 24 memberi hasil 26.

* (perkalian)

Menghasilkan perkalian dari dua angka atau mengembalikan string yang diulang beberapa kali.

2 * 3 menghasilkan 6'la' * 3 menghasilkan 'lalala'.

** (pangkat)

Menghasilkan x pangkat y

3 ** 4 memberikan 81 (dengan kata lain 3 * 3 * 3 * 3)

/ (pembagian)

Membagi x oleh y

4 / 3 menghasilkan 1.3333333333333333.

// (pembagi bulat ke bawah)

Mengembalikan hasil pembulatan ke bawah dari hasil pembagian

4 // 3 menghasilkan 1.

% (modulo)

Menghasilkan sisa dari pembagian

8 % 3 menghasilkan 2-25.5 % 2.25 menghasilkan 1.5.

<< (geser kiri)

Menggeser nomor bit ke sebelah kiri sesuai dengan jumlah bit yang telah ditentukan (setiap angka merupakan representasi bit di memori atau digit biner, yakni 0 dan 1)

2 << 2 menghasilkan 82 direpresentasikan 10 dalam bits.

Menggeser 2 bit kekiri akan menghasilkan 1000 yang merupakan representasi dari desimal 8.

>> (geser kanan)

Menggeser angka bit ke kanan sesuai dengan jumlah bit yang telah ditentukan.

11 >> 1 menghasilkan 5.

11 direpresentasikan oleh bit dengan 1011 kemudian digeser ke kanan 1 bit menghasilkan 101 yang merupakan desimal angka 5

& (bitwise AND)

Operasi bit-wise AND dari angka (bitwise adalah operasi angka berbasis bit yakni dengan 0 dan 1)

5 & 3 menghasilkan 1.

| (bitwise OR)

Operasi bitwise OR dari angka

5 | 3 menghasilkan 7

^ (bitwise XOR)

Operasi angka Bitwise XOR (OR ekslusif/exclusive or)

5 ^ 3 menghasilkan 6

~ (bitwise invert)

Membalikkan angka bitwise dari x atau -(x+1)

~5 menghasilkan -6.

< (kurang dari)

Menghasilkan pengembalian apakah x kurang dari y. Semua operator perbandingan hanya menghasilkan True atau False. Catat huruf besar yang ada di awal kata tersebut.

5 < 3 menghasilkan False dan 3 < 5 menghasilkan True.

Perbandingan dapat dirangkai secara bebas: 3 &lt; 5 &lt; 7 menghasilkan True.

> (lebih besar dari)

Menghasilkan pengembalian apakah x lebih besar daripada y

5 &gt; 3 menghasilkan True. Jika operand berupa angka, keduanya akan dikonversikan dalam tipe yang sejenis. Selain itu, selalu mengembalikan nilai False

<= (lebih kecil atau sama dengan)

Menghasilkan pengembalian apakah x lebih kecil atau sama dengan y

x = 3; y = 6; x &lt;= y menghasilkan True.

>= (lebih besar atau sama dengan)

Menghasilkan pengembalian apakah x lebih besar atau sama dengan y

x = 4; y = 3; x &gt;= 3 menghasilkan True.

== (sama dengan)

Membandingkan apakah kedua objek sama atau tidak

x = 2; y = 2; x == y menghasilkan True.

x = 'str'; y = 'stR'; x == y menghasilkan False.

x = 'str'; y = 'str'; x == y menghasilkan True.

!= (tidak sama dengan)

Membandingkan apakah kedua objek berbeda atau tidak

x = 2; y = 3; x != y menghasilkan True.

not (boolean NOT)

Jika x True, akan menghasilkan False. Jika x False, menghasilkan True.

x = True; not x menghasilkan False.and (boolean AND)

x dan y menghasilkan False Jika x False, selain itu akan menghasilkan pengembalian evaluasi nilai y

x = False; y = True; x and y menghasilkan False mengingat x False. Dalam kasus ini, Python tidak akan mengevaluasi y mengingat nilai dari ekspresi and adalah False yang menunjukkan bahwa seluruh ekspresi akan bernilai False dengan mengabaikan nilai apapun yang ada setelahnya. Ini disebut evaluasi sirkuit-pendek.or (boolean OR)

Jika x True, akan mengembalikan True, selain itu akan mengembalikan nilai y

x = True; y = False; x or y mengembalikan True. Evaluasi sirkuit pendek juga berlaku di sini.

Jalan pintas untuk operasi matematika dan penugasan

Menjalankan operasi matematika di variable lalu menugaskan hasilnya kembali kepada variabel cukup umum dilakukan di Python. Berikut adalah jalan pintas untuk menjalankan ekspresi tersebut.

Anda dapat menulis:

a = 2
a = a * 3

dengan cara:

a = 2
a *= 3

Perhatikan bahwa operasi ekxpresi var = var menjadi var operasi = ekspresi.

Urutan Evaluasi

Jika Anda memiliki ekspresi seperti 2 + 3 * 4, yang dilakukan penambahan dulu atau perkalian dulu? Dulu guru matematika di sekolah kita mengatakan bahwa perkalian harus dilakukan lebih dulu. Ini berarti operasi perkalian memiliki tingkat yang lebih tinggi daripada operasi penambahan.

Tabel berikut memberikan urutan untuk Python, dari urutan paling rendah (ikatan terendah) ke urutan tertinggi (ikatan tertinggi). Ini berarti bahwa dalam setiap ekspresi yang diberikan, Python akan mengevaluasi operator dan ekspresi di tabel yang lebih rendah sebelum menjalankan operasi di tabel yang lebih tinggi.

Tabel berikut diambil dari manual referensi Python, diberikan hanya untuk kelengkapan saja. Lebih disarankan sebetulnya untuk menggunakan tanda kurung untuk mengelompokkan operasi dan operand secara benar, dan secara eksplit menentukan urutan. Ini membuat program dapat lebih dibaca. Lihat Mengubah Urutan Evaluasi di bawah untuk lebih lengkapnya.lambda

Ekspresi lambdaor

Boolean ORand

Boolean ANDnot x

Boolean NOTin, not in

Tes keanggotaan variabelis, is not

Tes identitas variabel<, <=, >, >=, !=, ==

Perbandingan|

Bitwise OR^

Bitwise XOR&

Bitwise AND<<, >>

Menggeser+, -

Penambahan dan Pengurangan*, /, //, %

Perkalian, Pembagian, Pembagian pembulatan kebawah dan sisa (modulo)+x, -x

Positif, Negatif~x

Bitwise NOT**

Eksponensial/Pangkatx.attribute

Referensi terhadap atributx[index]

Pendaftaranx[index1:index2]

Pemotonganf(argumen ...)

Pemanggilan fungsi(ekspresi, ...)

Pengikatan atau penampilan dalam format tuple[ekspresi, ...]

Penampilan dalam format list{key:datum, ...}

Penampilan dalam format kamus (dictionary)

Simbol operasi yang belum dibahas akan dijelaskan nanti pada bagian berikutnya.

Simbol operasi yang memiliki bobot yang sama akan ditampilkan pada baris yang sama di tabel di atas. Sebagai contoh, + dan - memiliki bobot yang sama.

Mengubah Urutan Pelaksanaan Ekspresi

Untuk membuat ekspresi lebih mudah dibaca kita dapat menggunakan tanda dalam kurung. Sebagai contoh 2 + ( 3 * 4 ) jauh lebih mudah untuk dipahami daripada2 + 3 * 4yang membutuhkan pengetahuan urutan operator. Sebagaimana hal lainnya, tanda dalam kurung harus digunakan secara tepat (jangan berlebihan) dan jangan berulang seperti di(2 + (3 * 4)).

Ada keuntungan lain menggunakan tanda kurung – membantu penggantian urutan pelaksanaan. Sebagai contoh jika Anda ingin penambahan diproses dulu sebelum perkalian dalam satu ekspresi, Anda dapat menuliskannya dengan (2 +3) * 4.

Asosiatifitas

Operator biasanya diasosiasikan dari kiri kekanan. Ini berarti operator dengan urutan yang sama, akan dijalankan secara urut dari kiri ke kanan. Sebagai contoh, 2 + 3 + 4 akan dijalankan dengan urutan (2 + 3) + 4. Beberapa operator seperti operator sama-dengan (penugasan/assignment) memiliki asosiatifitas dari kanan ke kiri. Misalnya a = b = c diperlakukan a = (b = c).

Ekspresi

Contoh (simpan berkas berikut dengan nama expression.py):

panjang = 5
lebar = 2

area = panjang * lebar
print('Area seluas', area)
print('Perimeter seluas', 2 * (panjang + lebar))

Keluaran:

$ python3 expression.py
Area seluas 10
Perimeter seluas 14

Bagaimana Cara Kerjanya:

Panjang dan lebar dari sebuah persegi empat disimpan dalam variabel dengan nama sama. Kita gunakan ini untuk menghitung area dan perimeter persegi empat di mana variabelnya disimpan dengan nama yang sama. Kita simpan hasil dari ekspresi panjang * lebar ke dalam variabel bernama area, lalu mencetaknya di layar dengan perintah print. Dalam kasus kedua, kita secara langsung menggunakan nilai dari eksresi 2 * (panjang + lebar) dalam fungsi print.

Juga perhatikan bagaimana Python ‘mencetak-cantik’ keluarannya. Meskipun kita tidak menentikan spasi antara 'Area seluas' dengan variabel area, Python menampilkannya dalam keluaran yang manis dan bersih sehingga program dapat jauh lebih mudah dibaca dengan cara ini (mengingat kita tidak perlu khawatir tentang spasi dan string untuk menggunakan keluaran). Ini adalah salah satu contoh bagaimana Python membuat hidup programmer menjadi lebih mudah.

Ringkasan

Kita telah melihat bagaimana menggunakan operator, operan dan ekspresi – ini adalah kerangka dasar dari sebuah program. Berikutnya kita akan melihat bagaimana cara menggunakan hal ini ke dalam program lewat alur kontrol statemen.

Kategori
Python

Langkah Pertama Pemrograman Python

Kita sekarang akan melihat bagaimana membuat program yang sering digunakan saat memulai pemrograman, yakni ‘Hello World’ di Python. Langkah ini akan mengajari Anda bagaimana menulis, menyimpan dan menjalankan program Python.

Ada dua cara menjalankan program Anda dengan menggunakan Python – menggunakan prompt interpreter interaktif atau menggunakan berkas sumber (source file). Kita akan lihat bagaimana cara menggunakan kedua metode ini.

Menggunakan Prompt Interpreter

Buka terminal di sistem operasi Anda (sebagaimana telah didiskusikan sebelumnya di Bab Instalasi) lalu buka prompt Python dengan mengetikkan python3 dan menekan tombol enter.

Sekali Anda mulai python3, Anda akan melihat >>> di mana Anda dapat mulai mengetikkan sesuatu. Ini disebut sebagai prompt interpreter Python.

Di prompt interpreter Python, ketik print('Hello World') lalu tekan tombol enter. Anda seharusnya melihat keluaran Hello World

Berikut contoh apa yang seharusnya Anda lihat, saat menggunakan komputer Mac OS X. Detail tentang perangkat lunak Python, tentu akan berbeda berdasarkan komputer Anda, tapi bagian prompt (contoh dari >>> dan berikutnya) seharusnya sama dengan mengabaikan sistem operasi yang Anda miliki.

$ python3
Python 3.3.0 (default, Oct 22 2012, 12:20:36)
[GCC 4.2.1 Compatible Apple Clang 4.0 ((tags/Apple/clang-421.0.60))] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> print('hello world')
hello world
>>> 

Perhatikan bahwa Python memberikan keluaran di baris berikutnya secara langsung! Yang baru Anda masukkan adalah statemen Python tunggal. Kita menggunakan print untuk (secara mengejutkan) menampilkan setiap nilai yang Anda masukkan. Di sini kita memasukkan teks Hello World dan secara langsung tampil di layar.

Bagaimana Berhenti dari Prompt Interpreter

Jika Anda menggunakan shell Linux atau Unix, Anda dapat keluar dari prompt interpreter dengan menekan ctrl-d atau memasukkan perintah exit() (catatan: ingat selalu untuk memasukkan tanda kurung, ‘()’) diikuti dengan penekanan tombol enter. Jika Anda menggunakan baris perintah Windows, tekan ctrl-z diikuti tombol enter.

Memilih Editor

Kita tidak dapat menuliskan program di baris interpreter setiap kali ingin menjalankan sesuatu, jadi kita harus menuliskannya di dalam berkas dan kita dapat menjalankan program kita selama beberapa kali.

Untuk membuat berkas kode program Python, kita perlu perangkat lunak berupa editor sehingga kita dapat menulis dan menyimpannya. Editor bahasa pemrograman Python yang baik akan membuat hidup Anda lebih mudah dalam menulis berkas kode program. Oleh karena itu, pemilihan editor sifatnya sangat penting. Anda harus memilih editor sebagaimana memilih mobil untuk dikendarai. Editor yang bagus akan membantu Anda menulis program Python secara lebih mudah, dan membuat perjalanan Anda lebih nyaman dalam meraih tujuan Anda secara lebih cepat dan aman.

Salah satu dari syarat dasar adalah syntax highlighting atau pewarnaan sintaks di mana bagian program Python Anda akan diwarnai secara berbeda sehingga Anda dapat benar-benar melihat program Anda dan memvisualisasikan bagaimana jika program tersebut berjalan.

Jika Anda tidak tahu darimana memulai, Saya rekomendasikan untuk menggunakan perangkat lunak editor Komodo Edit yang tersedia untuk Windows, Mac OS X dan Linux.

Notepad vs Vim

Jika Anda menggunakan Windows, jangan menggunakan Notepad – perangkat lunak tersebut tidak disarankan untuk dipilih karena tidak ada pewarnaan sintaks dan lebih penting lagi, tidak mendukung indentasi teks, yang merupakan syarat sangat penting dalam kasus ini, yang nanti akan kita lihat. Editor yang bagus seperti Komodo Edit akan melakukan ini secara otomatis.

Jika Anda merupakan programmer yang berpengalaman, Anda pasti sudah menggunakan Vim atau Emacs. Tanpa perlu banyak pembahasan, kedua perangkat lunak ini merupakan editor yang paling berkualitas dan Anda akan memperoleh banyak keuntungan jika menggunakannya untuk menulis pemrograman Python. Jika Anda mau menyediakan atau punya waktu untuk belajar Vim atau Emacs, saya menganjurkan untuk mempelajarinya karena akan sangat bermanfaat dalam jangka panjang. Bagaimanapun juga, sebagaimana saya sebutkan sebelumnya, pemula dapat mulai dengan menggukana Komodo Edit dan fokus belajar pemrograman Python daripada belajar editor untuk saat ini.

Sebagai pengingat kembali, silakan pilih editor yang layak untuk Anda – Hal itu dapat membuat penulisan program Python menjadi lebih menyenangkan dan mudah.

Untuk Pengguna Vim

Ada pengenalan yang bagus tentang bagaimana membuat Vim menjadi Python IDE yang bagus oleh John M Anderson. Yang juga direkomendasikan adalah jedi-vim plugin dan konfigurasi dotvim saya. Untuk Pengguna Emacs

Ada pengenalan yang bagus tentang bagaimana membuat Emacs menjadi Python IDE yang bagus oleh Pedro Kroger. Yang juga direkomendasikan adalah konfigurasi dotemacs BG.

Menggunakan Berkas Program

Sekarang kita kembali ke pemrograman. Ada tradisi setiap Anda belajar bahasa pemrograman baru, program pertama yang Anda tulis dan jalankan adalah program ‘Hello World’ – program itu hanyalah menampilkan ‘Hello World’ saat Anda menjalankannya. Sebagaimana dikatakan oleh Simon Cozens (pengarang buku yang sangat menakjubkan ‘Beginning Perl’), itu adalah “mantra tradisional dewa pemrograman yang membantu Anda belajar bahasa tersebut secara lebih baik.”

Pilihlah Editor Anda, dan masuk ke dalam program tersebut, simpan dengan nama hello.py.

Jika Anda menggunakan Komodo Edit, klik di File — New — New File, ketik baris berikut:

print('Hello World')

Di Komodo Edit, klik File — Save untuk menyimpan berkas.

Untuk kebutuhan belajar pemrograman Python ini, dimana Anda harus simpan berkasnya? Di setiap folder yang Anda sendiri tahu persis di mana letak folder tersebut. Jika Anda tidak tahu apa maksudnya, buat folder baru dan gunakan folder tersebut untuk menyimpan dan menjalankan semua program Python Anda:

  • C:\\py di Windows
  • /tmp/py di Linux
  • /tmp/py di Mac OS X

Untuk membuat folder, gunakan perintah mkdir di terminal, contohnya mkdir /tmp/py.Penting

Selalu pastikan Anda memberi nama ekstensi berkasnya .py, sebagai contoh foo.py.

Menjalankan Program

Di Komodo Edit, klik Tools — Run Command, ketik python3 hello.py dan klik Run 

Jalan terbaik adalah, tidak mengetikkannya di Komodo Edit, namun menggunakan terminal:

  1. Buka Terminal sebagaimana telah dijelaskan di Bab Instalasi.
  2. Ganti direktori di mana Anda menyimpan berkas, sebagai contoh, cd /tmp/py
  3. Jalankan program dengan mengetikkan perintah python3 hello.py.

Keluaran akan ditampilkan sebagai berikut.

$ python3 hello.py
Hello World

Jika Anda memperoleh keluaran sebagaimana yang ditampilkan di atas, selamat! – Anda telah berhasil menjalankan program Python pertama Anda. Anda telah berhasil melewati bagian yang paling sulit dari belajar pemrograman, yakni, memulai program pertama.

Jika Anda memperoleh pesan kesalahan, mohon ketikkan lagi program di atas sama persis seperti ditampilkan di atas dan jalankan program kembali. Mohon dicatat bawah Python sangat peka terhadap huruf besar kecil, seperti print tidak sama dengan Print – catat bahwa p di kata pertama adalah huruf kecil dan p di kata berikutnya adalah huruf besar. Juga, pastikan tidak ada spasi atau tab sebelum huruf pertama di tiap baris – kita akan lihat nanti kenapa ini penting.

Bagaimana Cara Kerjanya

Program Python disusun atas statemen. Di Program pertama kita, kita hanya punya satu statemen. Dalam statemen ini, kita sebut sebagai fungsi print yang hanya mencetak teks Hello World. Kita akan belajar tentang fungsi secara lebih mendalam di bagian berikutnya – Apa yang perlu Anda pahami sekarang adalah setiap yang Anda ketikkan setelah tanda petik akan dikeluarkan kembali di layar. Dalam kasus ini kita mengetikkan teks ‘Hello World

Program Python yang bisa Dieksekusi

Ini hanya berlaku untuk pengguna Linux dan Unix, tapi pengguna Windows juga perlu tahu hal ini.

Setiap kali, Anda ingin menjalankan program Python, Anda harus secara eksplisit mengetikkan python3 foo.py, tapi kenapa kita tidak menjalankannya seperti program lain di komputer? Kita dapat melakukannya dengan menggunakan sesuatu yang disebut baris hashbang.

Tambahkan baris berikut di baris pertama program Anda:

#!/usr/bin/env python3

Jadi program Anda akan terlihat seperti ini sekarang:

#!/usr/bin/env python3
print('Hello World')

Hak Eksekusi

Kedua, kita harus memberikan program tersebut hak eksekusi dengan perintah chmod lalu jalankan berkas program.

Perintah chmod yang digunakan di sini adalah untuk mengubah mode dari file dengan memberikan hak eksekusi untuk semua pengguna di dalam sistem.

$ chmod a+x hello.py

Sekarang, kita dapat menjalankan program secara langsung sebab sistem operasi akan memanggil /usr/bin/env yang akan menemukan Python 3 yang sudah kita pasang, sehingga tahu bagaimana menjalankan berkas program tersebut:

$ ./hello.py
Hello World

Kita menggunakan ./ untuk mengindikasikan bahwa program berada di folder saat ini.

Untuk menjadikannya lebih menarik, Anda dapat mengganti nama berkas tersebut hanya dengan nama hello dan menjalankannya dengan ./hello dan tetap akan jalan mengingat sistem sudah tahu bahwa untuk menjalankan program tersebut harus menggunakan interpreter yang lokasinya sudah ditentukan di baris pertama berkas program.

Menjalankan Program dari Folder

Sejauh ini, kita sudah menjalankan program kita sepanjang kita tahu path-nya secara tepat. Bagaimana jika kita ingin menjalankan program dari folder? Anda dapat melakukannya dengan menyimpan program di satu folder yang terdaftar di variabel lingkungan PATH.

Setiap Anda menjalankan program apapun, sistem akan mencari program tersebut di tiap folder yang terdaftar dalam variabel lingkungan PATH dan menjalankan program tersebut. Kita dapat membuat program ini tersedia di mana saja dengan menyalin berkas program ini ke dalam direktori-direktori yang terdaftar di PATH.

$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/home/swaroop/bin
$ cp hello.py /home/swaroop/bin/hello
$ hello
Hello World

Kita dapat menampilkan variabel PATH dengan menggunakan perintah echo dan memberikan awalan nama variabel dengan $ untuk mengindikasikan kepada shell bahwa kita membutuhkan nilai dari “variabel lingkungan”. Kita lihat bahwa /home/swaroop/bin ada di salah satu direktori di variabel PATH di mana swaroop adalah nama user yang saya gunakan di dalam sistem. Biasanya ada direktori yang sama persis untuk username Anda di dalam sistem.

Jika Anda ingin menambahkan direktori pilihan Anda ke dalam variabel PATH – ini dapat dilakukan dengan menjalankan perintah export PATH=$PATH:/home/swaroop/mydir di mana '/home/swaroop/mydir' adalah direktori yang ingin saya tambahkan ke dalam variabel PATH.

Metode ini sangat bermanfaat jika Anda ingin menuliskan perintah yang dapat Anda jalankan tiap saat, di mana saja. Hal ini seperti membuat perintah Anda sendiri seperti cd atau perintah lain yang Anda gunakan di terminal.

Memperoleh Bantuan

Jika Anda butuh informasi cepat tentang fungsi atau statemen di Python, Anda dapat menggunakan fungsi help yang secara baku sudah ada. Hal ini sangat bermanfaat terutama saat menggunakan prompt interpeter. Sebagai contoh, jalankan perintah help(print) – akan menampilkan bantuan dari fungsi print yang digunakan untuk mencetak semua masukan ke dalam layar.Catatan

tekan q untuk keluar dari bantuan.

Mirip dengan hal tersebut, Anda dapat memperoleh informasi segala sesuatu tentang pemrograman Python. Cukup gunakan help() untuk mempelajari lebih lanjut tentang bagaimana menggunakan help itu sendiri!

Jika Anda ingin memperoleh bantuan operator seperti return, Anda harus meletakknya di dalam tanda petik seperti help('return') sehingga Python tidak bingung tentang apa yang Anda ingin lakukan.

Ringkasan

Anda seharusnya sudah mampu menulis, menyimpan dan menjalankan program Python secara mudah.

Sekarang Anda adalah pengguna Python, mari belajar beberapa konsep Python lebih lanjut dalam dasar pemrograman Python.

Kategori
Python

Instalasi Python

Instalasi Python dapat dilakukan di Windows, Linux, MacOS atau perangkat kecil lainnya seperti Raspberry Pi. Panduan berikut untuk pemula, berisi petunjuk instalasi Python pada sistem operasi umumnya.

Versi Python meningkat dari waktu ke waktu. Saat tulisan ini dibuat versi terbaru adalah Python versi 3.3, sehingga banyak direktori yang kita buat dengan menggunakan nama Python33. Anda bisa menyesuaikan penamaan folder dan lainnya sesuai dengan versi Python terakhir.

Instalasi Python di Windows

Kunjungi http://www.python.org/download/ dan unduh versi terakhir. Instalasi akan dilakukan sebagaimana perangkat lunak berbasis Windows lainnya.Perhatian

Ketika diberi pilihan untuk menghilangkan centang komponen “optional”, jangan melakukan hilangkan centangnya.

Prompt DOS

Jika Anda ingin menggunakan Python dari baris perintah Windows seperti prompt DOS, Anda harus set variabel PATH secara benar.

Untuk Windows 2000, XP, 2003 , klik Control Panel — System — Advanced — Environment Variables. Klik pada variabel bernama PATH di bagian ‘System Variables’, lalu pilih Edit dan tambahkan ;C:\Python33 (mohon pastikan folder ini sudah ada, dan akan berbeda untuk versi Python yang lebih baru) di akhir isian yang sudah ada di sana. Tentu saja, gunakan nama direktori yang sesuai.

Untuk versi Windows lebih lama, buka berkas C:\AUTOEXEC.BAT dan tambahkan baris ‘PATH=%PATH%;C:\Python33’ (tanpa tanda petik) kemudian nyalakan ulang sistemnya. Untuk Windows NT, gunakan berkas AUTOEXEC.NT.

Untuk Windows Vista:

  1. Klik Start dan pilih Control Panel
  2. Klik Sistem, di bagian kanan Anda akan lihat “View basic information about your computer”
  3. Di bagian kiri daftar tasks, muncul “Advanced system settings.” Silakan diklik.
  4. Tab Advance dari kotak dialog System Properties akan muncul. Klik tombol Environment Variable di bagian kanan bawah.
  5. Di kotak bawah berjudul “System Variables” gulung layar ke Path dan klik tombol Edit.
  6. Ganti path sesuai yang dibutuhkan (lihat referensi sebelumnya).
  7. Nyalakan kembali sistem Anda. Vista tidak akan mengambil perubahan variable lingkungan path sistem hingga dinyalakan kembali.

Untuk Windows 7:

  1. Klik kanan Komputer yang ada di desktop, dan pilih Properties, atau klik Start dan pilih Control Panel — System and Security — System. Koik di seting sistem bagian Advanced di sebelah kiri dan tekan tab Advanced. Di bagian bawah tekan “Environment Variables”, dan di bawah “System variables”, cari variabel PATH, pilih dan tekan Edit.
  2. Pergi ke akhir baris di bawah nilai Variable dan tambahkan ;C:\Python33.
  3. Jika nilai sebelumnya adalah %SystemRoot%\system32; maka sekarang akan menjadi %SystemRoot%\system32;C:\Python33
  4. Tekan ok dan selesai. Tidak perlu dinyalakan ulang.

Menjalankan prompt Python di Windows

Untuk pengguna Windows, Anda dapat menjalankan interpreter di baris perintah jika diperlukan set variabel PATH dengan benar.

Untuk membuka terminal di Windows, klik tombol Start dan klik ‘Run’. Di kotak dialog, ketik cmd dan tekan enter.

Lalu ketik python3 -V dan pastikan tidak ada pesan kesalahan.

Instalasi Python di Mac OS X

Untuk pengguna Mac OS X, buka terminal dengan menekan tombol Command+Space (untuk membuka pencarian Spotlight), ketik Terminal dan tekan tombol enter.

Install Homebrew dengan menjalankan:

ruby -e "$(curl -fsSkL raw.github.com/mxcl/homebrew/go)"

Lalu instal Python 3 dengan menggunakan:

brew install python3

Lalu, jalankan python3 -V dan pastikan tidak ada pesan kesalahan.

Instalasi Python di Linux

Untuk pengguna Linux, buka terminal dengan membuka aplikasi Terminal dengan menekan Alt + F1 dan memasukkan gnome-terminal. Jika hal itu tidak jalan, silakan rujuk ke dokumentasi atau forum untuk distribusi Linux yang Anda miliki.

Selanjutnya, kita menginstal paket python3. Sebagai contoh, di Ubuntu, Anda bisa menjalankan sudo apt-get install python3. Silakan cek dokumentasi atau forum sesuai dengan distribusi Linux yang Anda gunakan untuk menjalankan perintah manajer paket yang sesuai.

Setelah Anda menyelesaikan instalasi, jalankan perintah python3 -V dan Anda seharusnya melihat versi Python di layar:

$ python3 -V
Python 3.3.0

Catatan

$ adalah prompt dari shell. Hal itu berbeda satu sama lain tergantung dari setingan sistem operasi di komputer Anda, dan untuk saat ini saya akan menggunakan simbol $ sebagai prompt.

Pada distribusi Linux yang baru, sudah menyertakan Python3 secara baku. Jadi Anda cek dulu apakah versi Python baku yang dibawa distribusi Linux Anda versi 2 atau 3. Sejak sekarang, saya sudah mengasumsikan Anda punya Python 3 terinstal di sistem Anda.

Berikutnya, kita akan menulis program Python 3 pertama kita.

Kategori
Python

Bahasa Pemrograman Python dan Fiturnya

Bahasa Pemrograman Python memiliki fitur-fitur menarik bagi pemula. Anda cukup belajar satu bahasa pemrograman dan bisa menjangkau seluruh tugas-tugas permasalahan di bidang pemrograman.

Sederhana

Bahasa Pemrograman Python adalah bahasa yang minimalis dan sederhana. Membaca program Python sederhana seperti membaca bahasa Inggris, meskipun Inggris yang baku! Watak Python berupa pseudo-code ini adalah kekuatan terbesarnya. Hal tersebut memungkinkan Anda berkonsentrasi kepada solusi terhadap masalah daripada pusing tentang bahasanya sendiri.

Mudah Dipelajari

Seperti yang akan Anda lihat, Python sangat mudah untuk dimulai. Python juga memiliki sintaks yang luar biasa mudah, seperti telah disebutkan sebelumnya.

bahasa pemrograman python
Sumber Gambar: https://www.reddit.com/r/ProgrammerHumor/comments/9c55gd/python/

Bebas dan Open Source

Bahasa Pemrograman Python adalah salah satu contoh dari FLOSS (Free/Libre and Open Source Software – Perangkat Lunak Bebas dan Terbuka). Dalam bahasa yang sederhana, Anda dapat mendistribusikan perangkat lunak ini secara bebas, membaca kode programnya, membuat perubahan, dan menggunakan sebagian dari program ini untuk program bebas lainnya. FLOSS didasarkan atas konsep komunitas yang berbagi pengetahuan. Ini salah satu alasan kenapa Python sangat bagus – dia dibuat dan diperbaiki secara konstan oleh komunitas yang ingin melihat Python lebih baik.

Bahasa Tingkat-Tinggi

Saat Anda menulis program di Python, Anda tidak perlu repot untuk mempelajai detail tingkat-rendah-nya seperti manajemen memori yang digunakan program dan hal-hal tingkat rendah (mendekati bahasa mesin) lainnya.

Portabel

Dengan sifatnya yang terbuka (open source), Python telah diporting (disesuaikan agar bisa berjalan di) banyak platform. Seluruh program Python Anda dapat dijalankan dalam platform berikut tanpa perlu diganti, dan jika Anda cukup berhati-hati, dapat terhindar dari fitur yang tergantung dari sistem operasi yang digunakan.

Anda dapat menggunakan Python di Linux, Windows, FreeBSD, Macintosh, Solaris, OS/2, Amita, AROS, AS/400, BeOS, OS/390, z/OS, Palm OS, QNX, VMS, Psion, Acorn RISC OS, VxWorks, PlayStation, Sharp Zaurus, windows CE dan bahkan Pocket PC!

Anda dapat pula menggunakan platform seperti Kivy untuk membuat game di iOS (iPhone, iPad) dan Android.

Diinterpretasikan (Interpreted)

Tentang hal ini perlu sedikit penjelasan.

Program yang ditulis dalam bahasa seperti C atau C++ (sering disebut bahasa yang dikompilasi – compiled language), dikonversi dari kode program C atau C++ ke dalam bahasa yang dapat berbicara oleh komputar Anda (kode biner seperti 0s dan 1s) menggunakan kompiler dengan bermacam penanda dan pilihan. Saat Anda menjalankan program, perangkat lunak penghubung (linker/loeader) menyalin program Anda dari cakram keras ke dalam memori dan mulai menjalankannya.

Python, di sisi lain, tidak perlu dikompilasi menjadi biner. Anda cukuup jalankan program langsung dari kode program. Secara internal, Python mengonversi kode program ke dalam bentuk antara yang dinamakan bytecodes dan menerjemahkannya ke dalam bahasa komputer Anda, lalu menjalankannya. Semua ini, sebetulnya, membuat penggunaan Python menjadi lebih mudah. Anda tidak perlu khawatir tentang kompilasi program, dan memastikan pustaka terkait dijalankan, dan hal-hal teknis lainnya. Ini juga membuat program Python Anda lebih portabel. Anda cuma perlu menyalin program Python ke dalam komputer lain dan langsung jalan!

Berorientasi Objek

Python mendukung pemrograman berorientasi prosedur (procedure-oriented) sebaik pemrograman berorientasi objek (object-oriented). Dalam bahasa procedure-oriented, program dibangun dari rangkaian prosedur atau fungsi, agar dapat digunakan kembali. Dalam bahasa object-oriented, program dbuat berdasaran objek yang dikombinasikan data dan metode. Python sangat kuat namun sederhana dalam menjalankan OOP (Object Oriented Programming) terutama jika dibandingkan dengan bahasa besar seperti C++ atau Java.

Dapat diperluas (Extensible)

Jika Anda ingin bagian penting dari program dijalankan secara lebih cepat, atau bagian lain berisi algoritma yang bersifat rahasia, Anda dapat membuat bagian dari kode tersebut ke dalam C atau C++ dan menggunakannya ke dalam program Python Anda.

Dapat disematkan (Embeddable)

Anda dapat menyematkan Python ke dalam program C/C++ untuk memberi kemampuan ‘scripting’ bagi pengguna program Anda.

Pustaka yang Ekstensif

Pustaka Standar Python (Python Standard Library) sangat banyak. Pustaka tersebut dapat membantu Anda mengerjakan banyak hal mencakup ekspresi regular (regular expressions/REGEX), pembuatan dokumen otomatis, unit testing, threading, basis data, browser web, CGI, FTP, email, XML, XML-RPC, HTML, berkas WAV, kriptografi, GUI (graphical user interface – antar muka pengguna berbentuk grafik) dan hal lain yang bergantung-sistem. Ingat, semua ini tersedia di mana saja saat Python diinstal. Ini filosofi Python yang bernama Batteries Included (sudah termasuk batere di dalamnya).

Disamping pustaka standar, ada banyak pustaka berkualitas tinggi lainnya yang dapat Anda temukan di Python Package Index.

Python adalah bahasa yang kuat dan menarik. Bahasa ini punya kombinasi yang tepat antara kinerja dan fitur, yang menjadikan penulisan program di Python sangat mudah dan menyenangkan.

Berikutnya, sebelum belajar instalasi, perlu Anda baca dulu perbandingan antara Python 3 dan Python 2

Kategori
Python

Belajar Python Untuk Pemula

Belajar Python buat sebagian orang mungkin sulit. Tapi jika dibandingkan dengan bahasa pemrograman lain, Python termasuk mudah dan bisa dipraktekkan langsung. Yang terpenting adalah keindahan dan keterbacaannya. Percaya nggak? Coba yuk tengok panduan berikut.

Panduan berikut disarikan dari Byte of Python karangan Swaroop Chitlur.

Modal Belajar Python

Belajar Python tidak butuh keahlian khusus. Paling tidak Anda paham sedikit bahasa Inggris, paham Matematika, dan yang paling penting punya imajinasi yang cukup kuat. Pada dasarnya semua bahasa pemrograman membutuhkan imajinasi, tepatnya abstraksi, yang kuat karena semua konsepnya itu tidak terlihat. Kita sebagai programmer harus bisa membayangkannya.

Python itu Apa?

Python barangkali merupakan satu dari bahasa pemrograman yang sederhana namun tangguh. Bahasa ini baik untuk pemula maupun ahli, dan yang lebih penting, sangat enak untuk digunakan untuk pemrograman dan mudah bagi yang ingin belajar Python.

Python adalah salah satu dari jarangnya bahasa pemrograman yang mampu mengklaim sederhana dan tangguh secara bersamaan. Anda akan terkejut namun senang melihat bagaimana mudahnya konsentrasi langsung kepada jawaban daripada pusing dengan sintaks dan struktur dari bahasa pemrograman yang Anda gunakan.

belajar Python
Logo Bahasa Pemrograman Python

Secara resmi Python dikenalkan dengan definisi sebagai berikut:

Python adalah bahasa pemrograman yang mudah dipelajari dan tangguh (powerful). Bahasa ini memiliki struktur data tingkat-tinggi yang efisien dan sederhana, namun punya pendekatan yang efektif untuk pemrograman berbasis objek. Sintaks Python yang elegan dan bersifat dynamic typing (sintaks akan dicek secara langsung tanpa harus menunggu dikompilasi dalam bahasa mesin), dilengkapi dengan interpreter, membuatnya menjadi bahasa pemrograman yang ideal untuk membuat skrip (scripting) dan pengembangan aplikasi secara cepat (rapid application development) di banyak area di platform utama.

Guido van Rossum, pencipta bahasa Python, memberi nama bahasa ini setelah melihat acara BBC “Monty Python’s Flying Circus”. Dia sendiri tidak terlalu suka dengan ular yang membunuh binatang lain untuk makanan dengan menelan seluruh badan dan meremukkannya.

Setelah mengenal ringkas, selanjutnya langkah belajar Python kita akan menemui Fitur Bahasa Pemrograman Python.