├── .gitignore ├── requirements.txt ├── assets └── komodo-edit-hello-world.png ├── LICENSE ├── .project ├── 23-translation-howto.pd ├── README.md ├── 20-appendix-about.pd ├── 21-revision-history.pd ├── config.json ├── 02-preface.pd ├── 04-installation.pd ├── 19-appendix-floss.pd ├── 16-standard-library.pd ├── 14-io.pd ├── 03-intro.pd ├── 01-frontpage.pd ├── 15-exceptions.pd ├── 17-more.pd ├── 18-what-next.pd ├── 07-operators-expressions.pd ├── 05-first-steps.pd ├── fabfile.py ├── 08-control-flow.pd ├── 10-modules.pd ├── 06-basics.pd ├── 09-functions.pd └── 22-translations.pd /.gitignore: -------------------------------------------------------------------------------- 1 | *.pyc 2 | *.*DS_Store 3 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | Fabric == 1.4.3 2 | boto == 2.6.0 3 | beautifulsoup4 == 4.1.3 4 | -------------------------------------------------------------------------------- /assets/komodo-edit-hello-world.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/asofyan/byte_of_python/HEAD/assets/komodo-edit-hello-world.png -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License - see http://creativecommons.org/licenses/by-sa/3.0/deed.en_US for details. 2 | -------------------------------------------------------------------------------- /.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | byte_of_python 4 | 5 | 6 | 7 | 8 | 9 | 10 | com.aptana.projects.webnature 11 | 12 | 13 | -------------------------------------------------------------------------------- /23-translation-howto.pd: -------------------------------------------------------------------------------- 1 | # Cara Penerjemahan 2 | 3 | Sumber buku secara lengkap tersedia di repositori Git . Terjemahan Bahasa Indonesia tersedia di . 4 | 5 | Silakan [fork dari repositori](https://help.github.com/articles/fork-a-repo). 6 | 7 | Lalu, unduh repositori ke dalam komputer Anda. Anda harus paham bagaimana menggunakan [Git](http://www.git-scm.com) untuk dapat melakukannya. 8 | 9 | Lalu mulai edit berkas `.pd` ke dalam bahasa lokal Anda. Silakan baca [README Pandoc](http://johnmacfarlane.net/pandoc/README.html#pandocs-markdown) untuk emahami cara pem-formatan teks. 10 | 11 | Lalu ikuti petunjuk di berkas [README](http://github.com/swaroopch/byte_of_python#README) untuk menginstal perangkat lunak yang dibutuhkan guna mengonversi berkas asli ke dalam berkas PDF atau dalam format lainnya. 12 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # A Byte of Python 2 | 3 | ## Instalasi 4 | 5 | Pastikan Python (>= 2.7) telah terinstal. 6 | 7 | Instal Pandoc dari 8 | 9 | Instal `pdflatex` dari . 10 | Mohon dicatat bahwa pengguna Mac dapat menginstal `MacTex.pkg` dari . 11 | 12 | Instal `pip` jika belum ada di komputer Anda: 13 | 14 | sudo sh -c "curl -k -O https://raw.github.com/pypa/pip/master/contrib/get-pip.py && python get-pip.py && rm get-pip.py" 15 | 16 | 17 | Instal pustaka Python yang dibutuhkan: 18 | 19 | sudo pip install -r requirements.txt 20 | 21 | 22 | Konversi berkas sumber ke dalam format HTML: 23 | 24 | fab html 25 | 26 | Konversi berkas sumber ke dalam format PDF: 27 | 28 | fab pdf 29 | 30 | Konversi berkas sumber ke dalam format EPUB (ebook): 31 | 32 | fab epub 33 | 34 | ## Mengedit 35 | 36 | Jika Anda menggunakan editor VIM, Anda bisa instal plugin [vim-pandoc](https://github.com/vim-pandoc/vim-pandoc). Bagaimanapun juga ada kelemahannya - untuk bab yang panjang, plugin tersebut membuat vim menjadi pelan, jadi saya hanya mengeditnya dalam mode teks murni (`:set ft=`), namun saat mereview saya menggunakan `pandoc` (`:set ft=pandoc`) 37 | 38 | ## Terjemahan 39 | 40 | Terjemahan Bahasa Indonesia ini disusun oleh Ahmad Sofyan asofyan (a) gmail.com 41 | -------------------------------------------------------------------------------- /20-appendix-about.pd: -------------------------------------------------------------------------------- 1 | # Colophon 2 | 3 | Hampir semua perangkat lunak yang saya gunakan untuk membuat buku ini merupakan perangkat lunak [FLOSS](#floss). 4 | 5 | ## Kelahiran Buku Ini 6 | 7 | Draft pertama buku ini, saya gunakan Linux Red Hat 9.0 sebagai dasar untuk setup pertama, dan di draft ke 6, saya mulai menggunkana Linux Fedora Core 3 sebagai basis setelan. 8 | 9 | Initially, I was using KWord to write the book (as explained in the [history lesson](#history-lesson) in the preface). 10 | 11 | ## Teenage Years 12 | 13 | Later, I switched to DocBook XML using Kate but I found it too tedious. So, I switched to OpenOffice which was just excellent with the level of control it provided for formatting as well as the PDF generation, but it produced very sloppy HTML from the document. 14 | 15 | Finally, I discovered XEmacs and I rewrote the book from scratch in DocBook XML (again) after I decided that this format was the long term solution. 16 | 17 | In the sixth draft, I decided to use Quanta+ to do all the editing. The standard XSL stylesheets that came with Fedora Core 3 Linux were being used. However, I had written a CSS document to give color and style to the HTML pages. I had also written a crude lexical analyzer, in Python of course, which automatically provides syntax highlighting to all the program listings. 18 | 19 | For this seventh draft, I'm using [MediaWiki](http://www.mediawiki.org ) as the basis of my [setup](http://www.swaroopch.com/notes/). Now I edit everything online and the readers can directly read/edit/discuss within the wiki website. 20 | 21 | I used Vim for editing thanks to the [ViewSourceWith extension for Firefox](https://addons.mozilla.org/en-US/firefox/addon/394) that integrates with Vim. 22 | 23 | ## Now 24 | 25 | Using [Vim](http://www.swaroopch.com/notes/vim), [Pandoc](http://johnmacfarlane.net/pandoc/README.html), and Mac OS X. 26 | 27 | ## About The Author 28 | 29 | 30 | -------------------------------------------------------------------------------- /21-revision-history.pd: -------------------------------------------------------------------------------- 1 | # Sejarah Perbaikan 2 | 3 | - 2.0 4 | - 20 Okt 2012 5 | - Ditulis ulang dalam [format Pandoc](http://johnmacfarlane.net/pandoc/README.html), terima kasih untuk istri saya yang banyak menerjemahkan melalui format Mediawiki 6 | - Penyederhanaan teks, menghapus bagian-bagian yang tidak penting seperti `nonlocal` dan metaclasses 7 | - 1.90 8 | - 04 Sep 2008 dan masih dalam pengembangan 9 | - Bangkit kembali setelah vakum selama 3.5 tahun! 10 | - Penulisan ulang untuk 3.0 11 | - Penulisan ulang dengan menggunakan [MediaWiki](http://www.mediawiki.org) (lagi) 12 | - 1.20 13 | - 13 Jan 2005 14 | - Penulisan ulang secara lengkap dengan [Quanta+](https://en.wikipedia.org/wiki/Quanta_Plus) di [Fedora](http://fedoraproject.org/) Core 3 dengan menambahkan banyak perbaikan dan pembaruan. Tambahan contoh-contoh baru. Menulis ulang setelan DocBook dari nol. 15 | - 1.15 16 | - 28 Mar 2004 17 | - Revisi minor 18 | - 1.12 19 | - 16 Mar 2004 20 | - Tambahan dan perbaikan. 21 | - 1.10 22 | - 09 Mar 2004 23 | - Perbaikan salah ketik, terima kasih untuk para pembaca yang antusias dan siap bantu. 24 | - 1.00 25 | - 08 Mar 2004 26 | - Setelah menerima banyak saran dan masukan dari pembaca, Saya membuat revisi yang signifikan terhadap isinya, lengkap dengan perbaikan salah ketik. 27 | - 0.99 28 | - 22 Feb 2004 29 | - Tambahan bab baru di modul. Penambahan detail tentang jumlah argumen variabel di dalam fungsi. 30 | - 0.98 31 | - 16 Feb 2004 32 | - Menulis skrip Python dan CSS stylesheet untuk memperbaiki keluaran XHTML, termasuk penganalisis leksikal yang mentah-namun-berfungsi, untuk sorotan sintaks otomatis mirip-Vim terhadap listing program. 33 | - 0.97 34 | - 13 Feb 2004 35 | - Draft penulisan ulang yang baru, dalam format DocBook XML (lagi). Buku ini telah memiliki banyak perbaikan - lebih koheren dan mudah dibaca. 36 | - 0.93 37 | - 25 Jan 2004 38 | - Penambahan pembahasan IDLE dan hal-hal lain khusus Windows. 39 | - 0.92 40 | - 05 Jan 2004 41 | - Perubahan beberapa contoh. 42 | - 0.91 43 | - 30 Des 2003 44 | - Perbaikan salah ketik. Improvisasi terhadap berbagai topik. 45 | - 0.90 46 | - 18 Des 2003 47 | - Tambahan 2 bab. Format [OpenOffice](https://en.wikipedia.org/wiki/OpenOffice) dengan revisi. 48 | - 0.60 49 | - 21 Nov 2003 50 | - Ditulis ulang secara penuh dan dikembangkan lagi materinya. 51 | - 0.20 52 | - 20 Nov 2003 53 | - Perbaikan beberapa salah ketik dan kesalahan program. 54 | - 0.15 55 | - 20 Nov 2003 56 | - Konversi ke format [DocBook XML](https://en.wikipedia.org/wiki/DocBook) dengan XEmacs. 57 | - 0.10 58 | - 14 Nov 2003 59 | - Draf pertama dengan [KWord](https://en.wikipedia.org/wiki/Kword). 60 | -------------------------------------------------------------------------------- /config.json: -------------------------------------------------------------------------------- 1 | { 2 | "SHORT_PROJECT_NAME": "python", 3 | "FULL_PROJECT_NAME": "byte_of_python", 4 | "MARKDOWN_FILES": [ 5 | { 6 | "file": "01-frontpage.pd", 7 | "slug": "python", 8 | "title": "Python" 9 | }, 10 | { 11 | "file": "02-preface.pd", 12 | "slug": "python_en-preface", 13 | "title": "Python : Preface" 14 | }, 15 | { 16 | "file": "03-intro.pd", 17 | "slug": "python_en-introduction", 18 | "title": "Python : Introduction" 19 | }, 20 | { 21 | "file": "04-installation.pd", 22 | "slug": "python_en-installation", 23 | "title": "Python : Installation" 24 | }, 25 | { 26 | "file": "05-first-steps.pd", 27 | "slug": "python_en-first_steps", 28 | "title": "Python : First Steps" 29 | }, 30 | { 31 | "file": "06-basics.pd", 32 | "slug": "python_en-basics", 33 | "title": "Python : Basics" 34 | }, 35 | { 36 | "file": "07-operators-expressions.pd", 37 | "slug": "python_en-operators_and_expressions", 38 | "title": "Python : Operators and Expressions" 39 | }, 40 | { 41 | "file": "08-control-flow.pd", 42 | "slug": "python_en-control_flow", 43 | "title": "Python : Control Flow" 44 | }, 45 | { 46 | "file": "09-functions.pd", 47 | "slug": "python_en-functions", 48 | "title": "Python : Functions" 49 | }, 50 | { 51 | "file": "10-modules.pd", 52 | "slug": "python_en-modules", 53 | "title": "Python : Modules" 54 | }, 55 | { 56 | "file": "11-data-structures.pd", 57 | "slug": "python_en-data_structures", 58 | "title": "Python : Data Structures" 59 | }, 60 | { 61 | "file": "12-problem-solving.pd", 62 | "slug": "python_en-problem_solving", 63 | "title": "Python : Problem Solving" 64 | }, 65 | { 66 | "file": "13-oop.pd", 67 | "slug": "python_en-object_oriented_programming", 68 | "title": "Python : Object Oriented Programming" 69 | }, 70 | { 71 | "file": "14-io.pd", 72 | "slug": "python_en-input_output", 73 | "title": "Python : Input Output" 74 | }, 75 | { 76 | "file": "15-exceptions.pd", 77 | "slug": "python_en-exceptions", 78 | "title": "Python : Exceptions" 79 | }, 80 | { 81 | "file": "16-standard-library.pd", 82 | "slug": "python_en-standard_library", 83 | "title": "Python : Standard Library" 84 | }, 85 | { 86 | "file": "17-more.pd", 87 | "slug": "python_en-more", 88 | "title": "Python : More" 89 | }, 90 | { 91 | "file": "18-what-next.pd", 92 | "slug": "python_en-what_next", 93 | "title": "Python : What Next" 94 | }, 95 | { 96 | "file": "19-appendix-floss.pd", 97 | "slug": "python_en-appendix_floss", 98 | "title": "Python : Appendix : FLOSS" 99 | }, 100 | { 101 | "file": "20-appendix-about.pd", 102 | "slug": "python_en-appendix_about", 103 | "title": "Python : Appendix : About" 104 | }, 105 | { 106 | "file": "21-revision-history.pd", 107 | "slug": "python_en-appendix_revision_history", 108 | "title": "Python : Appendix : Revision History" 109 | }, 110 | { 111 | "file": "22-translations.pd", 112 | "slug": "python_en-translations", 113 | "title": "Python : Appendix : Translations" 114 | }, 115 | { 116 | "file": "23-translation-howto.pd", 117 | "slug": "python_en-translation_howto", 118 | "title": "Python : Appendix : Translation Howto" 119 | } 120 | ] 121 | } 122 | -------------------------------------------------------------------------------- /02-preface.pd: -------------------------------------------------------------------------------- 1 | # Pendahuluan 2 | 3 | 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. Buku ini bertujuan untuk membantu Anda belajar bahasa yang menakjubkan ini dan menunjukkan bagaimana menyelesaikan hal-hal secara cepat tanpa kesulitan - efek dari 'Obat yang Sempurna untuk masalah pemrograman Anda'. 4 | 5 | ## Untuk Siapa Buku ini Ditujukan 6 | 7 | Buku ini dapat digunakan sebagai panduan atau tutorial untuk bahasa pemrograman Python. Target utamanya adalah untuk pemula. Namun juga bermanfaat untuk programmer yang berpengalaman. 8 | 9 | Tujuannya adalah, jika Anda tahu bagaimana menyimpan file teks di komputer, maka Anda dapat belajar Python dari buku ini. Jika Anda punya pengalaman pemrograman sebelumnya, Anda juga dapat belajar Python dari buku ini. 10 | 11 | Jika Anda punya pengalaman pemrograman sebelumnya, Anda akan tertarik melihat perbedaan antara Python dengan bahasa pemrograman favorit Anda - Saya menggarisbawahi cukup banyak perbedaan. Sedikit peringatan, Python akan segera akan menjadi bahasa pemrograman favorit Anda! 12 | 13 | ## Pelajaran Sejarah 14 | 15 | Saya mulai Python pertama kali saat saya perlu installer untuk perangkat lunak yang saya tulis bernama 'Diamond', sehingga instalasi dapat berjalan mudah. Saya harus memilih antara Python dan Perl untuk sebagai tautan pustaka QT. Saya melakukan riset kecil di web, dan menemukan [sebuah artikel oleh Eric S. Raymond](http://pythonology.org/success&story=esr), hacker terkenal dan dihormati, di mana dia bicara bagaimana Python menjadi bahasa pemrograman favoritnya. Saya juga menemukan bahwa tautan PyQT lebih matang dibandingan dengan Perl-QT. Jadi, saya memutuskan Python adalah bahasa untuk saya. 16 | 17 | Kemudian, saya mencarai buku yang bagus tentang Python. Saya tidak dapat menemukannya! Saya temukan beberapa buku O'Reilly, namun kadang terlalu mahal atau seperti petunjuk referensi daripada panduan. Akhirnya saya menggunakan dokumentasi resmi yang ada bersama Python. Bagaimanapun juga, dokumentasi itu terlalu singkat dan kecil. Meskipun memberikan gambaran tentang Python, namun tidak lengkap. Saya bisa mengikutinya karena saya punya latar belakang pemrograman sebelumnya, tapi tentu saja dokumentasi itu tidak cocok untuk pemula. 18 | 19 | Kira-kira setelah enam bulan sejak saya bersentuhan dengan Python, saya menginstal Linux Red Hat 9.0 dan bermain-main dengan KWord. Saya sangat senang menggunakannya, dan secara tiba-tiba saya punya ide untuk menulis beberapa hal tentang Python. Saya mulai menulis beberapa halaman, tapi kemudian berkembang menjadi 30 halaman secara cepat. Lalu, saya mulai serius untuk menjadikannya dalam bentuk buku yang bermanfaat. Saya akan mempertimbangkan buku ini sebagai kontribusi dan penghargaan saya terhadap komunitas open source. 20 | 21 | Buku ini dimulai dari catatan pribadi tentang Python, dan saya masih menganggap seperti itu, meskipun saya mengupayakan banyak hal agar lebih enak untuk yang lainnya :) 22 | 23 | Dalam semangat utama pada open source, saya menerima banyak saran konstruktif, kritik dan [umpan balik](#who-reads-a-byte-of-python) dari pembaca yang antusias yang membantu banyak dalam perbaikan buku ini. 24 | 25 | ## Status Buku 26 | 27 | Buku ini telah diformat ulang di Oktober 2012 menggunakan Pandoc agar memungkinkan untuk dibuat beberapa versi ebook yang disarankan pembaca, bersama perbaikan dan pembaruan. 28 | 29 | Perubahan di edisi Desember 2008 (dari revisi besar di Maret 2005), adalah pembaruan untuk rilis Python 3.0. 30 | 31 | Buku ini butuh bantuan dari pembaca seperti Anda untuk menunjukkan bagian mana dari buku yang tidak bagus, tidak komprehensif, atau salah. Mohon [kirim ke pengarang utama](http:/www.swaroopch.com/contact/) atau [penerjemah](#terjemahan) dengan komentar dan saran. 32 | 33 | ## Situs Web Resmi 34 | 35 | Situs web resmi dari buku ini adalah di mana Anda dapat membaca seluruh buku secara online, mengunduh versi terakhir dari buku, [membeli versi cetak](http://www.swaroopch.com/buybook), dan mengirimkan umpan balik kepada saya. 36 | 37 | ## Sesuatu Untuk Dipikirkan 38 | 39 | > Ada dua cara untuk mengonstruksi desain perangkat lunak: cara pertama adalah membuatnya sederhana sehingga jelas tidak ada kekurangan; atau membuatnya secara rumit sehingga tidak ada kekurangan yang jelas. 40 | > 41 | > -- C. A. R. Hoare 42 | 43 | 44 | 45 | > Keberhasilan hidup tidak banyak kaitannya terhadap bakat dan kesempatan, melainkan konsentrasi dan ketekunan. 46 | > 47 | > -- C. W. Wendte 48 | -------------------------------------------------------------------------------- /04-installation.pd: -------------------------------------------------------------------------------- 1 | # Instalasi 2 | 3 | ## Instalasi di Windows 4 | 5 | Kunjungi dan unduh versi terakhir. Instalasi akan dilakukan sebagaimana perangkat lunak berbasis Windows lainnya. 6 | 7 | Perhatian 8 | 9 | : Ketika diberi pilihan untuk menghilangkan centang komponen "optional", jangan melakukan hilangkan centangnya. 10 | 11 | ### Prompt DOS 12 | 13 | Jika Anda ingin menggunakan Python dari baris perintah Windows seperti prompt DOS, Anda harus set variabel PATH secara benar. 14 | 15 | 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. 16 | 17 | 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`. 18 | 19 | Untuk Windows Vista: 20 | 21 | #. Klik Start dan pilih Control Panel 22 | #. Klik Sistem, di bagian kanan Anda akan lihat “View basic information about your computer” 23 | #. Di bagian kiri daftar tasks, muncul “Advanced system settings.” Silakan diklik. 24 | #. Tab Advance dari kotak dialog System Properties akan muncul. Klik tombol Environment Variable di bagian kanan bawah. 25 | #. Di kotak bawah berjudul "System Variables" gulung layar ke Path dan klik tombol Edit. 26 | #. Ganti path sesuai yang dibutuhkan (lihat referensi sebelumnya). 27 | #. Nyalakan kembali sistem Anda. Vista tidak akan mengambil perubahan variable lingkungan path sistem hingga dinyalakan kembali. 28 | 29 | Untuk Windows 7: 30 | 31 | #. 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. 32 | #. Pergi ke akhir baris di bawah nilai Variable dan tambahkan `;C:\Python33`. 33 | #. Jika nilai sebelumnya adalah `%SystemRoot%\system32;` maka sekarang akan menjadi `%SystemRoot%\system32;C:\Python33` 34 | #. Tekan ok dan selesai. Tidak perlu dinyalakan ulang. 35 | 36 | ### Menjalankan prompt Python di Windows 37 | 38 | Untuk pengguna Windows, Anda dapat menjalankan interpreter di baris perintah jika diperlukan [set variabel `PATH` dengan benar](#dos-prompt). 39 | 40 | Untuk membuka terminal di Windows, klik tombol Start dan klik 'Run'. Di kotak dialog, ketik `cmd` dan tekan enter. 41 | 42 | Lalu ketik `python3 -V` dan pastikan tidak ada pesan kesalahan. 43 | 44 | ## Instalasi di Mac OS X 45 | 46 | Untuk pengguna Mac OS X, buka terminal dengan menekan tombol `Command+Space` (untuk membuka pencarian Spotlight), ketik `Terminal` dan tekan tombol enter. 47 | 48 | Install [Homebrew](http://mxcl.github.com/homebrew/) dengan menjalankan: 49 | 50 | ~~~ 51 | ruby -e "$(curl -fsSkL raw.github.com/mxcl/homebrew/go)" 52 | ~~~ 53 | 54 | Lalu instal Python 3 dengan menggunakan: 55 | 56 | ~~~ 57 | brew install python3 58 | ~~~ 59 | 60 | Lalu, jalankan `python3 -V` dan pastikan tidak ada pesan kesalahan. 61 | 62 | ## Instalasi di Linux 63 | 64 | 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. 65 | 66 | Selanjutnya, kita menginstal paket `python3`. Sebagai contoh, di Ubuntu, Anda bisa menjalankan [`sudo apt-get install python3`](http://packages.ubuntu.com/search?keywords=python3&searchon=names&suite=all§ion=all). Silakan cek dokumentasi atau forum sesuai dengan distribusi Linux yang Anda gunakan untuk menjalankan perintah manajer paket yang sesuai. 67 | 68 | Setelah Anda menyelesaikan instalasi, jalankan perintah `python3 -V` dan Anda seharusnya melihat versi Python di layar: 69 | 70 | ~~~ 71 | $ python3 -V 72 | Python 3.3.0 73 | ~~~ 74 | 75 | Catatan 76 | 77 | : `$` 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. 78 | 79 | Baku versi baru di distribusi Anda? 80 | 81 | : Distribusi lebih baru seperti [Ubuntu 12.10 menggunakan Python 3 sebagai versi baku](https://wiki.ubuntu.com/Python/3), jadi cek terlebih dahulu sebelum melakukan langkah instalasi. 82 | 83 | ## Ringkasan 84 | 85 | Sejak sekarang, saya sudah mengasumsikan Anda punya Python 3 terinstal di sistem Anda. 86 | 87 | Berikutnya, kita akan menulis program Python 3 pertama kita. 88 | -------------------------------------------------------------------------------- /19-appendix-floss.pd: -------------------------------------------------------------------------------- 1 | # FLOSS 2 | 3 | _Free/Libre and Open Source Software_ atau Perangkat Lunak Bebas/Kode Program Terbuka, disingkat sebagai, [FLOSS](http://en.wikipedia.org/wiki/FLOSS) adalah sebuah konsep yang berlandaskan komunitas, yang berarti di dalamnya ada konsep berbagi, terutama berbagi pengetahuan. FLOSS bebas untuk digunakan, dimodifikasi dan didistribusikan kembali. 4 | 5 | Jika Anda sudah selesai membaca buku ini, maka Anda seharusnya sudah tidak begitu asing lagi dengan istilah FLOSS, mengingat Anda telah menggunakan **Python** dan Python merupakan Perangkat Lunak Bebas! 6 | 7 | Berikut beberapa contoh FLOSS untuk memberikan gambaran kepada Anda tentang bagaimana komunitas yang saling berbagi dalam membangun sesuatu dapat membuat: 8 | 9 | [Linux](http://www.kernel.org) 10 | 11 | : Inti (Kernel) sistem operasi FLOSS yang digunakan pada sistem operasi GNU/Linux. Linux, kernelnya, dimulai pembuatannya oleh Linus Torvalds semasa dia menjadi mahasiswa. Android dikembangkan berbasis Linux. Setiap website yang Anda kunjungi akhir-akhir ini, hampir semuanya dijalankan di atas Linux. 12 | 13 | [Ubuntu](http://www.ubuntu.com) 14 | 15 | : Distribusi yang dikembangkan berbasis komunitas, disponsori oleh Canonical, dan saat ini Ubuntu merupakan distribusi Linux yang paling terkenal di antara pengguna umum saat ini. Ubuntu memungkinkan Anda menginstal berbagai macam perangkat lunak bebas (FLOSS) yang tersedia, dengan cara yang mudah digunakan dan mudah diinstal. Yang lebih bagus lagi, Anda dapat menyalakan ulang komputer dan langsung menjalankan GNU/Linux dari CD! Hal ini memungkinkan Anda mencoba sistem operasi baru sebelum menginstalnya di komputer Anda. Bagaimanapun juga, Ubuntu tidak sepenuhnya perangkat lunak bebas; Beberapa diantaranya merupakan perangkat lunak tertutup seperti drivers, firmware dan beberapa aplikasi. 16 | 17 | [LibreOffice](http://www.libreoffice.org/) 18 | 19 | : Program ini merupakan program aplikasi kantor lengkap dan baik, dikembangkan oleh komunitas. Di dalamnya sudah termasuk program pengolah kata, presentasi, lembar kerja dan komponen aplikasi untuk menggambar, serta mampu membuka dan mengolah aplikasi perkantoran MS Word dan MS PowerPoint dengan mudah. LibreOffice dapat dijalankan di hampir semua platform dan seluruhnya bersifat bebas, gratis dan berkode program terbuka. 20 | 21 | [Mozilla Firefox](http://www.mozilla.org/products/firefox) 22 | 23 | : Dapat dikatakan bahwa Mozilla Firefox adalah salah satu peramban web terbaik. Sangat cepat digunakan dan telah memperoleh pengakuan penuh untuk fitur-fiturnya yang bermanfaat dan impresif. Peramban ini memiliki konsep ekstensi, yang memungkinkan pengembang di seluruh dunia membuat semacam plugin untuk dipasangkan di ekstensi Firefox. 24 | 25 | Produk rekanannya, [Thunderbird](http://www.mozilla.org/products/thunderbird) merupakan program pembaca email yang bagus yang memungkinkan pembacaan email secara cepat. 26 | 27 | [Mono](http://www.mono-project.com) 28 | 29 | : Proyek ini merupakan implementasi platform .NET dari Microsoft dalam format kode terbuka. Dengan adanya Mono, aplikasi .NET dapat dibuat dan dijalankan pada sistem operasi GNU/Linux,Windows, FreeBSD, Mac OS dan platform lainnya. 30 | 31 | [Server web Apache](http://httpd.apache.org) 32 | 33 | : Aplikasi yang paling populer sebagai server web berkode terbuka. Faktanya, Apache adalah server web *paling populer* di planet ini! Program ini dijalankan lebih dari setengah situs web yang ada di luar sana. Ya, benar - Apache melayani permintaan situs web lebih banyak daripada gabungan seluruh kompetitor lain (termasuk Microsoft IIS). 34 | 35 | [Pemutar Multimedia VLC](http://www.videolan.org/vlc/) 36 | 37 | : Aplikasi ini merupakan pemutar video yang dapat menjalankan format apa saja, mulai dari DivX ke MP3, dari VCD hingga DVD dan.. siapa yang bilang kode terbuka nggak seru? ;-) 38 | 39 | Daftar ini dibuat dengan tujuan untuk memberi Anda gambaran singkat - ada lebih banyak lagi perangkat lunak berkode terbuka di luar sana, seperti bahasa Perl, PHP, sistem pengelolaan konten (CMS) Drupal, server database PostgreSQL, permainan balapan TORCS, IDE Kdevelop, pemutar video Xine, editor teks VIM, editor teks Quanta+, pemutar audio Banshee, pengedit gambar GIMP, ... dan seterusnya. Daftar ini bisa bertambah tak ada habisnya. 40 | 41 | Untuk memperoleh kabar terbaru dari dunia FLOSS (perangkat lunak berkode terbuka), lihat beberapa situs web di bawah ini: 42 | 43 | - [linux.com](http://www.linux.com) 44 | - [LinuxToday](http://www.linuxtoday.com) 45 | - [NewsForge](http://www.newsforge.com) 46 | - [DistroWatch](http://www.distrowatch.com) 47 | 48 | Kunjungi juga beberapa situs web berikut untuk gambaran lebih lanjut tentang FLOSS: 49 | 50 | - [GitHub Explore](http://github.com/explore) 51 | - [OMG! Ubuntu!](http://www.omgubuntu.co.uk) 52 | - [SourceForge](http://www.sourceforge.net) 53 | - [FreshMeat](http://www.freshmeat.net) 54 | 55 | Jadi, silakan ekplorasi dunia yang bebas dan terbuka dari FLOSS! 56 | -------------------------------------------------------------------------------- /16-standard-library.pd: -------------------------------------------------------------------------------- 1 | # Pustaka Standar 2 | 3 | Pustaka Standar Python berisi banyak sekali modul-modul yang bermanfaat dan merupakan bagian baku instalasi standar Python. Sangat penting bagi Anda untuk membiasakan diri dengan pustaka standar Python, mengingat banyak permasalahan yang bisa diselesaikan dengan cepat jika Anda sudah terbiasa dengan hal-hal yang bisa dilakukan oleh pustaka standar Python. 4 | 5 | Kita akan menjelajahi beberapa penggunaan modul yang umum dalam pustaka ini. Anda dapat memperoleh informasi lengkap dari modul-modul Pustaka Standar Python di dokumentasi yang dibundel bersama instalasi Python Anda di [ bagian 'Referensi Pustaka'](http://docs.python.org/py3k/library/index.html). 6 | 7 | Mari kita lihat beberapa modul yang bermanfaat 8 | 9 | Catatan 10 | 11 | : Jika Anda temukan topik di bab ini perlu pemahaman tingkat lanjut, Anda bisa abaikan bab ini. Bagaimanapun juga, saya rekomendasikan Anda untuk kembali ke bab ini jika Anda sudah merasa nyaman melakukan pemrograman dengan Python. 12 | 13 | ## modul sys 14 | 15 | Modul sys berisi fungsi-fungsi yang spesifik berkaitan dengan sistem. Kita telah melihat sebelumnya daftar `sys.argv` berisi argumen baris perintah. 16 | 17 | Anggap kita ingin mengecek versi Python yang sedang kita gunakan, misalnya, untuk memastikan kita menggunakan paling tidak versi 3. Modul `sys` akan memberikan fungsi tersebut. 18 | 19 | ~~~ 20 | $ python3 21 | >>> import sys 22 | >>> sys.version_info 23 | sys.version_info(major=3, minor=3, micro=0, releaselevel='final', serial=0) 24 | >>> sys.version_info.major >= 3 25 | True 26 | ~~~ 27 | 28 | Bagaimana Cara Kerjanya: 29 | 30 | Modul `sys` memiliki tuple `version_info` yang memberikan informasi tentang versi yang digunakan. Isian pertama berisi versi besar (_major version_). Kita dapat mengecek ini, sebagai contoh, untuk memastikan program hanya berjalan di bawah Python versi 3.0. 31 | 32 | Simpan dengan nama `versioncheck.py`: 33 | 34 | ~~~python 35 | import sys, warnings 36 | if sys.version_info.major < 3: 37 | warnings.warn("Butuh Python 3.0 untuk menjalankan program ini", 38 | RuntimeWarning) 39 | else: 40 | print('Program dijalankan secara normal') 41 | ~~~ 42 | 43 | Keluaran: 44 | 45 | ~~~ 46 | $ python2.7 versioncheck.py 47 | versioncheck.py:6: RuntimeWarning: Butuh Python 3.0 untuk menjalankan program ini 48 | RuntimeWarning) 49 | 50 | $ python3 versioncheck.py 51 | Program dijalankan secara normal 52 | ~~~ 53 | 54 | Bagaimana Cara Kerjanya: 55 | 56 | Kita menggunakan modul dari pustaka standar dengan nama `warnings` yang digunakan untuk menampilkan pesan kesalahan kepada pengguna. Jika versi Python yang digunakan kurang dari 3, kita akan tampilkan pesan kesalahan terkait. 57 | 58 | ## Modul penyimpan pesan (_logging_) 59 | 60 | Bagaimana jika Anda ingin menyimpan pesan _debugging_ atau pesan penting dari program dan ingin disimpan di suatu tempat sehingga Anda dapat mengecek apakah program berjalan sebagaimana yang Anda harapkan? Bagaimana "menyimpan pesan-pesan ini di suatu tempat"? Ini dapat dicapai dengan menggunakan modul _logging_. 61 | 62 | Simpan sebagai `gunakan_logging.py`: 63 | 64 | ~~~python 65 | import os, platform, logging 66 | 67 | if platform.platform().startswith('Windows'): 68 | berkas_logging = os.path.join(os.getenv('HOMEDRIVE'), os.getenv('HOMEPATH'), 'test.log') 69 | else: 70 | berkas_logging = os.path.join(os.getenv('HOME'), 'test.log') 71 | 72 | print("Logging ke", berkas_logging) 73 | 74 | logging.basicConfig( 75 | level=logging.DEBUG, 76 | format='%(asctime)s : %(levelname)s : %(message)s', 77 | filename = logging_file, 78 | filemode = 'w', 79 | ) 80 | 81 | logging.debug("Memulai program") 82 | logging.info("Mengerjakan sesuatu") 83 | logging.warning("Matikan sekarang") 84 | ~~~ 85 | 86 | Keluaran: 87 | 88 | ~~~ 89 | $ python3 gunakan_logging.py 90 | Logging ke C:\Users\swaroop\test.log 91 | ~~~ 92 | 93 | Jika kita memeriksa isi dari `test.log`, akan terlihat seperti ini: 94 | 95 | ~~~ 96 | 2012-10-26 16:52:41,339 : DEBUG : Memulai program 97 | 2012-10-26 16:52:41,339 : INFO : Mengerjakan sesuatu 98 | 2012-10-26 16:52:41,339 : WARNING : Matikan sekarang 99 | ~~~ 100 | 101 | Bagaimana Cara Kerjanya: 102 | 103 | Kita menggunakan tiga modul dari pustaka standar - modul `os` untuk interaksi dengan sistem operasi, modul `platform` untuk mencari informasi tentang platform - sistem operasi dan modul `logging` untuk menyimpan pesan dan informasi. 104 | 105 | Pertama, kita cek sistem operasi apa yang kita gunakan dengan mencatat string kembalian dari fungsi `platform.platform()` (untuk informasi lebih lanjut, jalankan `import platforml help(platform)). Jika Windows, kita cari tahu _drive_ (bagian dari _harddisk_ yang digunakan), mencari folder rumah dan nama berkas tempat kita menyimpan informasi. Dengan menyatukan ketiga informasi tersebut bersama-sama, kita akan mendapatkan lokasi lengkap dari berkas. Untuk platform lain, kita hanya perlu tahu folder rumah dari pengguna yang bersangkutan, dan kita akan mendapatkan lokasi lengkap dari berkas yang dituju. 106 | 107 | Kita gunakan fungsi `os.path.join()` untuk menyatukan ketiga hal di atas bersamaan. Alasan penggunaan fungsi khusus untuk menyatukan string tersebut bersama-sama, sebab fungsi ini akan memastikan lokasi lengkapnya (separator/pemisah antar folder) sesuai dengan format yang diharapkan oleh sistem operasi. 108 | 109 | Kita konfigurasikan modul `logging` untuk menuliskan seluruh pesan dalam format khusus yang telah kita tentukan sebelumnya. 110 | 111 | Terakhir, kita dapat menuliskan pesan hanya untuk debugging, informasi atau pesan kesalahan, bahkan pesan kesalahan yang bersifat kritis. Sekali program berjalan, kita dapat melihat berkas ini dan kita tahu apa yang terjadi di dalam program, meskipun tidak ada informasi yang ditampilkan di depan pengguna langsung. 112 | 113 | ## Seri Modul Mingguan 114 | 115 | Ada lebih banyak pustaka standar yang bisa dieksplorasi seperti [debugging](http://docs.python.org/py3k/library/pdb.html), [penanganan pilihan baris perintah](http://docs.python.org/py3k/library/argparse.html), [ekspresi reguler](http://docs.python.org/py3k/library/re.html) dan lain-lain. 116 | 117 | Cara terbaik untuk mengeksplorasi pustaka standar lebih lanjut adalah dengan membaca seri terbaik dari Doug Hellmann [Modul Mingguan Python](http://www.doughellmann.com/projects/PyMOTW/) atau langsung membaca [Dokumentasi Python](http://docs.python.org/py3k/). 118 | 119 | ## Ringkasan 120 | 121 | Kita telah menjelajahi beberapa fungsi dari banyak modul yang ada dalam Pustaka Standar Python. Sangat dianjurkan untuk menelusuri lebih lanjut lewat [Pustaka Standar Python](http://docs.python.org/py3k/library/index.html) untuk mengetahui modul-modul apa yang tersedia. 122 | 123 | Berikutnya, kita akan membahas berbagai macam aspek dari Python yang akan membuat tur Python kita lebih *lengkap*. 124 | -------------------------------------------------------------------------------- /14-io.pd: -------------------------------------------------------------------------------- 1 | # Masukan Keluaran 2 | 3 | Akan ada kondisi di mana program Anda harus berinteraksi dengan pengguna. Misalnya, Anda ingin mengambil masukan dari pengguna dan mencetak hasilnya. Kita dapat melakukan hal ini dengan menggunakan fungsi `input()` dan `print()` secara bersamaan. 4 | 5 | Untuk keluaran, kita juga bisa menggunakan berbagai macam metode klas `str` (string). Sebagai contoh, Anda dapat memanfaatkan metode `rjust` untuk menampilkan layar rata kanan dengan ukuran khusus. Lihat `help(str)` untuk informasi lebih detail. 6 | 7 | Jenis masukan dan keluaran yang umum lainnya adalah dalam penggunaan berkas (_file_). Kemampuan untuk membuat, membaca dan menulis berkas sangat penting dalam sebuah program, dan kita akan mengeksplorasi aspek tersebut di bab ini. 8 | 9 | ## Masukan dari Pengguna 10 | 11 | Simpan program ini dengan nama `masukan_pengguna.py`: 12 | 13 | ~~~python 14 | def putarbalik(teks): 15 | return text[::-1] 16 | 17 | def ini_palindrom(teks): 18 | return text == putarbalik(teks) 19 | 20 | sesuatu = input('Masukkan teks: ') 21 | if (ini_palindrom(sesuatu)): 22 | print("Ya, ini palindrom") 23 | else: 24 | print("Tidak, ini bukan palindrom") 25 | ~~~ 26 | 27 | Keluaran: 28 | 29 | ~~~ 30 | $ python3 masukan_pengguna.py 31 | Masukkan teks: sir 32 | Tidak, ini bukan palindrom 33 | 34 | $ python3 masukan_pengguna.py 35 | Masukkan teks: madam 36 | Ya, ini palindrom 37 | 38 | $ python3 masukan_pengguna.py 39 | Masukkan teks: racecar 40 | Ya, ini palindrom 41 | ~~~ 42 | 43 | Bagaimana Cara Kerjanya: 44 | 45 | Kita menggunakan fitur pemotongan untuk membalikkan teks. Kita sudah pelajari sebelumnya tentang bagaimana cara membuat [potongan dari urutan](#sequence) dengan menggunakan `seq[a:b]` mulai dari posisi `a` hingga posisi `b`. Kita juga dapat memberikan argumen ketiga yang menentukan berapa banyak *langkah* yang diperlukan agar proses pemotongan selesai. Langkah bakunya adalah `1` yang akan memberikan hasil berurutan dari sebuah teks. Dengan memberi langkah negatif, seperti `-1` akan mengembalikan teks dalam urutan terbalik. 46 | 47 | Fungsi `input()` mengambil argumen string dan menampilkannya langsung kepada pengguna. Kemudian ia menunggu pengguna mengetikkan sesuatu dan menekan tombol enter/return. Jika pengguna sudah memasukkan teks dan menekan tombol enter/return, fungsi `input()` akan mengmbalikan teks yang telah ditulis sebelumnya oleh pengguna. 48 | 49 | Kemudian kita ambil teks tersebut dan kita balik. Jika teks asli dan teks balikannya sama, maka teks tersebut dikategorikan sebagai [palindrom]([http://en.wiktionary.org/wiki/palindrome). 50 | 51 | Pekerjaan Rumah 52 | 53 | : Mengecek apakah sebuah teks palindrom atau bukan, juga harus mengabaikan tanda baca, spasi, dan huruf besar kecil. Misalnya "Rise to vote, sir." juga palindrom namun program yang kita buat sebelumnya tidak mengenalinya sebagai palindrom. Dapatkah Anda memperbaiki program di atas sehingga dapat mengenali teks palindrom tersebut? 54 | 55 | *Petunjuk (Jangan dibaca) di bawah* 56 | 57 | Gunakan tuple (Anda dapat temukan *seluruh* tanda baca di sini [tanda baca](http://grammar.ccc.commnet.edu/grammar/marks/marks.htm)) untuk tempat penyimpanan seluruh karakter yang tidak kita inginkan, kemudian kita gunakan tes keikutsertaan untuk memastikan apakah sebeuah karakter dihapus atau tidak, dengan kata lain dilarang = ('!', '?', '.', ...). 58 | 59 | ## Berkas 60 | 61 | Anda dapat membaca atau menulis berkas dengan membuat objek dari kelas `file` dan menggunakan metode di dalamnya seperti `read`, `readline` atau `write` untuk membaca, membaca tiap baris, atau menulis ke dalam berkas tersebut. Kemampuan untuk membaca atau menulis sebuah berkas, tergantung mode yang Anda gunakan saat membuka sebuah berkas. Setelah menyelesaikan semua yang Anda inginkan pada berkas tersebut, Anda dapat memanggil metode `close` untuk memberitahu Python bahwa kita sudah selesai menggunakan berkas tersebut. 62 | 63 | Contoh (simpan sebagai `guna_berkas.py`): 64 | 65 | ~~~python 66 | puisi = '''\ 67 | Programming menyenangkan 68 | Saat pekerjaan terselesaikan 69 | jika kamu ingin kerja menyenangkan: 70 | gunakan Python! 71 | ''' 72 | 73 | f = open('puisi.txt', 'w') # membuka berkas dengan mode 'w' (writing/menulis) 74 | f.write(puisi) # menulis teks ke dalam berkas 75 | f.close() # menutup berkas 76 | 77 | f = open('puisi.txt') # jika tidak menentukan mode, diasumsikan secara baku dengan mode 'r' (read/baca) 78 | while True: 79 | line = f.readline() 80 | if len(line) == 0: # Panjang nol mengindikasikan EOF (_End Of File_/akhir berkas) 81 | break 82 | print(line, end='') 83 | f.close() # tutup berkas 84 | ~~~ 85 | 86 | Keluaran: 87 | 88 | ~~~ 89 | $ python3 guna_berkas.py 90 | Programming menyenangkan 91 | Saat pekerjaan terselesaikan 92 | jika kamu ingin kerja menyenangkan: 93 | gunakan Python! 94 | ~~~ 95 | 96 | Bagaimana Cara Kerjanya: 97 | 98 | Pertama, buka berkas dengan fungsi `open` yang sudah ada, dan tentukan nama berkas beserta mode yang kita gunakan saat membuka berkas. Mode ini dapat berupa mode baca (_read_/`'r'`), mode tulis (_write_/`'w'`), atau mode sisip (_append_/`'a'`). Kita juga dapat tentukan saat membaca, menulis atau menyisipkan dalam mode teks (`'t'`) atau mode biner (`'b'`). Sebetulnya ada banyak mode tersedia, dan untuk melihatnya secara detail Anda cukup ketikkan `help(open)`. Secara baku, `open()` dibuka dalam format teks ('t') dan mode baca ('r'). 99 | 100 | Dalam contoh kita, berkas dibuka dalam mode tulis teks dengan mode `write`, lalu kita tutup berkas dengan mode `close`. 101 | 102 | Berikutnya, kita buka lagi berkas yang sama untuk dibaca. Kita tidak perlu menentukan mode secara khusus sebba `membaca berkas teks` adalah mode baku. Lalu kita baca tiap baris yang ada di dalamnya dengan menggunakan metode `readline` dalam sebuah putaran. Metode ini akan mengembalikan satu beris penuh, termasuk karakter ganti baris di akhir baris. Saat string *kosong* dikembalikan, ini berarti kita sudah mencapai akhir berkas dan kita menghentikan ('break') putaran. 103 | 104 | Secara baku, fungsi `print()` juga akan mencetak teks di layar, termasuk otomatis pindah baris. Kita menghapus karakter baris baru yang ada di teks, dengan menambahkan `end=''` sebab baris yang dibaca dari berkas sendiri sudah memiliki karakter ganti baris. Tanpa ini akan mencetak ganti baris dua kali. Dan akhirnya, kita `menutup` berkas. 105 | 106 | Sekarang, periksa kembali isi dari `puisi.txt` untuk konfirmasi bahwa program sudah benar menulis dan membaca dari berkas tersebut. 107 | 108 | ## Pickle 109 | 110 | Python memberikan modul standar bernama `picke` di mana Anda dapat menyimpan objek **apa saja** ke dalam sebuah berkas, lalu memanfaatkannya kemudian. Ini dinamakan menyimpan objek secara *persisten*. 111 | 112 | Contoh (simpan sebagai `pickling.py`): 113 | 114 | ~~~python 115 | import pickle 116 | 117 | # nama berkas tempat objek akan disimpan 118 | berkasdaftarbelanja = 'daftarbelanja.data' 119 | # barang-barang yang akan dibeli 120 | daftarbelanja = ['apel', 'mangga', 'wortel'] 121 | 122 | # Menulis ke dalam berkas 123 | f = open(berkasdaftarbelanja, 'wb') 124 | pickle.dump(daftarbelanja, f) # buang objek ke dalam berkas 125 | f.close() 126 | 127 | del daftarbelanja # hapus variabel daftarbelanja 128 | 129 | # Baca kembali dari penyimpanan 130 | f = open(berkasdaftarbelanja, 'rb') 131 | daftarsimpan = pickle.load(f) # muat objek dari berkas 132 | print(daftarsimpan) 133 | ~~~ 134 | 135 | Keluaran: 136 | 137 | ~~~ 138 | $ python3 pickling.py 139 | ['apel', 'mangga', 'wortel'] 140 | ~~~ 141 | 142 | Bagaimana Cara Kerjanya: 143 | 144 | Untuk menyimpan objek ke dalam berkas, pertama kita harus `buka` berkas dalam mode `w` (tulis) dan `b` (format biner), kemudiapn panggil fungsi `dump` dari modul `pickle`. Proses ini dinamakan *pickling*. 145 | 146 | Kemudian, kita ambil objek dengan menggunakan fungsi `load` dari modul `pickle` yang mengembalikan objek. Proses ini dinamakan *unpickling*. 147 | 148 | ## Ringkasan 149 | 150 | Kita telah mendiskusikan berbagai jenis input/output, penanganan berka dan modul pickle. 151 | 152 | Berikutnya, kita akan jelajahi konsep eksepsi (_excpetions_). 153 | -------------------------------------------------------------------------------- /03-intro.pd: -------------------------------------------------------------------------------- 1 | # Pengenalan 2 | 3 | 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 permasalahan daripada dipusingkan dengan sintaks dan struktur dari bahasa pemrograman yang Anda gunakan. 4 | 5 | Secara resmi Python dikenalkan dengan definisi sebagai berikut: 6 | 7 | > 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. 8 | 9 | Saya akan mendiskusikan sebagian besar fitur-fitur ini di bagian berikutnya. 10 | 11 | Cerita di balik nama 12 | 13 | : 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. 14 | 15 | ## Fitur Python 16 | 17 | ### Sederhana 18 | 19 | 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. 20 | 21 | ### Mudah Dipelajari 22 | 23 | Seperti yang akan Anda lihat, Python sangat mudah untuk dimulai. Python juga memiliki sintaks yang luar biasa mudah, seperti telah disebutkan sebelumnya. 24 | 25 | ### Bebas dan Open Source 26 | 27 | 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. 28 | 29 | ### Bahasa Tingkat-Tinggi 30 | 31 | 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. 32 | 33 | ### Portabel 34 | 35 | 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. 36 | 37 | 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! 38 | 39 | Anda dapat pula menggunakan platform seperti [Kivy](http://kivy.org/) untuk membuat game di iOS (iPhone, iPad) dan Android. 40 | 41 | ### Diinterpretasikan (Interpreted) 42 | 43 | Tentang hal ini perlu sedikit penjelasan. 44 | 45 | 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. 46 | 47 | 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! 48 | 49 | ### Berorientasi Objek 50 | 51 | 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. 52 | 53 | ### Dapat diperluas (Extensible) 54 | 55 | 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. 56 | 57 | ### Dapat disematkan (Embeddable) 58 | 59 | Anda dapat menyematkan Python ke dalam program C/C++ untuk memberi kemampuan 'scripting' bagi pengguna program Anda. 60 | 61 | ### Pustaka yang Ekstensif 62 | 63 | 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). 64 | 65 | Disamping pustaka standar, ada banyak pustaka berkualitas tinggi lainnya yang dapat Anda temukan di [Python Package Index](http://pypi.python.org/pypi). 66 | 67 | Ringkasan 68 | 69 | : 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. 70 | 71 | ## Python 2 versus 3 72 | 73 | Anda dapat mengabaikan bagian ini jika Anda tidak tertarik perbedaan antara Python 2 dan 3. Tapi mohon perhatikan versi Python yang Anda gunakan. 74 | 75 | Buku ini ditulis ulang di tahun 2008 untuk Python 3. Ini adalah buku pertama yang menggunakan Python 3. Hal ini, sayangnya, menyebabkan kebingungan bagi pembaca yang mencoba menggunakan Python 2 dengan contoh Python 3 di buku dan sebaliknya. Tapi lambat laun, dunia masih migrasi ke Python 3. 76 | 77 | Jadi, ya, Anda akan belajar menggunakan Python 3 di buku ini, meskipun Anda sangat ingin menggunakan Python 2. *Ingat bahwa sekali Anda paham dan belajar dengan benar terhadap keduanya, Anda dapat lebih mudah belajar perbedaan dari dua versi tersebut dan beradaptasi dengan mudah. Bagian paling sulit adalah belajar pemrograman dan belajar inti dari bahasa Python itu sendiri. Inilah tujaun buku ini, sekali Anda meraih tujuan itu, Anda dapat dengan mudah menggunakan Python 2 atau Python 3 tergantung dari situasi.* 78 | 79 | Untuk detail perbedaan Antara Python 2 dan Python 3 lihat [halaman Python/3 di wiki Ubuntu](https://wiki.ubuntu.com/Python/3). 80 | 81 | ## Apa yang Programmer Katakan 82 | 83 | Mungkin Anda tertarik hacker besar seperti ESR mengatakan sesuatu tentang Python: 84 | 85 | (@) *Eric S. Raymond* adalah pengarang buku "The Cathedral and the Bazaar" dan juga orang yang pertama kali mengenalkan istilah *Open Source*. Dia mengatakan bahwa [Python telah menjadi bahasa pemrogaman favoritnya](http://www.linuxjournal.com/article.php?sid=3882). Artikel ini merupakan inspirasi utama dari keinginan saya untuk bekerja menggunakan Python. 86 | 87 | (@) *Bruce Eckel* adalah pengarang terkenal dari buku *Thinking in Java* dan *Thinking in C++*. Dia mengatakan tidak ada bahasa pemrograman yang bisa membuatnya lebih produktif selain Python. Dia bilang bahwa Python barangkali satu-satunya bahasa yang menitikberatkan pada membuat hal-hal yang lebih mudah bagi programmer. Baca [wawancara lengkapnya](http://www.artima.com/intv/aboutme.html) untuk informasi lebih detail. 88 | 89 | (@) *Peter Norvig* adalah pengarang terkenal dari bahasa Lisp dan Direktur Kualitas Pencarian di Google (terimakasih untuk Guido van Rossum telah menunjukkannya). Dia mengatakan bahwa Python merupakan bagian integral dari Google. Anda dapat memverifikasi pernyataan ini dengan melihat halaman [Google Jobs](http://www.google.com/jobs/index.html) yang mendaftar pengetahuan Python sebagai syarat utama dari programmer perangkat lunak. 90 | -------------------------------------------------------------------------------- /01-frontpage.pd: -------------------------------------------------------------------------------- 1 | % A Byte of Python 2 | % Swaroop C H 3 | % $$date$$ 4 | 5 | # A Byte of Python 6 | 7 | 'A Byte of Python' adalah buku gratis tentang pemrograman dalam bahasa Python. Buku ini dibuat dalam format tutorial atau panduan bagi pemula. Jika yang Anda ketahui tentang komputer adalah bagaimana menyimpan berkas-berkas teks, maka buku ini cocok untuk Anda. 8 | 9 | Buku ini ditulis minimal untuk Python 3, meskipun Python 2 lebih lazim digunakan untuk saat ini (baca lebih lanjut tentang hal ini [Python 2 lawan Python 3](#python-2-versus-3)) 10 | 11 | ## Siapa Pembaca A Byte of Python? 12 | 13 | Berikut kutipan beberapa orang tentang buku ini: 14 | 15 | > Hal terbaik yang saya temukan adalah "A Byte of Python", merupakan buku sederhana yang sangat cocok bagi pemula. Buku ini ditulis dengan baik, konsep dijelaskan saksama dengan contoh yang bisa dibuktikan langsung. 16 | > 17 | > -- [_Syed Talal_ (19 years old)](http://littlepancakes.wordpress.com/2010/01/30/python) 18 | 19 | > 20 | 21 | > Ini adalah tutorial terbaik bagi pemula yang pernah saya baca! Terima kasih atas upaya Anda. 22 | > 23 | > -- _Walt Michalik_ (wmich50-at-theramp-dot-net) 24 | 25 | > 26 | 27 | > Anda membuat tutorial Python terbaik yang pernah saya temukan di Internet. Hasil karya yang baik. Terima kasih! 28 | > 29 | > -- _Joshua Robin_ (joshrob-at-poczta-dot-onet-dot-pl) 30 | 31 | > 32 | 33 | > Pengantar yang ringan dan sempurna untuk pemrograman #Python bagi pemula 34 | > 35 | > -- [Shan Rajasekaran](https://twitter.com/ShanRajasekaran/status/268910645842423809) 36 | 37 | > 38 | 39 | > Hai, Saya dari Republik Dominika. Nama saya Pavel, dan baru-baru ini saya baca buku Anda 'A Byte of Python' dan saya pikir buku Anda bagus sekali!! :). Saya belajar banyak dari contoh-contoh yang ada. Buku Anda penolong terbaik untuk pemula seperti saya... 40 | > 41 | > -- _Pavel Simo_ (pavel-dot-simo-at-gmail-dot-com) 42 | 43 | > 44 | 45 | > Saya baru saja selesai membaca Byte of Python, dan saya pikir saya harus berterima kasih kepada Anda. Saya sangat sedih saat membaca halaman terakhir, dan sekarang saya harus kembali membaca buku manual atau pembelajaran Python yang bertele-tele serta membosankan dari Oreilly atau lainnya. Omong-omong, saya sangat menghargai buku Anda. 46 | > 47 | > -- _Samuel Young_ (sy-one-three-seven-at-gmail-dot-com) 48 | 49 | > 50 | 51 | > Salam Swaroop, Saya mengikuti kelas pemrograman dari pengajar yang tidak tertarik untuk mengajar. Kami menggunakan Learning Python, edisi kedua, oleh O'Reilly. Buku itu bukan buku teks untuk pemula yang tidak punya pengetahuan tentang pemrograman, dan pengajar tersebut harusnya bekerja di bidang lain. Terima kasih untuk buku Anda, tanpa itu saya kehilangan arah tentang Python maupun pemrograman. Terima kasih banyak, Anda berhasil 'membagi pesan' ke level yang dipahami oleh pemula dan tidak semua orang mampu. 52 | > 53 | > -- _Joseph Duarte_ (jduarte1-at-cfl-dot-rr-dot-com) 54 | 55 | > 56 | 57 | > Saya sangat menyukai buku Anda! Buku tutorial Python terbaik yang pernah ada, dan referensinya sangat bermanfaat. Brilian, hasil karya yang agung! Teruskan hasil yang bagus ini! 58 | > 59 | > -- _Chris-André Sommerseth_ 60 | 61 | > 62 | 63 | > Saya baru saja mengirim email untuk berterima kasih karena telah menulis Byte of Python secara online. Saya telah mencoba Python beberapa bulan sebelum membaca buku Anda, dan meskipun sedikit berhasil dengan PyGame, Saya tidak pernah menyelesaikannya sebagai satu program. 64 | > 65 | > Terima kasih telah menyederhanakan kategori, Python sepertinya terlihat sebagai tujuan yang bisa dicapai. Sepertinya saya merasa belajar fondasinya, dan melanjutkan tujuan utama saya, pengembangan game. 66 | > 67 | > ... 68 | > 69 | > Sekali lagi, terima kasih BANYAK telah membuat panduan yang berguna dan terstruktur tentang dasar pemrograman di web. Hal itu telah mendorong saya keluar masuk pada OOP dengan pemahaman penuh, di mana dua buku teks lain telah gagal. 70 | > 71 | > -- _Matt Gallivan_ (m-underscore-gallivan12-at-hotmail-dot-com) 72 | 73 | > 74 | 75 | > Saya ingin berterima kasih untuk buku Anda 'A byte of python' yang menurut saya merupakan cara terbaik untuk belajar Python. Saya 15 tahun, tinggal di Mesir dan nama saya Ahmed. Python adalah bahasa pemerograman kedua setelah saya belajar Visual Basic 6 yang tidak bisa saya nikmati, dan saya lebih menikmati belajar Python. Saya membuat program buku alamat dan berhasil. Saya akan mencoba membuat program lebih banyak lagi dan membaca program Python lebih banyak (jika Anda memberitahu sumbernya, akan membantu saya). Saya juga mulai belajar Java, dan jika Anda bisa memberi tahu tutorial Java sebagus buku Anda, itu juga sangat membantu saya. Terima kasih. 76 | > 77 | > -- _Ahmed Mohammed_ (sedo-underscore-91-at-hotmail-dot-com) 78 | 79 | > 80 | 81 | > Buku yang menakjubkan bagi pemula untuk belajar Python adalah tutorial 110-halaman A Byte of Python oleh Swaroop CH. Buku tersebut ditulis dengan baik, mudah diikuti, dan mungkin pengenalan bahasa pemrograman Python terbaik yang pernah ada. 82 | > 83 | > -- _Drew Ames_ di artikel [Scripting Scribus](http://www.linux.com/feature/126522) dipublikasikan di Linux.com 84 | 85 | > 86 | 87 | > Kemarin saya baca sebagian besar Byte of Python di Nokia N8000 saya, dan buku itu adalah buku pengenalan Python yang paling mudah dan lengkap yang pernah saya temui. Sangat merekomendasikannya sebagai titik awal untuk belajar Python. 88 | > 89 | > -- _Jason Delport_ dib [weblog](http://paxmodept.com/telesto/blogitem.htm?id=627) 90 | 91 | > 92 | 93 | > Byte of Vim dan Python oleh @swaroopch sejauh ini menurut saya merupakan hasil karya penulisan terbaik di bidang teknis. Bacaan yang bagus #FeelGoodFactor 94 | > 95 | > -- _Surendran_ mengatakannya di [tweet](http://twitter.com/suren/status/12840485454) 96 | 97 | > 98 | 99 | > "Byte of python" sejauh ini yang terbaik sobat 100 | > 101 | > (jawaban dari pertanyaan "Siapakah yang dapat merekomendasikan literatur yang baik, tidak mahal untuk belajar dasar-dasar Python?") 102 | > 103 | > -- _Justin LoveTrue_ mengatakannya di [halaman komunitas Facebook](http://www.facebook.com/pythonlang/posts/406873916788) 104 | 105 | > "Buku Byte of python sangat-sangat membantu.. Terima kasih banyak :)" 106 | > 107 | > -- [Chinmay](https://twitter.com/a_chinmay/status/258822633741762560) 108 | 109 | > 110 | 111 | > Selalu menjadi penggemar A Byte of Python - dibuat untuk programmer baru maupun yang berpengalaman. 112 | > 113 | > -- [Patrick Harrington, di jawaban StackOverflow](http://stackoverflow.com/a/457785/4869) 114 | 115 | Bahkan NASA 116 | 117 | : Buku ini digunakan oleh NASA! Digunakan untuk proyek mereka [Jet Propulsion Laboratory](http://dsnra.jpl.nasa.gov/software/Python/byte-of-python/output/byteofpython_html/) dalam proyek Deep Space Network. 118 | 119 | ## Kursus Akademis 120 | 121 | Buku ini digunakan sebagai materi instruksi di beberapa institusi pendidikan: 122 | 123 | - 'Prinsip-prinsip Bahasa Pemrograman' kursus di [Vrije Universiteit, Amsterdam](http://www.few.vu.nl/~nsilvis/PPL/2007/index.html) 124 | - 'Konsep Dasar Komputasi' kursus di [Universitas California, Davis](http://www.cs.ucdavis.edu/courses/exp_course_desc/10.html) 125 | - 'Programming Dengan Python' kursus di [Universitas Harvard](http://www.people.fas.harvard.edu/~preshman/python_winter.html) 126 | - 'Pengenalan Pemrograman' kursus di [Universitas Leeds](http://www.comp.leeds.ac.uk/acom1900/) 127 | - 'Pengenalan Pemrograman Aplikasi' kursus di [Universitas Boston](http://www.cs.bu.edu/courses/cs108/materials.html) 128 | - 'Keahlian Teknologi Informasi untuk Meteorologi' kursus di [Universitas Oklahoma](http://gentry.metr.ou.edu/byteofpython/) 129 | - 'Geoprocessing' kursus di [Michigan State University](http://www.msu.edu/~ashton/classes/825/index.html) 130 | - 'Sistem Semantik Web Multi Agen' kursus di the [Universitas Edinburgh](http://homepages.inf.ed.ac.uk/ewan/masws/) 131 | 132 | ## Lisensi 133 | 134 | Buku ini dilisensikan di bawah lisensi [Creative Commons Attribution-Share Alike 3.0 Unported](http://creativecommons.org/licenses/by-sa/3.0/deed.en_US). 135 | 136 | Ini artinya: 137 | 138 | - Anda bebas untuk membaginya seperti menyalin, mendisitribusikan dan mengirimkan buku ini 139 | - Anda bebas untuk menata ulang, seperti mengganti bagian buku untuk diadaptasikan 140 | - Anda bebas menggunakannya untuk kebutuhan komersial 141 | 142 | Mohon dicatat: 143 | 144 | - Mohon *tidak* menjual versi elektronik maupun cetakan buku ini kecuali Anda sejara jelas dan tegas menyebutkan di penjalasan bahwa buku yang Anda jual bukan dari pengarang asli buku ini. 145 | - Pertalian *harus* ditunjukkan di penjelasan awal dan halaman depan dari dokumen dengan menyambungkan ke dan mengindikasikan dengan jelas bahwa teks asli dapat diambil dari lokasi ini. 146 | - Semua kode/skrip yang diberikan di buku ini dilisensikan di bawah [3-clause BSD License](http://www.opensource.org/licenses/bsd-license.php) kecuali disebutkan lain. 147 | 148 | ## Baca Sekarang 149 | 150 | Anda dapat [membaca buku ini secara online](http://www.swaroopch.com/notes/Python_en-Preface). 151 | 152 | ## Beli Buku Ini 153 | 154 | [Versi cetak buku ini dapat dibeli](http://www.swaroopch.com/buybook) untuk kenikmatan membaca Anda, dan mendukung pengembangan serta perbaikan berkelanjutan dari buku ini. 155 | 156 | ## Unduh 157 | 158 | - [PDF](http://files.swaroopch.com/python/byte_of_python.pdf) 159 | - [Sumber Lengkap](https://bitbucket.org/swaroopch/byte_of_python) 160 | 161 | **Jika Anda ingin mendukung pengembangan berkelanjutan dari buku ini, mohon pertimbangkan untuk [membeli versi cetak](http://www.swaroopch.com/buybook)**. 162 | 163 | ## Baca buku ini di bahasa asli Anda 164 | 165 | Jika Anda tertarik untuk membaca atau mengontribusikan terjemahan buku ini di dalam bahasa lainnya, silakan lihat di [Halaman Penerjemahan](#terjemahan). 166 | -------------------------------------------------------------------------------- /15-exceptions.pd: -------------------------------------------------------------------------------- 1 | # Eksepsi 2 | 3 | Eksepsi (pengecualian) akan muncul jika terjadi sesuatu di program Anda yang bersifat *pengecualian*. Misalnya, bagaimana jika Anda ingin membuka satu berkas dan berkas tersebut tidak ada? Atau bagaimana jika Anda secara tidak sengaja menghapusnya saat program masih berjalan? Kondisi semacam ini ditangani dengan menggunakan **eksepsi**. 4 | 5 | Mirip dengan itu, bagaimana jika program Anda memiliki statemen yang tidak valid? Hal ini ditangani oleh Python dengan **mengangkat** tangannya dan menyampaikan kepada Anda telah terjadi **kesalahan/_error_** Similarly, what if your program had some invalid statements? This is handled by Python which **raises** its hands and tells you there is an **error**. 6 | 7 | ## Error 8 | 9 | Misalnya Anda ingin memanggil fungsi sederhana `print`. Bagaimana jika kita salah tulis dari `print` menjadi `Print`? Perhatikan huruf besar di awalnya. Dalam hal ini, Python akan *mengangkat* error sintaksis. 10 | 11 | ~~~ 12 | >>> Print('Halo Dunia') 13 | Traceback (most recent call last): 14 | File "", line 1, in 15 | Print('Halo Dunia') 16 | NameError: name 'Print' is not defined 17 | >>> print('Halo Dunia') 18 | Halo Dunia 19 | ~~~ 20 | 21 | Jika Anda perhatikan `NameError` muncul bersama dengan lokasi dimana error terdeteksi. Ini yang disebut sebagai *penanganan kesalahan/_error handler_*. 22 | 23 | ## Eksepsi 24 | 25 | Kita akan **mencoba** membaca masukan dari pnegguna. Tekan `ctrl-d` dan lihat apa yang terjadi. 26 | 27 | ~~~ 28 | >>> s = input('Masukkan Sesuatu --> ') 29 | Masukkan Sesuatu --> 30 | Traceback (most recent call last): 31 | File "", line 1, in 32 | s = input('Masukkan Sesuatu --> ') 33 | EOFError: EOF when reading a line 34 | ~~~ 35 | 36 | Python memunculkan kesalahan yang dinamakan `EOFError`, pada dasarnya dia menemukan sebuah simbol *end of file/akhir berkas* (yang diwakilkan dalam bentuk `ctrl-d`) saat Python tidak mengharapkan kemunculannya. 37 | 38 | ## Menangani Eksepsi 39 | 40 | Kita dapat menangani ekspsi dengan menggunakan statemen `try..except`. Pada dasarnya kita meletakkan statemen seperti biasa ke dalam blok `try` dan meletakkan seluruh penanganan kesalahan ke dalam blok `except`. 41 | 42 | Contoh (simpan sebagai `try_except.py`): 43 | 44 | ~~~python 45 | try: 46 | text = input('Masukkan sesuatu --> ') 47 | except EOFError: 48 | print('Kenapa Anda melakukan EOF terhadap saya?') 49 | except KeyboardInterrupt: 50 | print('Anda membatalkan operasi.') 51 | else: 52 | print('Anda memasukkan {0}'.format(text)) 53 | ~~~ 54 | 55 | Keluaran: 56 | 57 | ~~~ 58 | $ python3 try_except.py 59 | Masukkan sesuatu --> # Press ctrl-d 60 | Kenapa Anda melakukan EOF terhadap saya? 61 | 62 | $ python3 try_except.py 63 | Masukkan sesuatu --> # Press ctrl-c 64 | Anda membatalkan operasi. 65 | 66 | $ python3 try_except.py 67 | Masukkan sesuatu --> tidak ada pengecualian 68 | Anda memasukkan tidak ada pengecualian 69 | ~~~ 70 | 71 | Bagaimana Cara Kerjanya: 72 | 73 | Kita menempatkan semua statemen yang akan memunculkan eksepsi atau pesan kesalahan di dalam blok `try` kemudian meletakkan penanggung jawab (_handler_) ke dalam blok `except`. Klausa `except` ini dapat menangani eksepsi atau pesan kesalahan tunggal, atau penanganan lebih dari satu eksepsi yang ditulis dengan pemisah koma. Jika pesan kesalahan atau eksepsinya tidak ditulis, dia akan menangani *semua* eksepsi dan pesan kesalahan. 74 | 75 | Mohon dicatat bahwa harus ada paling tidak satu klausa `except` pada setiap klausa `try` yang dibuat. Jika tidak, untuk apa membuat blok `try`? 76 | 77 | Jika pesan kesalahan atau eksepsi tidak ditangani, maka handler Python yang baku akan dipanggil, program akan berhenti dan menampilkan pesan kesalahan. Kita sudah lihat hal ini sebelumnya. 78 | 79 | Anda juga dapat menggunakan klausa `else` pada setiap blok `try..except`. Klausa ini akan dieksekusi jika tidak ada eksepsi yang terjadi. 80 | 81 | Dalam contoh berikutnya, kita juga akan melihat bagaimana cara memperoleh eksepsi dari sebuah objek sehingga kita bisa mengambil informasi lebih banyak. 82 | 83 | ## Memunculkan Eksepsi 84 | 85 | Anda dapat *memunculkan* eksepsi dengan menggunakan statemen `raise` dengan memberikan nama dari kesalahan/ekspsi dan objek eksepsi yang akan *dilemparkan* 86 | 87 | Kesalahan atau eksepsi yang dapat Anda munculkan harus berupa kelas yang secara langsung atau tidak diturunkan dari kelas `Exception`. 88 | 89 | Contoh (simpan dengan nama `munculkan.py`): 90 | 91 | ~~~python 92 | class EksepsiMasukanSingkat(Exception): 93 | '''kelas eksepsi buatan-sendiri.''' 94 | def __init__(self, panjang, minimal): 95 | Exception.__init__(self) 96 | self.panjang = panjang 97 | self.minimal = minimal 98 | 99 | try: 100 | text = input('Ketikkan sesuatu --> ') 101 | if len(text) < 3: 102 | raise EksepsiMasukanSingkat(len(text), 3) 103 | # Perintah lain dapat dilanjutkan sebagaimana biasanya di sini 104 | except EOFError: 105 | print('Kenapa Anda menimpakan EOF ke saya?') 106 | except ShortInputException as ex: 107 | print('EksepsiMasukanSingkat: Panjang masukan adalah {0}, dibutuhkan minimal sepanjang {1}'\ 108 | .format(ex.panjang, ex.minimal)) 109 | else: 110 | print('Tidak ada eksepsi yang dimunculkan.') 111 | ~~~ 112 | 113 | Keluaran: 114 | 115 | ~~~ 116 | $ python3 munculkan.py 117 | Ketikkan sesuatu --> a 118 | EksepsiMasukanSingkat: Panjang masukan adalah 1, dibutuhkan minimal sepanjang 3 119 | 120 | $ python3 munculkan.py 121 | Ketikkan sesuatu --> abc 122 | Tidak ada eksepsi yang dimunculkan. 123 | ~~~ 124 | 125 | Bagaimana Cara Kerjanya: 126 | 127 | Di sini, kita membuat jenis eksepsi kita sendiri. Eksepsi ini disebut `EksepsiMasukanSingkat`. Dia punya dua field - `panjang` untuk menampung panjangnya masukan (_input_), dan `minimal` yang merupakan minimal panjang yang diinginkan oleh program. 128 | 129 | Dalam klausul `except`, kita menyebutkan kelas pesan kesalahannya, yang akan disimpan `sebagai` nama variabel yang menjadi rujukan setiap objek pesan kesalahan/eksepsi terkait. Hal ini dapat dianalogikan sebagai parameter dan arguman dalam pemanggilan fungsi. Dalam klausul `except` di sini, kita gunakan field `panjang` dan `minimal` untuk mencetak pesan yang sesuai terhadap pengguna. 130 | 131 | ## Try .. Finally 132 | 133 | Misalnya Anda membaca berkas dalam program. Bagaimana Anda tahu bahwa objek berkas yang bersangkutan sudah ditutup secara semestinya atau ada eksepsi yang dimunculkan? Ini dapat kita atasi dengan penggunaan blok `finally`. Catat bahwa Anda dapat menggunakan klausul `except` bersamaan dengan blok `finally` untuk blok yang sama dengan `try`. Anda harus sisipkan diantara salah satunya jika Anda ingin memanfaatkan keduanya. 134 | 135 | Simpan sebagai `finally.py`: 136 | 137 | ~~~python 138 | import time 139 | 140 | try: 141 | f = open('puisi.txt') 142 | while True: # idiom yang umum dalam pembacaan-berkas 143 | line = f.readline() 144 | if len(line) == 0: 145 | break 146 | print(line, end='') 147 | time.sleep(2) # Jeda dua detik untuk memastikan perintahnya dijalankan 148 | except KeyboardInterrupt: 149 | print('!! Anda membatalkan pembacaan berkas.') 150 | finally: 151 | f.close() 152 | print('(Pembersihan: Menutup berkas)') 153 | ~~~ 154 | 155 | Keluaran: 156 | 157 | ~~~ 158 | $ python3 finally.py 159 | Programming menyenangkan 160 | Saat pekerjaan terselesaikan 161 | jika kamu ingin kerja menyenangkan: 162 | !! Anda membatalkan pembacaan berkas. 163 | (Pembersihan: Menutup berkas) 164 | ~~~ 165 | 166 | Bagaimana Cara Kerjanya: 167 | 168 | Kita telah lakukan cara pembacaan berkas seperti biasanya, namun secara khusus kita kenalkan waktu jeda selama 2 detik setelah mencetak tiap baris dengan fungsi `time.sleep` sehingga program akan berjalan secara lebih lambat (Python biasanya berjalan sangat cepat). Ketika program masih berjalan, tekan `ctrl-c` untuk menginterupsi/membatalkan program. 169 | 170 | Perhatikan bahwa eksepsi `KeyboardInterrupt` dimunculkan dan program berhenti berjalan. Bagaimanapun juga, sebelum program berhenti, klausul _finally_ dieksekusi dan objek berkas akan tertutup setelahnya. 171 | 172 | ## Statemen with 173 | 174 | Memanfaatkan sumber daya di dalam blok `try` dan secara berurutan melepaskan sumber daya lewat blok `finally` adalah hal yang biasa. Meskipun demikian, ada juga statemen `with` yang memungkinkan hal ini dilakukan secara bersih. 175 | 176 | 177 | Simpan sebagai `gunakan_with.py`: 178 | 179 | ~~~python 180 | with open("puisi.txt") as f: 181 | for line in f: 182 | print(line, end='') 183 | ~~~ 184 | 185 | Bagaimana Cara Kerjanya: 186 | 187 | Keluaran harusnya sama dengan contoh sebelumnya. Bedanya di sini kita menggunakan fungsi `open` dengan statemen `with` - kita tinggalkan perintah menutup berkas yang nantinya secara otomatis akan dilakukan oleh `with open`. 188 | 189 | Yan terjadi di belakang layar sebetulnya ada protokol yang digunakan oleh statemen `with`. Dia mengambil objek yang dikembalikan oleh statemen `open`, dalam kasus ini kita sebut saja sebagai `sangberkas`. 190 | 191 | Dia *selalu* memanggil fungsi `sangberkas.__enter__` sebelum memulai blok perintah di bawahnya dan *selalu* memanggil `sangberkas.__exit__` setelah menyelesaikan blok perintah. 192 | 193 | Jadi kode yang kita tulis di blok `finally` seharusnya secara otomatis sudah diurus oleh metode `__exit__. Ini membantu kita untuk menghindari penggunaan statemen `try..finally` secara eksplisit dan terus menerus. 194 | 195 | Diskusi lebih lanjut tentang hal ini di luar skup buku ini, jadi silakan rujuk ke [PEP 343](http://www.python.org/dev/peps/pep-0343/) untuk penjelasan yang lebih komprehensif. 196 | 197 | ## Ringkasan 198 | 199 | Kita telah diskusi penggunaan statemen `try..except` dan `try..finally`. Kita juga telah mencoba bagaimana membuat jenis eksepsi kita sendiri dan bagaimana memunculkan eksepsi. 200 | 201 | Selanjutnya, kita akan menelusuri Pustaka Baku Python (_Python Standard Library_). 202 | -------------------------------------------------------------------------------- /17-more.pd: -------------------------------------------------------------------------------- 1 | # Lebih Lanjut 2 | 3 | Sejauh ini kita telah mempelajari hampir mayoritas seluruh aspek Python yang mungkin akan Anda gunakan. Dalam bab ini, kita akan bahas lagi beberapa aspek lanjutan yang akan membuat pengetahuan Anda terhadap Python semakin bulat. 4 | 5 | ## Mengumpan tuples 6 | 7 | Pernahkah Anda menginginkan dua nilai kembalian yang berbeda dari satu fungsi? Anda dapat melakukannya di Python. Yang perlu dilakukan hanyalah menggunakan tuple. 8 | 9 | ~~~ 10 | >>> def ambil_detail_kesalahan(): 11 | ... return (2, 'detail kesalahan kedua') 12 | ... 13 | >>> errnum, errstr = ambil_detail_kesalahan() 14 | >>> errnum 15 | 2 16 | >>> errstr 17 | 'detail kesalahan kedua' 18 | ~~~ 19 | 20 | Perhatikan bahwa penggunaan `a, b = ` menerjemahkan hasil dari ekspresi tersebut sebagai tuple dengan dua nilai. 21 | 22 | Jika Anda ingin menerjemahkan hasil sebagai `(a, )`, Anda cukup tambahkan bintang sebagaimana Anda menambahkannya dalam parameter fungsi: 23 | 24 | ~~~ 25 | >>> a, *b = [1, 2, 3, 4] 26 | >>> a 27 | 1 28 | >>> b 29 | [2, 3, 4] 30 | ~~~ 31 | 32 | Cara ini juga yang paling cepat untuk memindah-gantikan nilai dari dua variabel di Python: 33 | 34 | ~~~ 35 | >>> a = 5; b = 8 36 | >>> a, b = b, a 37 | >>> a, b 38 | (8, 5) 39 | ~~~ 40 | 41 | ## Metode Khusus 42 | 43 | Ada beberapa metode yang khusus Python seperti `__init__` dan `__del__` yang memiliki kepentingan khusus di dalam kelas. 44 | 45 | Beberapa metode khusus digunakan untuk meniru perilaku tertentu dari tipe-tipe yang sudah ada secara baku (_built-in_). Misalnya, jika Anda ingin menggunakan metode indeks `x[key]` dalam kelas Anda (seperti saat Anda menggunakan list dan tuples), maka yang perlu Anda lakukan cukup mengimplementasi fungsi `__getitem__()` dan pekerjaan Anda selesai. Jika Anda memikirkannya, inilah yang dilakukan Python untuk kelas `list` itu sendiri! 46 | 47 | Dalam tabel berikut akan Anda temukan beberapa metode khusus. Jika Anda ingin mengetahui seluruh metode khusus, [silakan lihat buku petunjuk](http://docs.python.org/py3k/reference/datamodel.html#specialnames). 48 | 49 | `__init__(self, ...)` 50 | 51 | : Metode ini dipanggil sesaat sebelum objek yang tercantum dibawahnya dibuat, dan metodenya siap digunakan. 52 | 53 | `__del__(self)` 54 | 55 | : Dipanggil sebelum objek dimusnahkan 56 | 57 | `__str__(self)` 58 | 59 | : Dipanggil sebelum kita menggunakan fungsi `print` atau ketika `str()` digunakan 60 | 61 | `__lt__(self, other)` 62 | 63 | : Dipanggil ketika operator *lebih kecil dari* (<) digunakan. Mirip dengan hal ini, ada metode khusus lainnya untuk semua operator (+, >, dll.) 64 | 65 | `__getitem__(self, key)` 66 | 67 | : Dipanggil ketika operasi pembuatan indeks `x[key]` dilakukan. 68 | 69 | `__len__(self)` 70 | 71 | : Dipanggil ketika fungsi baku `len()` digunakan untuk objek yang bersifat urutan (sequence). 72 | 73 | ## Blok Statemen Tunggal 74 | 75 | Kita telah pelajari sebelumnya bahwa setiap blok statemen dibuat terlepas dari level indentasinya. Meskipun demikian ada satu keberatan. Jika blok statemen hanya berisi satu statemen saja, maka Anda bisa teruskan ke dalam satu baris, misalnya, sebuah statemen besifat kondisional ataupun statemen perulangan. Contoh berikut memperjelas apa yang dimaksud sebelumnya: 76 | 77 | ~~~ 78 | >>> flag = True 79 | >>> if flag: print('Ya') 80 | Ya 81 | ~~~ 82 | 83 | Perhatikan bahwa statemen tunggal digunakan di satu tempat dan bukan di blok terpisah. Meskipun Anda dapat membuat program ini menjadi semakin *kecil* secara ukuran, namu saya sangat menganjurkan untuk menghindari metode jalan pintas ini, kecuali hanya untuk pengecekan kesalahan. Sebab utamanya adalah karena lebih mudah membuat statemen tambahan jika Anda menggunakan indentasi yang layak. 84 | 85 | ## Forms Lambda 86 | 87 | Statemen `lambda` digunakan untuk membuat objek fungsi yang baru. Pada dasarnya, `lambda` mengambil parameter yang diikuti oleh ekspresi tunggal dan nilai dari eksresi ini akan dikembalikan oleh fungsi yang baru. 88 | 89 | Contoh (simpan sebagai `lambda.py`): 90 | 91 | ~~~python 92 | points = [ { 'x' : 2, 'y' : 3 }, { 'x' : 4, 'y' : 1 } ] 93 | points.sort(key=lambda i : i['y']) 94 | print(points) 95 | ~~~ 96 | 97 | Keluaran: 98 | 99 | ~~~ 100 | [{'x': 4, 'y': 1}, {'x': 2, 'y': 3}] 101 | ~~~ 102 | 103 | Bagaimana Cara Kerjanya: 104 | 105 | Perhatikan bahwa metode `sort` dari sebuah `list` dapat mengambil parameter `key` yang menentukan bagaimana nanti list akan diurutkan (biasanya kita hanya tahu urut dari atas atau urut dari bawah). Dalam kasus ini, kita ingin menggunakan pengurutan sendiri, dan untuk itu kita membuat fungsi sendiri. Namun alih-alih kita membuat blok fungsi dengan `def` dan hanya digunakan satu kali di tempat ini, kita gunakan lambda untuk membuat fungsi baru. 106 | 107 | ## Pengartian terhadap List (_List Comprehension_) 108 | 109 | List comprehension digunakan untuk menurunkan sebuah _list_ baru dari _list_ yang sudah ada. Misal Anda punya daftar angka dan Anda ingin membuat sebuah list baru yang berisi angka dari list pertama dikalikan dua hanya jika angkanya lebih besar dari pada dua. _List comprehension_ ideal untuk situasi ini. 110 | 111 | Contoh (simpan sebagai `list_comprehension.py`): 112 | 113 | ~~~python 114 | list_satu = [2, 3, 4] 115 | list_dua = [2*i for i in list_satu if i > 2] 116 | print(list_dua) 117 | ~~~ 118 | 119 | Keluaran: 120 | 121 | ~~~ 122 | $ python3 list_comprehension.py 123 | [6, 8] 124 | ~~~ 125 | 126 | Bagaimana Cara Kerjanya: 127 | 128 | Di sini kita turunkan satu list baru dengan menentukan manipulasi apa yang harus dikerjakan (`2*i`) ketika satu kondisi terpenuhi (`if i > 2`). Tolong dicatat bahwa daftar yang asli tetap sama dan tidak dimodifikasi sama sekali. 129 | 130 | Keuntungan menggunakan _list comprehensions_ adalah untuk mengurangi jumlah baris kode yang digunakan saat kita melakukan perulangan untuk memproses setiap list dan menyimpannya dalam list baru. 131 | 132 | ## Menerima Tuples dan Pustaka di dalam Fungsi 133 | 134 | Ada cara khusus untuk menerima parameter ke dalam fungsi sebagai tuple atau pustaka dengan menggunakan awalan * atau **. Ini bermanfaat saat kita mengambil cukup banyak argumen di dalam fungsi. 135 | 136 | ~~~ 137 | >>> def jumlahperkalian(perkalian, *args): 138 | ... '''Mengembalikan jumlah dari setiap argumen saat dinaikkan lewat perkalian.''' 139 | ... total = 0 140 | ... for i in args: 141 | ... total += pow(i, perkalian) 142 | ... return total 143 | ... 144 | >>> jumlahperkalian(2, 3, 4) 145 | 25 146 | 147 | >>> jumlahperkalian(2, 10) 148 | 100 149 | ~~~ 150 | 151 | Karena kita memiliki `*` sebagai awalan dalam variable `args`, maka seluruh argumen tambahan ke dalam fungsi tersebut disimpan dalam `args` sebagai tuple. Jika menggunakan awalan ** maka paremeter tambahan akan diperlakukan sebagai pustaka yang berisi pasangan kunci/nilai. 152 | 153 | ## Statemen Assert 154 | 155 | Statemen `assert` digunakan untuk memaksakan bahwa sesuatu itu benar. Misalnya, jika Anda sangat yakin bahwa hanya ada satu elemen di dalam list yang Anda gunakan dan ingin mengeceknya, serta memunculkan pesan kesalahan jika salah, maka statemen `assert` sangat ideal dalam konfisi ini. Ketika statemen assert gagal, maka `AssertionError` akan dimunculkan. 156 | 157 | ~~~ 158 | >>> daftarku = ['item'] 159 | >>> assert len(daftarku) >= 1 160 | >>> daftarku.pop() 161 | 'item' 162 | >>> daftarku 163 | [] 164 | >>> assert len(daftarku) >= 1 165 | Traceback (most recent call last): 166 | File "", line 1, in 167 | AssertionError 168 | ~~~ 169 | 170 | Statemen `assert` harus digunakan secara hati-hati. Biasanya, lebih baik digunakan untuk mengambil eksepsi, baik untuk mengatasi asalah atau menampilkan pesan kesalahan kepada pengguna lalu berhenti. 171 | 172 | ## Rangkaian Pelepasan (_Escape Sequences_) 173 | 174 | Misalnya, Anda punya string yang berisi tanda petik (`'`), bagaimana Anda menuliskannya di dalam string? Misalnya `What's your name?`. Anda tidak dapat menuliskan `'What's your name?'` karena Python akan bingung dimana string ini mulai dan berakhir. Jadi Anda aharus menentukan tanda petik tunggal mana yang bukan merupakan akhir dari string. Ini dapat dilakauka dengan bantuan *rangkaian pelepasan*. Anda cukup tentukan dengan garis miring terbalik `\'` - perhatikan garis miring terbaliknya. Jadi untuk string di atas, dapat Anda tuliskan dengan `'What\'s your name?'`. 175 | 176 | Cara lain untuk menentukan string secara khusus adalah dengan menuliskannya `"What's your name?"` - dengan tanda petik ganda. Sesuai dengan aturan sebelumnya, Anda juga harus menggunakan rangkaian pelepasan untuk penggunaan tanda petik ganda jika di dalam string yang bersangkutan mengandung tanad petik ganda. Jika karakter yang ingin dilepaskan adalah garis miring terbalik, Anda juga harus menuliskannya dua kali `\\`. 177 | 178 | Bagaimana jika ingin menentukan string sepanjang dua baris? Salah satu caranya adalah dengan tanda petik tiga sebagainya sudah dibahas [sebelumnya](#triple-quotes) atau Anda dapat menggunakan rangkaian pelepasan untuk karakter ganti baris - `\n` untuk menunjukkan baris baru. Contohnya `Ini adalah baris pertama\nIni adalah baris kedua`. Rangkaaian pelepasan lain yang menarik untuk diketahui adalah tab - `\t`. Ada banyak rangkaian pelepasan lainnya tapi saya hanya menyebutkan yang paling Anda butuhkan. 179 | 180 | Satu hal yang perlu dicatat adalah bahwa di dalam string, satu garis miring terbalik di akhir baris menunjukkan bahwa string dilanjutkan ke baris berikutnya, tapi tidak menambahkan baris baru. Contoh: 181 | 182 | ~~~python 183 | "Ini kalimat pertama. \ 184 | Ini kalimat kedua." 185 | ~~~ 186 | 187 | kalimat di atas sama persis dengan 188 | 189 | ~~~python 190 | "Ini kalimat pertama. Ini kalimat kedua." 191 | ~~~ 192 | 193 | ### String Mentah (_Raw_) 194 | 195 | Jika Anda ingin menentukan beberapa string di mana tidak ada pemrosesan secara khusus seperti pemberlakuan rangkaian pelepasan, maka Anda perlu menentukan string *mentah* dengan memberikan awalan `r` atau `R` ke dalam string. Contohnya `r"Baris baru ditentukan lewat \n"`. 196 | 197 | Catatan untuk pengguna Ekspresi Reguler 198 | 199 | : Selalu gunakan string mentah saat menggunakan ekspresi reguler. Karena jika tidak, akan ada terlalu banyak karakter tambahan. Misalnya, referensi balik sering ditampilkan sebagai `'\\1'` atau `r'\1'`. 200 | 201 | ## Ringkasan 202 | 203 | Di bab ini kita telah membahas beberapa fitur tambahan dari Python meskipun belum mencakup seluruh fitur yang dimiliki Python. Bagaimanapun juga, dalam tahap ini, kita telah membahas hampir semua hal yang mungkin akan Anda gunakan dalam praktik. Dan ini sudah cukup bagi Anda untuk mulai menulis program apapun yang ingin Anda tulis. 204 | 205 | Berikutnya, kita akan diskusi bagaimana menjelajahi Python lebih lanjut. 206 | -------------------------------------------------------------------------------- /18-what-next.pd: -------------------------------------------------------------------------------- 1 | # Apa Berikutnya 2 | 3 | Jika Anda telah membaca buku ini secara saksama hingga sekarang dan praktik membuat banyak program, maka Anda sekarang seharusnya lebih nyaman dan familier dengan Python. Anda mungkin sudah mmebuat beberapa program Python untuk percobaan dan melatih kemampuan Python Anda. Jika belum, mulailah sekarang. Pertanyaan berikutnya adalah 'Apa Berikutnya?' 4 | 5 | Saya sarankan Anda coba geluti masalah ini: 6 | 7 | > Buat program *buku-alamat* berbasis perintah di mana Anda dapat menelusuri, menambah, modifikasi,menghapus atau mencari kontak yang Anda miliki seperti teman, keluarga dan rekanan serta informasi detail mereka seperti alamat email atau nomor telepon. Detailnya harus disimpan agar bisa ditampilkan di kemudian hari. 8 | 9 | Ini cukup mudah jika Anda memikirkannya dengan mempertimbangkan berbagai hal yang telah kita pelajari sebelumnya hingga sekarang. Jika Anda masih membutuhkan petunjuk bagaimana melakukannya, berikut beberapa petunjuk. 10 | 11 | Petunjuk (Jangan baca ini sebelum Anda mencobanya) 12 | 13 | : Buat sebuah _class_ untuk merepresentasikan informasi dari seseorang. Gunakan pustaka untuk menyimpan objek person ini, dengan menggunakan namanya sebagai kunci. Gunakan modul picke untuk menyimpan objek secara persisten ke dalam ruang penyimpanan komputer Anda. Gunakan metode baku dari pustaka untuk menambah, menghapus dan mengubah informasi dari orang tersebut. 14 | 15 | Sekai Anda bisa melakukan ini, Anda dapat menyebut diri Anda sebagai seorang programmer Python. Lalu kirim [surel ke saya](http://www.swaroopch.com/contact/) dan berterimakasihlah terhadap buku yang bagus ini ;-). Langkah ini tidak wajib, namun dianjurkan. Juga pertimbangkan untuk membeli [versi cetak](http://www.swaroopch.com/buybook/) untuk mendukung pengembangan buku ini. 16 | 17 | Jika program di atas menurut Anda cukup mudah, ini contoh lain yang lebih sulit: 18 | 19 | > Implementasikan [perintah ganti](http://unixhelp.ed.ac.uk/CGI/man-cgi?replace). Perintah ini akan mengganti satu string ke dalam string yang lain di dalam daftar berkas yang diberikan. 20 | 21 | Perintah ganti dapat dibuat secara sederhana atau rumit sesuai dengan keinginan Anda, dari substitusi string sederhana hingga pencarian pola (ekspresi reguler) 22 | 23 | Setelah itu, berikut beberapa petunjuk untuk perjalanan Anda bersama Python: 24 | 25 | ## Kode Contoh 26 | 27 | Cara paling baik untuk belajar bahasa pemrograman adalah dengan menulis banyak kode dan membaca banyak kode: 28 | 29 | - [Resep Masak Python](http://code.activestate.com/recipes/langs/python/) koleksi resep atau tips yang sangat bermanfaat untuk memecahkan masalah khusus dengan menggunakan Python. Buku ini wajib-baca untuk setiap pengguna Python. 30 | - [Modul Mingguan Python](http://www.doughellmann.com/PyMOTW/contents.html) panduan yang sangat baik dan wajib dibaca untuk [Pustaka Standar Python](#pustaka-standar). 31 | 32 | ## Tanya Jawab 33 | 34 | - [Lakukan dan Jangan Lakukan di Python](http://docs.python.org/py3k/howto/doanddont.html) 35 | - [Pertanyaan Resmi yang Sering Diajukan di Python](http://www.python.org/doc/faq/general/) 36 | - [Daftar Pertanyaan yang Jarang Ditanyakan dari Norvig](http://norvig.com/python-iaq.html) 37 | - [Interview Tanya Jawab Python](http://dev.fyicenter.com/Interview-Questions/Python/index.html) 38 | - [Pertanyaan di StackOverflow dengan tagar Python](http://beta.stackoverflow.com/questions/tagged/python) 39 | 40 | ## Panduan 41 | 42 | - [Daftar lengkap tutorial Python dari Awaretek](http://www.awaretek.com/tutorials.html) 43 | 44 | ## Video 45 | 46 | - [PyVideo](http://www.pyvideo.org/category) 47 | 48 | ## Diskusi 49 | 50 | Jika Anda terhenti karena permasalahan Python, dan tidak ada tempat bertanya, [daftar tutor-python](http://mail.python.org/mailman/listinfo/tutor) adalah tempat yang tepat untuk bertanya. 51 | 52 | Pastikan Anda sudah mengerjakan PR Anda dan mencoba menyelesaikan sendiri terlebih dahulu sebelum bertanya. 53 | 54 | ## Berita 55 | 56 | Jika ingin mengikuti berita-berita terkini dari dunia Python, silakan ikuti [Planet Python Resmi](http://planet.python.org). 57 | 58 | ## Menginstal Pustaka 59 | 60 | Ada sangat banyak pustaka kode terbuka yang tersedia di [Indeks Paket Python](http://pypi.python.org/pypi) yang dapat Anda gunakan di program Anda. 61 | 62 | Untuk menginstal dan menggunakan pustaka ini, Anda dapat gunakan [pip](http://www.pip-installer.org/en/latest/). 63 | 64 | ## Perangkat Lunak Grafis 65 | 66 | Misalnya Anda ingin membuat program grafis sendiri dengan menggunakan Python. Ini dapat dilakukan dengan memanfaatkan pustaka GUI (_Graphical User Interface_/Antarmuka Pengguna Grafis) yang bisa dilekatkan pada program Python Anda. Pelekatan ini memungkinkan Anda menulis program di Python dan menggunakan pustaka yang berdiri sendiri yang ditulis dalam bahasa C atau C++ atau bahasa lainnya. 67 | 68 | Ada banyak pilihan menggunakan GUI di Python: 69 | 70 | Kivy 71 | 72 | : 73 | 74 | PyGTK 75 | 76 | : Perangkat lunak ini merupakan lekatan Python terhadap GTK+ toolkit, yang merupakan fondasi dari antar muka GNOME. GTK+ memiliki banyak aturan main untuk bisa digunakan, namun sekali Anda merasa nyaman, Anda bisa membuat aplikasi GUI secara cepat. Aplikasi desainer antar muka Glade juga sangat bagus. Dokumentasi juga diperbaiki dari waktu ke waktu. GTK+ berjalan baik di Linux meskipun portingnya ke Windows masih belum selesai. Anda dapat membuat perangkat lunak baik bebas maupun komersial dengan menggunakan GTK+. Untuk memulai, silakan baca [Panduan PyGTK](http://www.pygtk.org/tutorial.html). 77 | 78 | PyQt 79 | 80 | : PyQt adalah lekatan Python terhadap kumpulan pustaka bantu Qt, yang merupakan fondasi dibangunnya KDE. Qt sangat mudah digunakan dan sangat bagus terutama dengan adanya Qt Designer dan dokumentasi Qt yang komprehensif. PyQt bebas alias gratis jika digunakan untuk membuat perangkat lunak bebas (GPL) dan Anda harus membelinya jika ingin digunakan untuk membuat perangkat lunak komersial tertutup. Mulai dari Qt 4.5 Anda juga bisa menggunakannya untuk membuat perangkat lunak non-GPL. Untuk mulai, silakan baca [Tutorial PyQt](http://zetcode.com/tutorials/pyqt4/) atau [buku PyQT](http://www.qtrac.eu/pyqtbook.html). 81 | 82 | wxPython 83 | 84 | : Pustaka ini adalah lekatan Python untuk toolkit wxWidgets. wxPython memiliki kurva pembelajaran tersendiri yang terhubung dengan wxWidgets. Meskipun demikian, pustaka ini sangat portabel dan bisa dijalankan di Linux, Windos, Mac bahkan juga platform embedded. Ada banyak IDE yang tersedia untuk wxPython termasuk desainer GUI seperti [SPE (Editor Python dari Stani)](http://spe.pycs.net) dan pembangun GUI [wxGlade](http://wxglade.sourceforge.net/). Anda dapat menggunakannya untuk membuat aplikasi bebas/gratis ataupun aplikasi tertutup. Untuk memulai, silakan baca [tutorial wxPython](http://zetcode.com/wxpython/). 85 | 86 | ### Ringkasan Alat Bantu GUI 87 | 88 | Untuk pilihan lebih banyak, silakan lihat [halaman wiki GuiProgramming di situs web resmi dari python](http://www.python.org/cgi-bin/moinmoin/GuiProgramming). 89 | 90 | Namun sayangnya, tidak ada yang satupun yang disebut sebagai standar GUI di Python. Saya sarankan Anda memilih salah satu dari alat-alat bantu di atas, tergantung dari kondisi Anda. Faktor pertama yang perlu dipertimbangkan adalah apakah Anda mau membayar alat bantu GUI tersebut atau tidak. Faktor kedua adalah apakah program yang Anda buat hanya bisa berjalan di Windows, Mac, Linux atau jalan di semua platform. Faktor ketiga adalah, jika Anda memilih platform Linux, apakah Anda menggunakan KDE atau GNOME sebagai lingkungan grafiknya. 91 | 92 | Untuk analisis yang komprehensif dan detail, lihat halaman 26 dari [The Python Papers, Volume 3, Issue 1](http://archive.pythonpapers.org/ThePythonPapersVolume3Issue1.pdf). 93 | 94 | ## Berbagai Macam Penerapan 95 | 96 | Biasanya ada dua bagian dari bahasa pemrograman - bahasanya dan perangkat lunaknya. Bahasa adalah *bagaimana* anda menuliskan sesuatu. Sedangkan perangkat lunaknya adalah *apa* yang sebetulnya menjalankan program kita. 97 | 98 | Kita telah menggunakan *CPython* untuk menjalankan program kita. Hal ini sering disebut sebagai CPython sebab ditulis dalam bahasa C dan bahasa tersebut merupakan *interpreter Python Klasik*. 99 | 100 | Ada juga perangkat lunak lain yang bisa menjalankan program Python: 101 | 102 | [Jython](http://www.jython.org) 103 | 104 | : Implementasi Python yang berjalan pada platform Java. Ini berarti Anda bisa menggunakan pustaka dan kelas Java di dalam bahasa Python dan sebaliknya. 105 | 106 | [IronPython](http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython) 107 | 108 | : Implementasi Python yang bisa dijalankan pada platform .NET. Ini berarti bahwa Anda bisa menggunakan pustaka dan kelas .NET di dalam bahasa Python dan sebaliknya. 109 | 110 | [PyPy](http://codespeak.net/pypy/dist/pypy/doc/home.html) 111 | 112 | : Implementasi Python yang ditulis dalam bahasa Python! Ini merupakan proyek riset yang bertujuan untuk meningkatkan kecepatan dan kemudahan interpreter Python, mengingat interpreternya sendiri ditulis dalam bahasa dinamis (sebagai lawan dari bahasa statis seperti C, Java atau C#) 113 | 114 | [Stackless Python](http://www.stackless.com) 115 | 116 | : Implementasi Python yang mengkhususkan diri untuk peningkatan kinerja Python berbasis thread. 117 | 118 | Ada pula implementasi lain seperti [CLPython](http://common-lisp.net/project/clpython/) - Implementasi Python yang ditulis dalam bahasa Common Lisp dan [IronMonkey](http://wiki.mozilla.org/Tamarin:IronMonkey) merupakan porting IronPython di atas interpreter JavaScript yang berarti Anda dapat menggunakan Python (alih-alih JavaScript) untuk menulis program berbasis web ("Ajax"). 119 | 120 | Setiap implementasi ini memiliki kekhususan kegunaan untuk bidang-bidang tertentu. 121 | 122 | ## Pemrograman Berbasis Fungsi (untuk pengguna tingkat lanjut) 123 | 124 | Saat Anda menulis program yang lebih besar, Anda harus belajar lebih lanjut tentang pendekatan pemrograman berbasis fungsi sebagai perbandingan pada pendekatan pemrograman berbasis kelas sebagaimana yang sudah kita pelajari di [bab pemrograman berbasis objek](#object-oriented-programming): 125 | 126 | - [Functional Programming Howto oleh A.M. Kuchling](http://docs.python.org/dev/howto/functional.html) 127 | - [Bab Functional Programming pada buku 'Dive Into Python'](http://www.diveintopython.net/functional_programming/index.html) 128 | - [Presentasi Functional Programming with Python](http://ua.pycon.org/static/talks/kachayev/index.html) 129 | 130 | ## Ringkasan 131 | 132 | Kita telah sampai pada bagian akhir buku ini tapi, sebagaimana mereka katakan, ini adalah *awal dari yang akhir*!. Anda sekarang bisa menyebut diri Anda sebagai pengguna Python dan tanpa ragu lagi Anda sudah siap menyelesaikan masalah dengan menggunakan Python. Anda bisa mulai menggunakan komputer untuk mengerjakan segala hal yang tidak dibayangkan sebelumnya, atau menulis program _game_ Anda sendiri dan banyak lagi lainnya. Jadi, mari kita mulai! 133 | -------------------------------------------------------------------------------- /07-operators-expressions.pd: -------------------------------------------------------------------------------- 1 | # Operator dan Ekspresi 2 | 3 | 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. 4 | 5 | *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. 6 | 7 | ## Operator 8 | 9 | Kita akan melihat operator secara singkat dan bagaimana penggunaannya: 10 | 11 | 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: 12 | 13 | ~~~python 14 | >>> 2 + 3 15 | 5 16 | >>> 3 * 5 17 | 15 18 | >>> 19 | ~~~ 20 | 21 | `+` (tambah) 22 | 23 | : Menambahkan dua objek 24 | 25 | `3 + 5` menghasilkan `8`. `'a' + 'b'` menghasilkan `'ab'`. 26 | 27 | `-` (minus) 28 | 29 | : Mengurangi satu angka terhadap angka lainnya. Jika operand pertama tidak ada, diasumsikan nol. 30 | 31 | `-5.2` memberikan angka negatif dan `50 - 24` memberi hasil `26`. 32 | 33 | `*` (perkalian) 34 | 35 | : Menghasilkan perkalian dari dua angka atau mengembalikan string yang diulang beberapa kali. 36 | 37 | `2 * 3` menghasilkan `6`. `'la' * 3` menghasilkan `'lalala'`. 38 | 39 | `**` (pangkat) 40 | 41 | : Menghasilkan x pangkat y 42 | 43 | `3 ** 4` memberikan `81` (dengan kata lain `3 * 3 * 3 * 3`) 44 | 45 | `/` (pembagian) 46 | 47 | : Membagi x oleh y 48 | 49 | `4 / 3` menghasilkan `1.3333333333333333`. 50 | 51 | `//` (pembagi bulat ke bawah) 52 | 53 | : Mengembalikan hasil pembulatan ke bawah dari hasil pembagian 54 | 55 | `4 // 3` menghasilkan `1`. 56 | 57 | `%` (modulo) 58 | 59 | : Menghasilkan sisa dari pembagian 60 | 61 | `8 % 3` menghasilkan `2`. `-25.5 % 2.25` menghasilkan `1.5`. 62 | 63 | `<<` (geser kiri) 64 | 65 | : 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) 66 | 67 | `2 << 2` menghasilkan `8`. `2` direpresentasikan `10` dalam bits. 68 | 69 | Menggeser 2 bit kekiri akan menghasilkan `1000` yang merupakan representasi dari desimal `8`. 70 | 71 | `>>` (geser kanan) 72 | 73 | : Menggeser angka bit ke kanan sesuai dengan jumlah bit yang telah ditentukan. 74 | 75 | `11 >> 1` menghasilkan `5`. 76 | 77 | `11` direpresentasikan oleh bit dengan `1011` kemudian digeser ke kanan 1 bit menghasilkan `101` yang merupakan desimal angka `5` 78 | 79 | `&` (bitwise AND) 80 | 81 | : Operasi bit-wise AND dari angka (bitwise adalah operasi angka berbasis bit yakni dengan `0` dan `1`) 82 | 83 | `5 & 3` menghasilkan `1`. 84 | 85 | `|` (bitwise OR) 86 | 87 | : Operasi bitwise OR dari angka 88 | 89 | `5 | 3` menghasilkan `7` 90 | 91 | `^` (bitwise XOR) 92 | 93 | : Operasi angka Bitwise XOR (OR ekslusif/exclusive or) 94 | 95 | `5 ^ 3` menghasilkan `6` 96 | 97 | `~` (bitwise invert) 98 | 99 | : Membalikkan angka bitwise dari x atau -(x+1) 100 | 101 | `~5` menghasilkan `-6`. 102 | 103 | `<` (kurang dari) 104 | 105 | : Menghasilkan pengembalian apakah x kurang dari y. Semua operator perbandingan hanya menghasilkan `True` atau `False`. Catat huruf besar yang ada di awal kata tersebut. 106 | 107 | `5 < 3` menghasilkan `False` dan `3 < 5` menghasilkan `True`. 108 | 109 | Perbandingan dapat dirangkai secara bebas: `3 < 5 < 7` menghasilkan `True`. 110 | 111 | `>` (lebih besar dari) 112 | 113 | : Menghasilkan pengembalian apakah x lebih besar daripada y 114 | 115 | `5 > 3` menghasilkan `True`. Jika operand berupa angka, keduanya akan dikonversikan dalam tipe yang sejenis. Selain itu, selalu mengembalikan nilai `False` 116 | 117 | `<=` (lebih kecil atau sama dengan) 118 | 119 | : Menghasilkan pengembalian apakah x lebih kecil atau sama dengan y 120 | 121 | `x = 3; y = 6; x <= y` menghasilkan `True`. 122 | 123 | `>=` (lebih besar atau sama dengan) 124 | 125 | : Menghasilkan pengembalian apakah x lebih besar atau sama dengan y 126 | 127 | `x = 4; y = 3; x >= 3` menghasilkan `True`. 128 | 129 | `==` (sama dengan) 130 | 131 | : Membandingkan apakah kedua objek sama atau tidak 132 | 133 | `x = 2; y = 2; x == y` menghasilkan `True`. 134 | 135 | `x = 'str'; y = 'stR'; x == y` menghasilkan `False`. 136 | 137 | `x = 'str'; y = 'str'; x == y` menghasilkan `True`. 138 | 139 | `!=` (tidak sama dengan) 140 | 141 | : Membandingkan apakah kedua objek berbeda atau tidak 142 | 143 | `x = 2; y = 3; x != y` menghasilkan `True`. 144 | 145 | `not` (boolean NOT) 146 | 147 | : Jika x `True`, akan menghasilkan `False`. Jika x `False`, menghasilkan `True`. 148 | 149 | `x = True; not x` menghasilkan `False`. 150 | 151 | `and` (boolean AND) 152 | 153 | : `x dan y` menghasilkan `False` Jika x `False`, selain itu akan menghasilkan pengembalian evaluasi nilai y 154 | 155 | `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. 156 | 157 | `or` (boolean OR) 158 | 159 | : Jika x `True`, akan mengembalikan `True`, selain itu akan mengembalikan nilai y 160 | 161 | `x = True; y = False; x or y` mengembalikan `True`. Evaluasi sirkuit pendek juga berlaku di sini. 162 | 163 | ### Jalan pintas untuk operasi matematika dan penugasan 164 | 165 | Menjalankan operasi matematika di variable lalu menugaskan hasilnya kembali kepada variabel cukup umum dilakukan di Python. Berikut adalah jalan pintas untuk menjalankan ekspresi tersebut. 166 | 167 | Anda dapat menulis: 168 | 169 | ~~~python 170 | a = 2 171 | a = a * 3 172 | ~~~ 173 | 174 | 175 | dengan cara: 176 | 177 | ~~~python 178 | a = 2 179 | a *= 3 180 | ~~~ 181 | 182 | Perhatikan bahwa `operasi ekxpresi var = var` menjadi `var operasi = ekspresi`. 183 | 184 | ## Urutan Evaluasi 185 | 186 | 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. 187 | 188 | 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. 189 | 190 | Tabel berikut diambil dari [manual referensi Python](http://docs.python.org/py3k/reference/expressions.html#summary), 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](#changing-the-order-of-evaluation) di bawah untuk lebih lengkapnya. 191 | 192 | `lambda` 193 | 194 | : Ekspresi lambda 195 | 196 | `or` 197 | 198 | : Boolean OR 199 | 200 | `and` 201 | 202 | : Boolean AND 203 | 204 | `not x` 205 | 206 | : Boolean NOT 207 | 208 | `in, not in` 209 | 210 | : Tes keanggotaan variabel 211 | 212 | `is, is not` 213 | 214 | : Tes identitas variabel 215 | 216 | `<, <=, >, >=, !=, ==` 217 | 218 | : Perbandingan 219 | 220 | `|` 221 | 222 | : Bitwise OR 223 | 224 | `^` 225 | 226 | : Bitwise XOR 227 | 228 | `&` 229 | 230 | : Bitwise AND 231 | 232 | `<<, >>` 233 | 234 | : Menggeser 235 | 236 | `+, -` 237 | 238 | : Penambahan dan Pengurangan 239 | 240 | `*, /, //, %` 241 | 242 | : Perkalian, Pembagian, Pembagian pembulatan kebawah dan sisa (modulo) 243 | 244 | `+x, -x` 245 | 246 | : Positif, Negatif 247 | 248 | `~x` 249 | 250 | : Bitwise NOT 251 | 252 | `**` 253 | 254 | : Eksponensial/Pangkat 255 | 256 | `x.attribute` 257 | 258 | : Referensi terhadap atribut 259 | 260 | `x[index]` 261 | 262 | : Pendaftaran 263 | 264 | `x[index1:index2]` 265 | 266 | : Pemotongan 267 | 268 | `f(argumen ...)` 269 | 270 | : Pemanggilan fungsi 271 | 272 | `(ekspresi, ...)` 273 | 274 | : Pengikatan atau penampilan dalam format tuple 275 | 276 | `[ekspresi, ...]` 277 | 278 | : Penampilan dalam format list 279 | 280 | `{key:datum, ...}` 281 | 282 | : Penampilan dalam format kamus (dictionary) 283 | 284 | Simbol operasi yang belum dibahas akan dijelaskan nanti pada bab berikutnya. 285 | 286 | Simbol operasi yang memiliki *bobot yang sama* akan ditampilkan pada baris yang sama di tabel di atas. Sebagai contoh, `+` dan `-` memiliki bobot yang sama. 287 | 288 | ## Mengubah Urutan Pelaksanaan Ekspresi 289 | 290 | Untuk membuat ekspresi lebih mudah dibaca kita dapat menggunakan tanda dalam kurung. Sebagai contoh `2 + ( 3 * 4 ) jauh lebih mudah untuk dipahami daripada `2 + 3 * 4` yang membutuhkan pengetahuan urutan operator. Sebagaimana hal lainnya, tanda dalam kurung harus digunakan secara tepat (jangan berlebihan) dan jangan berulang seperti di `(2 + (3 * 4)). 291 | 292 | 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`. 293 | 294 | ## Asosiatifitas 295 | 296 | 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)`. 297 | 298 | ## Ekspresi 299 | 300 | Contoh (simpan berkas berikut dengan nama `expression.py`): 301 | 302 | ~~~python 303 | panjang = 5 304 | lebar = 2 305 | 306 | area = panjang * lebar 307 | print('Area seluas', area) 308 | print('Perimeter seluas', 2 * (panjang + lebar)) 309 | ~~~ 310 | 311 | Keluaran: 312 | 313 | ~~~ 314 | $ python3 expression.py 315 | Area seluas 10 316 | Perimeter seluas 14 317 | ~~~ 318 | 319 | Bagaimana Cara Kerjanya: 320 | 321 | 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. 322 | 323 | 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. 324 | 325 | ## Ringkasan 326 | 327 | 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 statemen. 328 | -------------------------------------------------------------------------------- /05-first-steps.pd: -------------------------------------------------------------------------------- 1 | # Langkah Pertama 2 | 3 | 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. 4 | 5 | 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. 6 | 7 | ## Menggunakan Prompt Interpreter 8 | 9 | Buka terminal di sistem operasi Anda (sebagaimana telah didiskusikan sebelumnya di [Bab Instalasi](#installation)) lalu buka prompt Python dengan mengetikkan `python3` dan menekan tombol enter. 10 | 11 | Sekali Anda mulai `python3`, Anda akan melihat `>>>` di mana Anda dapat mulai mengetikkan sesuatu. Ini disebut sebagai *prompt interpreter Python*. 12 | 13 | Di prompt interpreter Python, ketik `print('Hello World')` lalu tekan tombol `enter`. Anda seharusnya melihat keluaran `Hello World` 14 | 15 | 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. 16 | 17 | ~~~ 18 | $ python3 19 | Python 3.3.0 (default, Oct 22 2012, 12:20:36) 20 | [GCC 4.2.1 Compatible Apple Clang 4.0 ((tags/Apple/clang-421.0.60))] on darwin 21 | Type "help", "copyright", "credits" or "license" for more information. 22 | >>> print('hello world') 23 | hello world 24 | >>> 25 | ~~~ 26 | 27 | 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. 28 | 29 | Bagaimana Berhenti dari Prompt Interpreter 30 | 31 | : 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`. 32 | 33 | ## Memilih Editor 34 | 35 | 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. 36 | 37 | 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. 38 | 39 | 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. 40 | 41 | Jika Anda tidak tahu darimana memulai, Saya rekomendasikan untuk menggunakan perangkat lunak editor [Komodo Edit](http://www.activestate.com/komodo-edit/downloads) yang tersedia untuk Windows, Mac OS X dan Linux. 42 | 43 | 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. 44 | 45 | 46 | Jika Anda merupakan programmer yang berpengalaman, Anda pasti sudah menggunakan [Vim](http://www.vim.org/) atau [Emacs](http://www.gnu.org/software/emacs/). Tanpa perlu banyak pembahasan, kedua perangkat lunak ini merupakan editor yang paling berkualitas dan Anda akan memperoleh banyak keuntungan jika menggunakannya untuk menulis program 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 Python daripada belajar editor untuk saat ini. 47 | 48 | Sebagai pengingat kembali, silakan pilih editor yang layak untuk Anda - Hal itu dapat membuat penulisan program Python menjadi lebih menyenangkan dan mudah. 49 | 50 | Untuk Pengguna Vim 51 | 52 | : Ada pengenalan yang bagus tentang bagaimana [membuat Vim menjadi Python IDE yang bagus oleh John M Anderson](http://blog.sontek.net/blog/detail/turning-vim-into-a-modern-python-ide). Yang juga direkomendasikan adalah [jedi-vim plugin](https://github.com/davidhalter/jedi-vim) dan [konfigurasi dotvim saya](https://github.com/swaroopch/dotvim). 53 | 54 | Untuk Pengguna Emacs 55 | 56 | : Ada pengenalan yang bagus tentang bagaimana [membuat Emacs menjadi Python IDE yang bagus oleh Pedro Kroger](http://pedrokroger.net/2010/07/configuring-emacs-as-a-python-ide-2/). Yang juga direkomendasikan adalah [konfigurasi dotemacs BG](https://github.com/ghoseb/dotemacs). 57 | 58 | ## Menggunakan Berkas Program 59 | 60 | 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." 61 | 62 | Pilihlah Editor Anda, dan masuk ke dalam program tersebut, simpan dengan nama `hello.py`. 63 | 64 | Jika Anda menggunakan Komodo Edit, klik di `File` --- `New` --- `New File`, ketik baris berikut: 65 | 66 | ~~~python 67 | print('Hello World') 68 | ~~~ 69 | 70 | Di Komodo Edit, klik `File` --- `Save` untuk menyimpan berkas. 71 | 72 | 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: 73 | 74 | - `C:\\py` di Windows 75 | - `/tmp/py` di Linux 76 | - `/tmp/py` di Mac OS X 77 | 78 | Untuk membuat folder, gunakan perintah `mkdir` di terminal, contohnya `mkdir /tmp/py`. 79 | 80 | Penting 81 | 82 | : Selalu pastikan Anda memberi nama ekstensi berkasnya `.py`, sebagai contoh `foo.py`. 83 | 84 | Di Komodo Edit, klik `Tools` --- `Run Command`, ketik `python3 hello.py` dan klik `Run` Anda akan melihat keluaran tercetak sebagaimana tangkapan layar di bawah ini. 85 | 86 | ![Tangkapan layar dari Komodo Edit untuk program Hello World](assets/komodo-edit-hello-world.png) 87 | 88 | Jalan terbaik adalah, tidak mengetikkannya di Komodo Edit, namun menggunakan terminal: 89 | 90 | #. Buka Terminal sebagaimana telah dijelaskan di [Bab Instalasi](#installation). 91 | #. *G*anti *d*irektori di mana Anda menyimpan berkas, sebagai contoh, `cd /tmp/py` 92 | #. Jalankan program dengan mengetikkan perintah `python3 hello.py`. 93 | 94 | Keluaran akan ditampilkan sebagai berikut. 95 | 96 | ~~~ 97 | $ python3 hello.py 98 | Hello World 99 | ~~~ 100 | 101 | 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. 102 | 103 | 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 bari - kita akan [lihat nanti kenapa ini penting](#indentation). 104 | 105 | **Bagaimana Cara Kerjanya** 106 | 107 | 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 [bab berikutnya](#functions) - 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`' 108 | 109 | ### Program Python yang bisa Dieksekusi 110 | 111 | Ini hanya berlaku untuk pengguna Linux dan Unix, tapi pengguna Windows juga perlu tahu hal ini. 112 | 113 | 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*. 114 | 115 | Tambahkan baris berikut di *baris pertama* program Anda: 116 | 117 | ~~~python 118 | #!/usr/bin/env python3 119 | ~~~ 120 | 121 | Jadi program Anda akan terlihat seperti ini sekarang: 122 | 123 | ~~~python 124 | #!/usr/bin/env python3 125 | print('Hello World') 126 | ~~~ 127 | 128 | Kedua, kita harus memberikan program tersebut hak eksekusi dengan perintah `chmod` lalu *jalankan* berkas program. 129 | 130 | Perintah chmod yang digunakan di sini adalah untuk *me*ngubah *mod*e dari file dengan memberikan hak e*k*sekusi untuk *s*emua pengguna di dalam sistem. 131 | 132 | ~~~ 133 | $ chmod a+x hello.py 134 | ~~~ 135 | 136 | 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: 137 | 138 | ~~~ 139 | $ ./hello.py 140 | Hello World 141 | ~~~ 142 | 143 | Kita menggunakan `./` untuk mengindikasikan bahwa program berada di folder saat ini. 144 | 145 | 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. 146 | 147 | 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`. 148 | 149 | 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`. 150 | 151 | ~~~ 152 | $ echo $PATH 153 | /usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/home/swaroop/bin 154 | $ cp hello.py /home/swaroop/bin/hello 155 | $ hello 156 | Hello World 157 | ~~~ 158 | 159 | 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. 160 | 161 | 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`. 162 | 163 | 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. 164 | 165 | ## Memperoleh Bantuan 166 | 167 | 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. 168 | 169 | Catatan 170 | 171 | : tekan `q` untuk keluar dari bantuan. 172 | 173 | Mirip dengan hal tersebut, Anda dapat memperoleh informasi segala sesuatu tentang Python. Cukup gunakan `help()` untuk mempelajari lebih lanjut tentang bagaimana menggunakan `help` itu sendiri! 174 | 175 | 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. 176 | 177 | ## Ringkasan 178 | 179 | Anda seharusnya sudah mampu menulis, menyimpan dan menjalankan program Python secara mudah. 180 | 181 | Sekarang Anda adalah pengguna Python, mari belajar beberapa konsep Python lebih lanjut. 182 | -------------------------------------------------------------------------------- /fabfile.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | from __future__ import print_function 4 | 5 | 6 | ##### Configuration ############################## 7 | 8 | import json 9 | 10 | CONFIG = json.load(open('config.json')) 11 | 12 | ## NOTES 13 | ## 1. This assumes that you have already created the S3 bucket whose name 14 | ## is stored in AWS_S3_BUCKET_NAME environment variable. 15 | ## 2. Under that S3 bucket, you have created a folder whose name is stored 16 | ## above as SHORT_PROJECT_NAME. 17 | ## 3. Under that S3 bucket, you have created a folder whose name is stored as 18 | ## SHORT_PROJECT_NAME/assets. 19 | 20 | 21 | ##### Imports #################################### 22 | 23 | 24 | import os 25 | import datetime 26 | import subprocess 27 | import copy 28 | from xmlrpclib import ServerProxy 29 | 30 | import boto 31 | import boto.s3.bucket 32 | import boto.s3.key 33 | from bs4 import BeautifulSoup 34 | 35 | from fabric.api import task, local 36 | 37 | 38 | ##### Start with checks ########################## 39 | 40 | 41 | for chapter in CONFIG['MARKDOWN_FILES']: 42 | assert (chapter['slug'].lower() == chapter['slug']), \ 43 | "Slug must be lower case : {}".format(chapter['slug']) 44 | 45 | if str(os.environ.get('AWS_ENABLED')).lower() == 'false': 46 | AWS_ENABLED = False 47 | elif os.environ.get('AWS_ACCESS_KEY_ID') is not None \ 48 | and len(os.environ['AWS_ACCESS_KEY_ID']) > 0 \ 49 | and os.environ.get('AWS_SECRET_ACCESS_KEY') is not None \ 50 | and len(os.environ['AWS_SECRET_ACCESS_KEY']) > 0 \ 51 | and os.environ.get('AWS_S3_BUCKET_NAME') is not None \ 52 | and len(os.environ['AWS_S3_BUCKET_NAME']) > 0: 53 | AWS_ENABLED = True 54 | else: 55 | AWS_ENABLED = False 56 | print("NOTE: S3 uploading is disabled because of missing " + 57 | "AWS key environment variables.") 58 | 59 | # In my case, they are the same - 'files.swaroopch.com' 60 | # http://docs.amazonwebservices.com/AmazonS3/latest/dev/VirtualHosting.html#VirtualHostingCustomURLs 61 | if AWS_ENABLED: 62 | S3_PUBLIC_URL = os.environ['AWS_S3_BUCKET_NAME'] 63 | #else 64 | #S3_PUBLIC_URL = 's3.amazonaws.com/{}'.format( 65 | #os.environ['AWS_S3_BUCKET_NAME']) 66 | 67 | 68 | if os.environ.get('WORDPRESS_RPC_URL') is not None \ 69 | and len(os.environ['WORDPRESS_RPC_URL']) > 0 \ 70 | and os.environ.get('WORDPRESS_BASE_URL') is not None \ 71 | and len(os.environ['WORDPRESS_BASE_URL']) > 0 \ 72 | and os.environ.get('WORDPRESS_BLOG_ID') is not None \ 73 | and len(os.environ['WORDPRESS_BLOG_ID']) > 0 \ 74 | and os.environ.get('WORDPRESS_USERNAME') is not None \ 75 | and len(os.environ['WORDPRESS_USERNAME']) > 0 \ 76 | and os.environ.get('WORDPRESS_PASSWORD') is not None \ 77 | and len(os.environ['WORDPRESS_PASSWORD']) > 0 \ 78 | and os.environ.get('WORDPRESS_PARENT_PAGE_ID') is not None \ 79 | and len(os.environ['WORDPRESS_PARENT_PAGE_ID']) > 0 \ 80 | and os.environ.get('WORDPRESS_PARENT_PAGE_SLUG') is not None \ 81 | and len(os.environ['WORDPRESS_PARENT_PAGE_SLUG']) > 0: 82 | WORDPRESS_ENABLED = True 83 | else: 84 | WORDPRESS_ENABLED = False 85 | print("NOTE: Wordpress uploading is disabled because of " + 86 | "missing environment variables.") 87 | 88 | 89 | ##### Helper methods ############################# 90 | 91 | 92 | def _upload_to_s3(filename, key): 93 | """http://docs.pythonboto.org/en/latest/s3_tut.html#storing-data""" 94 | conn = boto.connect_s3() 95 | b = boto.s3.bucket.Bucket(conn, os.environ['AWS_S3_BUCKET_NAME']) 96 | k = boto.s3.key.Key(b) 97 | k.key = key 98 | k.set_contents_from_filename(filename) 99 | k.set_acl('public-read') 100 | 101 | url = 'http://{}/{}'.format(S3_PUBLIC_URL, key) 102 | print("Uploaded to S3 : {}".format(url)) 103 | return url 104 | 105 | 106 | def upload_output_to_s3(filename): 107 | key = "{}/{}".format(CONFIG['SHORT_PROJECT_NAME'], 108 | filename.split('/')[-1]) 109 | return _upload_to_s3(filename, key) 110 | 111 | 112 | def upload_asset_to_s3(filename): 113 | key = "{}/assets/{}".format(CONFIG['SHORT_PROJECT_NAME'], 114 | filename.split('/')[-1]) 115 | return _upload_to_s3(filename, key) 116 | 117 | 118 | def replace_images_with_s3_urls(text): 119 | """http://www.crummy.com/software/BeautifulSoup/bs4/doc/""" 120 | soup = BeautifulSoup(text) 121 | for image in soup.find_all('img'): 122 | image['src'] = upload_asset_to_s3(image['src']) 123 | return unicode(soup) 124 | 125 | 126 | def markdown_to_html(source_text, upload_assets_to_s3=False): 127 | """Convert from Markdown to HTML; optional: upload images, etc. to S3.""" 128 | args = ['pandoc', 129 | '-f', 'markdown', 130 | '-t', 'html5'] 131 | p = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE) 132 | output = p.communicate(source_text)[0] 133 | 134 | # http://wordpress.org/extend/plugins/raw-html/ 135 | output = '\n' + output + '\n' 136 | 137 | # NOTE: Also assumes that you have added the CSS from 138 | # `pandoc -S -t html5` to the `style.css` of your active Wordpress theme. 139 | 140 | if upload_assets_to_s3: 141 | output = replace_images_with_s3_urls(output) 142 | 143 | return output 144 | 145 | 146 | def _wordpress_get_pages(): 147 | server = ServerProxy(os.environ['WORDPRESS_RPC_URL']) 148 | print("Fetching list of pages from WordPress") 149 | return server.wp.getPosts(os.environ['WORDPRESS_BLOG_ID'], 150 | os.environ['WORDPRESS_USERNAME'], 151 | os.environ['WORDPRESS_PASSWORD'], 152 | { 153 | 'post_type': 'page', 154 | 'number': pow(10, 5), 155 | }) 156 | 157 | 158 | def wordpress_new_page(slug, title, content): 159 | """Create a new Wordpress page. 160 | 161 | https://codex.wordpress.org/XML-RPC_WordPress_API/Posts#wp.newPost 162 | https://codex.wordpress.org/Function_Reference/wp_insert_post 163 | http://docs.python.org/library/xmlrpclib.html 164 | """ 165 | server = ServerProxy(os.environ['WORDPRESS_RPC_URL']) 166 | return server.wp.newPost(os.environ['WORDPRESS_BLOG_ID'], 167 | os.environ['WORDPRESS_USERNAME'], 168 | os.environ['WORDPRESS_PASSWORD'], 169 | { 170 | 'post_name': slug, 171 | 'post_content': content, 172 | 'post_title': title, 173 | 'post_parent': 174 | os.environ['WORDPRESS_PARENT_PAGE_ID'], 175 | 'post_type': 'page', 176 | 'post_status': 'publish', 177 | 'comment_status': 'closed', 178 | 'ping_status': 'closed', 179 | }) 180 | 181 | 182 | def wordpress_edit_page(post_id, title, content): 183 | """Edit a Wordpress page. 184 | 185 | https://codex.wordpress.org/XML-RPC_WordPress_API/Posts#wp.editPost 186 | https://codex.wordpress.org/Function_Reference/wp_insert_post 187 | http://docs.python.org/library/xmlrpclib.html 188 | """ 189 | server = ServerProxy(os.environ['WORDPRESS_RPC_URL']) 190 | return server.wp.editPost(os.environ['WORDPRESS_BLOG_ID'], 191 | os.environ['WORDPRESS_USERNAME'], 192 | os.environ['WORDPRESS_PASSWORD'], 193 | post_id, 194 | { 195 | 'post_content': content, 196 | 'post_title': title, 197 | }) 198 | 199 | 200 | def collect_header_anchors(chapter, i, all_headers): 201 | soup = BeautifulSoup(chapter['html']) 202 | for header in soup.find_all(['h1', 'h2', 'h3', 'h4', 'h5', 'h6']): 203 | if 'id' in header.attrs: 204 | all_headers[header['id']] = i 205 | 206 | 207 | def fix_links_to_other_chapters(chapter, chapters, all_headers): 208 | """Fix links to other sections with Wordpress page URL.""" 209 | soup = BeautifulSoup(chapter['html']) 210 | for link in soup.find_all('a'): 211 | if 'href' in link.attrs: 212 | if link['href'].startswith('#'): 213 | header_id = link['href'][1:] 214 | assert header_id in all_headers, \ 215 | "#{} does not exist, referred in {}".format( 216 | header_id, chapter['file']) 217 | other_chapter = chapters[all_headers[header_id]] 218 | link['href'] = '{}#{}'.format( 219 | other_chapter['link'], 220 | header_id) 221 | chapter['html'] = unicode(soup) 222 | 223 | 224 | def add_previous_next_links(chapter, i, chapters): 225 | previous_link = None 226 | if i > 0: 227 | previous_link = chapters[i - 1]['link'] 228 | 229 | next_link = None 230 | if i < len(chapters) - 1: 231 | next_link = chapters[i + 1]['link'] 232 | 233 | if previous_link is not None or next_link is not None: 234 | chapter['html'] += "\n" 235 | 236 | if previous_link is not None: 237 | chapter['html'] += """\ 238 | ⇐ Previous chapter\ 239 | """.format(previous_link) 240 | 241 | if previous_link is not None and next_link is not None: 242 | chapter['html'] += ' ' * 5 243 | 244 | if next_link is not None: 245 | chapter['html'] += """\ 246 | Next chapter ⇒\ 247 | """.format(next_link) 248 | 249 | 250 | ##### Tasks ###################################### 251 | 252 | 253 | @task 254 | def prepare(): 255 | frontpage = CONFIG['MARKDOWN_FILES'][0] 256 | content = open(frontpage['file']).read() 257 | # TODO Can I make this always go change the third line instead? 258 | # TODO And then go back and change it to "$$date$$" so that it 259 | # is not inadvertently committed to the git repo. 260 | content = content.replace("$$date$$", 261 | datetime.datetime.now().strftime("%d %b %Y")) 262 | with open(frontpage['file'], 'w') as output: 263 | output.write(content) 264 | 265 | 266 | @task 267 | def wp(): 268 | """https://codex.wordpress.org/XML-RPC_WordPress_API/Posts""" 269 | if WORDPRESS_ENABLED: 270 | prepare() 271 | 272 | chapters = copy.deepcopy(CONFIG['MARKDOWN_FILES']) 273 | 274 | # header anchor id -> index in MARKDOWN_FILES 275 | all_headers = {} 276 | 277 | # Render html 278 | print("Rendering html") 279 | for (i, chapter) in enumerate(chapters): 280 | chapter['html'] = markdown_to_html(open(chapter['file']).read(), 281 | upload_assets_to_s3=AWS_ENABLED) 282 | 283 | collect_header_anchors(chapter, i, all_headers) 284 | 285 | chapter['link'] = "{}/{}/{}".format( 286 | os.environ['WORDPRESS_BASE_URL'], 287 | os.environ['WORDPRESS_PARENT_PAGE_SLUG'], 288 | chapter['slug']) 289 | 290 | # Fix cross-links 291 | for chapter in chapters: 292 | fix_links_to_other_chapters(chapter, chapters, all_headers) 293 | 294 | # Add previous and next links at end of html 295 | for (i, chapter) in enumerate(chapters): 296 | add_previous_next_links(chapter, i, chapters) 297 | 298 | # Fetch list of pages on the server and determine which already exist 299 | existing_pages = _wordpress_get_pages() 300 | existing_page_slugs = [i.get('post_name') for i in existing_pages] 301 | 302 | def page_slug_to_id(slug): 303 | pages = [i for i in existing_pages if i.get('post_name') == slug] 304 | page = pages[0] 305 | return page['post_id'] 306 | 307 | for chapter in chapters: 308 | if chapter['slug'] in existing_page_slugs: 309 | chapter['page_id'] = page_slug_to_id(chapter['slug']) 310 | 311 | # Send to WP 312 | print("Uploading to WordPress") 313 | for chapter in chapters: 314 | if chapter['slug'] in existing_page_slugs: 315 | print("Existing page: {}".format(chapter['link'])) 316 | assert wordpress_edit_page(chapter['page_id'], 317 | chapter['title'], 318 | chapter['html']) 319 | else: 320 | print("New page: {}".format(chapter['link'])) 321 | assert wordpress_new_page(chapter['slug'], 322 | chapter['title'], 323 | chapter['html']) 324 | 325 | 326 | @task 327 | def html(): 328 | """HTML5 output.""" 329 | prepare() 330 | 331 | args = ['pandoc', 332 | '-f', 'markdown', 333 | '-t', 'html5', 334 | '-o', '{}.html'.format(CONFIG['FULL_PROJECT_NAME']), 335 | '-s', 336 | '--toc'] + [i['file'] for i in CONFIG['MARKDOWN_FILES']] 337 | local(' '.join(args)) 338 | local('open {}.html'.format(CONFIG['FULL_PROJECT_NAME'])) 339 | 340 | 341 | @task 342 | def epub(): 343 | """http://johnmacfarlane.net/pandoc/epub.html""" 344 | prepare() 345 | 346 | args = ['pandoc', 347 | '-f', 'markdown', 348 | '-t', 'epub', 349 | '-o', '{}.epub'.format(CONFIG['FULL_PROJECT_NAME'])] + \ 350 | [i['file'] for i in CONFIG['MARKDOWN_FILES']] 351 | # TODO --epub-cover-image 352 | # TODO --epub-metadata 353 | # TODO --epub-stylesheet 354 | local(' '.join(args)) 355 | if AWS_ENABLED: 356 | upload_output_to_s3('{}.epub'.format(CONFIG['FULL_PROJECT_NAME'])) 357 | 358 | 359 | @task 360 | def pdf(): 361 | """http://johnmacfarlane.net/pandoc/README.html#creating-a-pdf""" 362 | prepare() 363 | 364 | args = ['pandoc', 365 | '-f', 'markdown', 366 | # https://github.com/jgm/pandoc/issues/571 367 | #'-t', 'pdf', 368 | '-o', '{}.pdf'.format(CONFIG['FULL_PROJECT_NAME']), 369 | '-N', 370 | '--toc'] + [i['file'] for i in CONFIG['MARKDOWN_FILES']] 371 | local(' '.join(args)) 372 | if AWS_ENABLED: 373 | upload_output_to_s3('{}.pdf'.format(CONFIG['FULL_PROJECT_NAME'])) 374 | 375 | 376 | @task 377 | def push(): 378 | wp() 379 | epub() 380 | pdf() 381 | 382 | 383 | @task 384 | def clean(): 385 | """Remove generated output files""" 386 | possible_outputs = ( 387 | '{}.html'.format(CONFIG['FULL_PROJECT_NAME']), 388 | '{}.epub'.format(CONFIG['FULL_PROJECT_NAME']), 389 | '{}.pdf'.format(CONFIG['FULL_PROJECT_NAME']), 390 | ) 391 | 392 | for filename in possible_outputs: 393 | if os.path.exists(filename): 394 | os.remove(filename) 395 | print("Removed {}".format(filename)) 396 | -------------------------------------------------------------------------------- /08-control-flow.pd: -------------------------------------------------------------------------------- 1 | # Alur Kontrol 2 | 3 | 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? 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? 4 | 5 | Sebagaimana yang Anda bisa tebak, ini dapat dilakukan lewat statemen alur kontrol. Ada tiga macam statemen alur kontrol di Python - `if`, `for` dan `while`. 6 | 7 | ## Statemen if 8 | 9 | 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. 10 | 11 | Contoh (simpan dengan nama `if.py`): 12 | 13 | ~~~python 14 | angka = 23 15 | tebakan = int(input('Masukkan sebuah angka : ')) 16 | 17 | if tebakan == angka: 18 | print('Selamat Anda telah menebaknya') # Blok baru mulai di sini 19 | print('(Tapi tidak ada satu hadiahpun untuk Anda!)') # Blok baru berakhir di sini 20 | elif tebakan < angka: 21 | print('Tidak, angkanya sedikit lebih besar lagi') # Blok lainnya 22 | # Anda dapat melakukan apapun di blok ini ... 23 | else: 24 | print('Tidak, angkanya lebih kecil lagi') 25 | # Pesan ini keluar jika Anda menebak angka yang lebih besar 26 | 27 | print('Selesai') 28 | # Statemen terakhir ini selalu dieksekusi, setelah statemen if tersebut dijalankan. 29 | ~~~ 30 | 31 | Keluaran: 32 | 33 | ~~~ 34 | $ python3 if.py 35 | Masukkan sebuah angka : 50 36 | Tidak, angkanya lebih kecil lagi 37 | Selesai 38 | 39 | $ python3 if.py 40 | Masukkan sebuah angka : 22 41 | Tidak, angkanya sedikit lebih besar lagi 42 | Selesai 43 | 44 | $ python3 if.py 45 | Masukkan sebuah angka : 23 46 | Selamat, Anda telah menbaknya 47 | (Tapi tidak ada satu hadiahpun untuk Anda!) 48 | Selesai 49 | ~~~ 50 | 51 | Bagaimana Cara Kerjanya: 52 | 53 | 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 [bab berikutnya](#functions). 54 | 55 | 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). 56 | 57 | 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? 58 | 59 | Perhatikan bahwa jika statemen `if` berisi titik koma di akhir kalimat 0 kita mengindikasikan kepada Python bahwa blok statemen tersebut akan mengikuti. 60 | 61 | 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. 62 | 63 | Statemen `elif` dan `else` juga harus punya titik koma di akhir baris logis diikuti oleh blok statemen terkait (dengan indentasi yang benar tentu saja) 64 | 65 | Anda dapat menambahkan statemen `if` yang lain di dalam blok statemen `if` dan seterusnya - ini dinamakan statemen `if` tergabung (nested). 66 | 67 | Ingat bahwa bagian `elif` dan `else` sifatnya tidak wajib. Statemen `if` yang valid, minimal: 68 | 69 | ~~~python 70 | if True: 71 | print('Yak, itu benar') 72 | ~~~ 73 | 74 | 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. 75 | 76 | 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. 77 | 78 | Catatan untuk programer C/C++ 79 | 80 | : Tidak ada statemen `switch` di Python. Anda dapat menggunakan `if..elif..else` untuk melakukan hal yang sama (dalam beberapa kasus dapat menggunakan [dictionary](#dictionary) untuk mengerjakannya dengan cepat) 81 | 82 | ## Statemen While 83 | 84 | 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`. 85 | 86 | Contoh (simpan dengan nama`while.py`): 87 | 88 | ~~~python 89 | angka = 23 90 | jalankan = True 91 | 92 | while lari: 93 | tebak = int(input('Masukkan sebuah angka: ')) 94 | if tebak == angka: 95 | print('Selamat, Anda telah menebaknya.') 96 | jalankan = False # ini akan menyebabkan loop while-nya berhenti 97 | elif tebak < angka: 98 | print('Tidak, sedikit lebih besar dari itu.') 99 | else: 100 | print('Tidak, sedikit lebih kecil dari itu.') 101 | else: 102 | print('Loop while-nya telah selesai.') 103 | # Kerjakan hal lain yang Anda inginkan di sini. 104 | 105 | print('Selesai') 106 | ~~~ 107 | 108 | Output: 109 | 110 | ~~~ 111 | $ python3 while.py 112 | Masukkan sebuah angka: 50 113 | Tidak, sedikit lebih kecil dari itu. 114 | Masukkan sebuah angka: 22 115 | Tidak, sedikit lebih besar dari itu. 116 | Masukkan sebuah angka: 23 117 | Selamat, Anda telah menebaknya. 118 | Loop while-nya telah selesai. 119 | Selesai 120 | ~~~ 121 | 122 | Bagaimana Cara Kerjanya: 123 | 124 | 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. 125 | 126 | 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. 127 | 128 | 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`. 129 | 130 | Nilai `True` dan `False` dianggap sebagai tipe Boolean, dan Anda dapat menganggapnya memiliki nilai `1` untuk `True` dan `0` untuk `False`. 131 | 132 | Catatan untuk Programmer C/C++ 133 | 134 | : Selalu ingat bahwa Anda dapat menyisipkan klausul `else` dalam putaran `while` 135 | 136 | ## Putaran For 137 | 138 | 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](#sequence) di bab berikutnya secara detail. Apa yang pelru Anda ketahui sekarang bahwa urutan/sequence hanyalah kumpulan item berurut. 139 | 140 | Contoh (simpan dengan nama `for.py`): 141 | 142 | ~~~python 143 | for i in range(1, 5): 144 | print(i) 145 | else: 146 | print('Putaran telah selesai') 147 | ~~~ 148 | 149 | Keluaran: 150 | 151 | ~~~ 152 | $ python3 for.py 153 | 1 154 | 2 155 | 3 156 | 4 157 | Putaran telah selesai 158 | ~~~ 159 | 160 | Bagamaimana Cara Kerjanya: 161 | 162 | Dalam program ini, kita akn menampilkan *urutan* angka. Kita akan menghasilkan urutan angka ini dalam fungsi built-in dengan nama `range`. 163 | 164 | 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. 165 | 166 | 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 [[bab tentang struktur data](#data-structures)]. 167 | 168 | `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. 169 | 170 | Ingat bahwa bagian `else` sifatnya tidak wajib. Jika dimasukkan, bagian tersebut hanya akan dijalankan setelah putaran `for` selesai, kecuali ketemu statemen [break](#break). 171 | 172 | 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. 173 | 174 | Catatan untuk Programmer /C++/Java/C# 175 | 176 | : 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. 177 | 178 | Di C/C++, jika Anda ingin menulis `for (int i = 0; i < 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. 179 | 180 | ## Statemen break 181 | 182 | 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. 183 | 184 | Sebagai catatan yang cukup penting, jika Anda *menghentikan* putaran `for` atau `while`, setiap blok `else` yang terkait **tidak akan** dieksekusi. 185 | 186 | Contoh (simpan dengan nama `break.py`): 187 | 188 | ~~~python 189 | while True: 190 | s = input('Masukkan sesuatu: ') 191 | if s == 'berhenti': 192 | break 193 | print('Panjang hurufnya adalah ', len(s)) 194 | print('Selesai') 195 | ~~~ 196 | 197 | Keluaran: 198 | 199 | ~~~ 200 | $ python3 break.py 201 | Masukkan sesuatu: Programming sangat menyenangkan 202 | Panjang hurufnya adalah 31 203 | Masukkan sesuatu: Saat pekerjaan selesai 204 | Panjang hurufnya adalah 22 205 | Masukkan sesuatu: jika Anda ingin pekerjaan Anda menyenangkan: 206 | Panjang hurufnya adalah 44 207 | Masukkan sesuatu: gunakan Python! 208 | Panjang hurufnya adalah 15 209 | Masukkan sesuatu: berhenti 210 | Selesai 211 | ~~~ 212 | 213 | Bagaimana Cara Kerjanya: 214 | 215 | 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. 216 | 217 | Panjang dari string yang dimasukkan dapat dicari dengan menggunakan fungsi built-in bernama `len` 218 | 219 | Ingat bahwa statemen `break` dapat digunakan dalam putaran `for` juga. 220 | 221 | ### Puisi Python dari Swaroop 222 | 223 | Input yang saya gunakan di sini adalah puisi mini yang saya tulis dengan nama *Puisi Python Swaroop*: 224 | 225 | ~~~ 226 | Programming sangat menyenangkan 227 | Saat pekerjaan selesai 228 | jika Anda ingin pekerjaan Anda menyenangkan: 229 | gunakan Python! 230 | ~~~ 231 | 232 | ## Statemen Continue (Lanjutkan) 233 | 234 | Statemen `continue` digunakan untuk memberitahu Python agar mengabaikan statemn yang tersisa dari blok putaran yang ada saat ini, dan *melanjutkan* blok putaran berikutnya. 235 | 236 | Contoh (simpan dengan nama `continue.py`): 237 | 238 | ~~~python 239 | while True: 240 | s = input('Masukkan sesuatu: ') 241 | if s == 'berhenti': 242 | break 243 | if len(s) < 3: 244 | print('Terlalu kecil') 245 | continue 246 | print('Nilai yang Anda masukkan memiliki panjang yang cukup') 247 | # Lakukan pemrosesan lainnya di sini... 248 | ~~~ 249 | 250 | Output: 251 | 252 | ~~~ 253 | $ python3 continue.py 254 | Masukkan sesuatu: a 255 | Terlalu kecil 256 | Masukkan sesuatu: 12 257 | Terlalu kecil 258 | Masukkan sesuatu: abc 259 | Nilai yang Anda masukkan memiliki panjang yang cukup 260 | Masukkan sesuatu: quit 261 | ~~~ 262 | 263 | Bagaimana Cara Kerjanya: 264 | 265 | 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. 266 | 267 | Catat bahwa statemen `continue` juga bisa jalan untuk putaran `for`. 268 | 269 | ## Ringkasan 270 | 271 | Kita telah melihat bagaimana menggunakan tiga statemen alur kontrol - `if`, `while` 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. 272 | 273 | Berikutnya, kita akan melihat bagaimana membuat dan menggunakan fungsi. 274 | -------------------------------------------------------------------------------- /10-modules.pd: -------------------------------------------------------------------------------- 1 | # Modul 2 | 3 | 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. 4 | 5 | Ada beberapa metode dalam menulis modul, tapi cara yang paling mudah adalah membuat file dengan ekstensi `.py` yang berisi fungsi dan variabel. 6 | 7 | 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](http://docs.python.org/py3k/extending/index.html) dan saat selesai dikompilasi, modul tersebut dapat digunakan dalam kode Python Anda dengan menggunakan interpreter Python standar. 8 | 9 | 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. 10 | 11 | Contoh (simpan dengan nama `pakai_sys.py`): 12 | 13 | ~~~python 14 | import sys 15 | 16 | print('Argumen baris perintahnya adalah:') 17 | for i in sys.argv: 18 | print(i) 19 | 20 | print('\n\n PYTHONPATH yang ditentukan adalah ', sys.path, '\n') 21 | ~~~ 22 | 23 | Keluaran: 24 | 25 | ~~~ 26 | $ python3 pakai_sys.py ini argumen kami 27 | Argumen baris perintahnya adalah: 28 | pakai_sys.py 29 | ini 30 | argumen 31 | kami 32 | 33 | PYTHONPATH yang ditentukan adalah ['', 'C:\\Windows\\system32\\python30.zip', 34 | 'C:\\Python30\\DLLs', 'C:\\Python30\\lib', 35 | 'C:\\Python30\\lib\\plat-win', 'C:\\Python30', 36 | 'C:\\Python30\\lib\\site-packages'] 37 | ~~~ 38 | 39 | Bagaimana Cara Kerjanya: 40 | 41 | 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 *sys*tem. 42 | 43 | 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. 44 | 45 | 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. 46 | 47 | 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. 48 | 49 | Variabel `sys.argv` berisi *list* string (lists dijelaskan lebih detail di [bab berikutnya](#struktur-data)). 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. 50 | 51 | Jika Anda menggunakan IDE untuk menulis dan menjalankan program ini, cari cara untuk menambahkan argumen program dari menu. 52 | 53 | 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. 54 | 55 | 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. 56 | 57 | `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`. 58 | 59 | Catat bahwa direktori saat ini adalah direktori tempat program ini dijalankan. Jalankan `import os; print(os.getcwd())` untuk mencari direktori program Anda saat ini. 60 | 61 | ## Berkas Byte-compiled .pyc 62 | 63 | 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](#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). 64 | 65 | Catatan 66 | 67 | : 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. 68 | 69 | ## Statemen from ... import 70 | 71 | 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`. 72 | 73 | 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. 74 | 75 | Contoh: 76 | 77 | ~~~python 78 | from math import sqrt 79 | print("Akar dari 16 adalah ", sqrt(16)) 80 | ~~~ 81 | 82 | ## __name__ di Dalam Modul 83 | 84 | 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. 85 | 86 | Contoh (simpan dengan nama `pakai_nama.py`): 87 | 88 | ~~~python 89 | if __name__ == '__main__': 90 | print('Program ini dijalankan sendiri') 91 | else: 92 | print('Saya diimpor dari modul lain') 93 | ~~~ 94 | 95 | Keluaran: 96 | 97 | ~~~ 98 | $ python3 pakai_nama.py 99 | Program ini dijalankan sendiri 100 | 101 | $ python3 102 | >>> import pakai_nama 103 | Saya diimpor dari modul lain 104 | >>> 105 | ~~~ 106 | 107 | Bagaimana Cara Kerjanya: 108 | 109 | 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. 110 | 111 | ## Membuat Modul Anda Sendiri 112 | 113 | 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. 114 | 115 | Contoh (simpan dengan nama `modulku.py`): 116 | 117 | ~~~python 118 | def katakanhai(): 119 | print('Hai, ini modulku berbicara.') 120 | 121 | __version__ = '0.1' 122 | ~~~ 123 | 124 | 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. 125 | 126 | Ingat bahwa modul harus diletakkan pada direktori yang sama dengan program yang mengimpornya, atau salah satu dari direktori yang terdaftar di `sys.path`. 127 | 128 | Modul lain (simpan dengan nama `demo_modulku.py`): 129 | 130 | ~~~python 131 | import modulku 132 | 133 | modulku.katakanhai() 134 | print ('Versi', modulku.__version__) 135 | ~~~ 136 | 137 | Keluaran: 138 | 139 | ~~~ 140 | $ python3 demo_modulku.py 141 | Hai, ini modulku berbicara. 142 | Versi 0.1 143 | ~~~ 144 | 145 | Bagaimana Cara Kerjanya: 146 | 147 | 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. 148 | 149 | Berikut versi yang menggunakan sintaks `from..import` (simpan dengan nama demo2_modulku.py): 150 | 151 | ~~~python 152 | from modulku import katakanhai, __version__ 153 | 154 | katakanhai() 155 | print('Versi', __version__) 156 | ~~~ 157 | 158 | Keluaran `demo2_modulku.py` sama dengan keluaran `demo_modulku.py`. 159 | 160 | 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. 161 | 162 | Anda dapat juga menggunakan: 163 | 164 | ~~~python 165 | from modulku import * 166 | ~~~ 167 | 168 | Ini akan mengimpor seluruh nama publik seperti `katakanhai` tapi tidak akan mengimpor `__version__` karena nama tersebut diawali dengan dua garis bawah. 169 | 170 | Zen of Python 171 | 172 | : 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](http://stackoverflow.com/questions/228181/zen-of-python) yang membuat daftar contoh dari masing-masing prinsip. 173 | 174 | ## Fungsi dir 175 | 176 | 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. 177 | 178 | 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. 179 | 180 | Contoh: 181 | 182 | ~~~ 183 | $ python3 184 | 185 | >>> import sys # mengambil seluruh atribut, dalam kasus ini, dari modul sys 186 | 187 | >>> dir(sys) 188 | ['__displayhook__', '__doc__', '__excepthook__', '__name__', '__package__', '__s 189 | tderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_compact_freelists', 190 | '_current_frames', '_getframe', 'api_version', 'argv', 'builtin_module_names', ' 191 | byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle' 192 | , 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 193 | 'exit', 'flags', 'float_info', 'getcheckinterval', 'getdefaultencoding', 'getfil 194 | esystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 195 | 'gettrace', 'getwindowsversion', 'hexversion', 'intern', 'maxsize', 'maxunicode 196 | ', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platfor 197 | m', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setprofile', 'setrecursionlimit 198 | ', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_in 199 | fo', 'warnoptions', 'winver'] 200 | 201 | >>> dir() # menampilkan daftar seluruh atribut dari modul yang sedang dijalankan 202 | ['__builtins__', '__doc__', '__name__', '__package__', 'sys'] 203 | 204 | >>> a = 5 # membuat variabel baru 'a' 205 | 206 | >>> dir() 207 | ['__builtins__', '__doc__', '__name__', '__package__', 'a', 'sys'] 208 | 209 | >>> del a # menghapus nama a 210 | 211 | >>> dir() 212 | ['__builtins__', '__doc__', '__name__', '__package__', 'sys'] 213 | 214 | >>> 215 | ~~~ 216 | 217 | Bagaimana Cara Kerjanya: 218 | 219 | Pertama, kita lihat penggunaan `dir` dari modul `sys` yang telah diimpor sebelumnya. Kita lihat banyak sekali daftar atribut yang ada di dalamnya. 220 | 221 | 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. 222 | 223 | 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`. 224 | 225 | 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. 226 | 227 | 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. 228 | 229 | ## Paket 230 | 231 | 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. 232 | 233 | 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. 234 | 235 | 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. 236 | 237 | Begini seharusnya struktur di dalam folder: 238 | 239 | ~~~ 240 | - / 241 | - world/ 242 | - __init__.py 243 | - asia/ 244 | - __init__.py 245 | - india/ 246 | - __init__.py 247 | - foo.py 248 | - afrika/ 249 | - __init__.py 250 | - madagaskar/ 251 | - __init__.py 252 | - bar.py 253 | ~~~ 254 | 255 | Paket hanyalah berupa cara yang nyaman untuk menata modul secara lebih teroganisir. Anda dapat lihat contoh-contohnya dalam [pustaka standar](#pustaka-standar). 256 | 257 | ## Ringkasan 258 | 259 | 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. 260 | 261 | Kita telah melihat bagaimana menggunakan modul ini dan membuat modul kita sendiri. 262 | 263 | Berikutnya, kita akan belajar konsep menarik lainnya yang bernama struktur data. 264 | -------------------------------------------------------------------------------- /06-basics.pd: -------------------------------------------------------------------------------- 1 | # Dasar 2 | 3 | Hanya menampilkan 'Hello World' tentu saja tidak cukup bukan? Anda ingin melakukan sesuatu lebih dari itu - misalnya mengambil beberapa masukan, mengubah, memproses dan mengeluarkannya dalam bentuk tertentu. Kita dapat melakukan ini di Python dengan menggunakan konstanta dan variabel, dan kita betul-betul akan belajar konsep ini dalam bab berikut. 4 | 5 | ## Komentar 6 | 7 | *Komentar* adalah teks apa saja yang ada setelah tanda `#` dan utamanya digunakan sebagai catatan untuk pembaca program. 8 | 9 | Sebagai contoh: 10 | 11 | ~~~python 12 | print('Hello World') # Mohon dicatat bahwa print adalah fungsi 13 | ~~~ 14 | 15 | atau: 16 | 17 | ~~~python 18 | # Mohon dicatat bahwa print adalah fungsi 19 | print('Hello World') 20 | ~~~ 21 | 22 | Gunakan komentar yang bermanfaat di dalam program sebanyak mungkin yang Anda bisa untuk: 23 | 24 | - menjelaskan asumsi 25 | - menjelaskan keputusan penting 26 | - menjelaskan detail yang penting 27 | - menjelaskan masalah yang coba Anda pecahkan 28 | - menjelaskan masalah yang Anda coba atasi di dalam program, dll. 29 | 30 | [*Kode menunjukkan bagaimana, sedangkan komentar menunjukkan kepada Anda mengapa.*](http://www.codinghorror.com/blog/2006/12/code-tells-you-how-comments-tell-you-why.html) 31 | 32 | Hal ini bermanfaat bagi pembaca program Anda sehingga mereka dapat memahami dengan mudah apa yang sedang dikerjakan oleh program. Ingat, bahwa orang yang membaca tersebut bisa jadi Anda sendiri 6 bulan kemudian. 33 | 34 | ## Konstanta Literal 35 | 36 | Contoh konstanta literal adalah nomor seperti `5`, `1.23`, atau string seperti `'Ini adalah string'` atau `"Ini, adalah string!"`. Disebut sebagai literal karena ia memang *literal* - Anda dapat menggunakan nilainya sebagaimana yang dituliskan (secara literal). Angka `2` selalu merepresentasikan dirinya sendiri, dan bukan hal lain - Ia merupakan *konstanta* karena nilainya tidak dapat diganti. Inilah kenapa semua ini disebut sebagai konstanta literal. 37 | 38 | ## Nomor 39 | 40 | Nomor biasanya digunakan dalam dua bentuk - integer dan float. 41 | 42 | Contoh integer misalnya `2` di mana semuanya adalah angka. 43 | 44 | Contoh dari angka floating point (atau sering disebut *float*) adalah `3.23` dan `52.3E-4`. Notasi `E` mengindikasikan basis 10. Dalam hal ini, `52.3E4` merarti `52.3 * 10^-4^`. 45 | 46 | Catatan untuk Programmer Berpengalaman 47 | 48 | : Tidak ada pembedaan untuk tipe `long`. Tipe `int` dapat digunakan sebagai integer dalam ukuran berapapun. 49 | 50 | ## String 51 | 52 | String adalah urutan *karakter*. String pada dasarnya adalah kumpulan huruf. 53 | 54 | Anda akan menggunakan string di hampir setiap program Python yang Anda tulis, jadi perhatikan baik-baik bagian berikut ini. 55 | 56 | ### Tanda Kutip 57 | 58 | Anda dapat menetukan string dengan tanda kutip seperti `'Kutip saya di sini'`. Setiap spasi kosong seperti spasi dan tab akan ditampilkan sebagaimana adanya. 59 | 60 | ### Kutip Ganda 61 | 62 | String dalam kutip ganda akan bekerja mirip seperti tanda kutip tunggal. Sebagai contoh `"Siapa nama Anda?"` 63 | 64 | ### Kutip Tiga 65 | 66 | Anda dapat menentukan string lebih dari satu baris dengan menggunakan kutip tiga - (`"""` atau `'''`). Anda dapat menggunakan tanda kutip dan kutip ganda secara bebas di dalam kutip tiga. Sebagai contoh: 67 | 68 | ~~~python 69 | '''Ini adalah string lebih dari satu baris. Ini adalah baris pertama. 70 | Ini baris kedua. 71 | "Siapa nama Anda?," Tanyaku. 72 | Dia bilang "Bond, James Bond." 73 | ''' 74 | ~~~ 75 | 76 | ### String bersifat Abadi (Immutable) 77 | 78 | Ini berarti sekali Anda membuat string, Anda tidak dapat mengubahnya. Meskipun ini terlihat jelek, tapi sebetulnya tidak. Kita akan memeriksa kenapa hal ini bukanlah batasan di beberapa program yang akan kita lihat kemudian. 79 | 80 | Catatan untuk Programmer C/C++ 81 | 82 | : Tidak ada pemisahan tipe data `char` di Python. Hal itu tidak diperlukan dan saya yakin Anda tidak akan merasa kehilangannya. 83 | 84 | Catatan untuk Programmer Perl/PHP 85 | 86 | : Ingat bahwa string bertanda kutip tunggal maupun ganda, adalah sama - mereka tidak berbeda sama sekali. 87 | 88 | ### Metode Format 89 | 90 | Kadang kita ingin menyusun string dari informasi lain. Ini tempat di mana metode `format()` berguna. 91 | 92 | Simpan baris berikut sebagai berkas bernama `str_format.py`: 93 | 94 | ~~~python 95 | usia = 20 96 | nama = 'Swaroop' 97 | 98 | print('{0} masih {1} tahun ketika dia menulis buku ini'.format(name, age)) 99 | print('Kenapa {0} bermain-main dengan python?'.format(name)) 100 | ~~~ 101 | 102 | Keluaran: 103 | 104 | ~~~ 105 | $ python3 str_format.py 106 | Swaroop masih 20 tahun ketika dia menulis buku ini 107 | Kenapa Swaroop bermain-main dengan python? 108 | ~~~ 109 | 110 | Bagaimana Cara Kerjanya: 111 | 112 | String menggunakan ketentuan khusus, dan dapat diulang, metode *format* dapat dipanggil untuk menggantikan argumen yang ada di dalam format. 113 | 114 | Coba perhatikan penggunaan pertama, di mana kita menggunakan `{0}` dan ini terkait dengan variabel `nama` yang merupakan argumen pertama dari metode `format`. Dan selanjutnya juga mirip, ketentuan berikutnya adalah `{1}` yang tersambung ke `usia` yang merupakan arguman kedua dari metode format. Mohon dicatat bahwa Python mulai penghitungan dari 0 yang berarti posisi pertama dalam indeks ini adalah 0, kedua adalah indeks 1 dan seterusnya. 115 | 116 | Mohon dicatat bahwa kita dapat memperoleh hasil yang sama dengan penggabungan string (string concatenation): `nama + ' berusia ' + str(usia) + ' tahun'` tapi ini lebih jelek dan lebih banyak kemungkinan salah. Kedua, konversi ke string dapat dilakukan secara otomatis lewat metode `format` daripada konversi eksplisit ke dalam string yang dibutuhkan dalam kasus ini. Ketiga, kita dapat menggunakan metode `format`, kita dapat mengubah pesan tanpa harus berurusan bagaimana variable tersebut digunakan dan sebaliknya. 117 | 118 | Juga catat bahwa nomor tersebut sifatnya pilihan, jadi Anda dapat menuliskannya dengan: 119 | 120 | ~~~python 121 | usia = 20 122 | nama = 'Swaroop' 123 | 124 | print('{} masih {} tahun ketika dia menulis buku ini'.format(name, age)) 125 | print('Kenapa {} bermain-main dengan python?'.format(name)) 126 | ~~~ 127 | 128 | yang akan menghasilkan output yang sama persis dengan program sebelumnya. 129 | 130 | Apa yang Python lakukan dalam metode `format` merupakan pengganti nilai tiap-tiap argumen yang diletakkan dalam bentuk dan aturan yang khusus. Aturan yang lebih detail misalnya: 131 | 132 | ~~~python 133 | desimal (.) presisi 3 untuk float '0.333' 134 | >>> '{0:.3}'.format(1/3) 135 | isi dengan garis bawah (_) dengan teks ditengah 136 | (^) dengan panjang 11 '___halo___' 137 | >>> '{0:_^11}'.format('halo') 138 | basis-kata kunci 'Swaroop menulis A Byte of Python' 139 | >>> '{nama} menulis {buku}'.format(nama='Swaroop', buku='A Byte of Python') 140 | ~~~ 141 | 142 | ## Variabel 143 | 144 | Penggunaan konstanta literal segera membuat kita bosan - kita ingin mencari cara bagaimana menyimpan informasi dan juga memanipulasinya. Segera sesuatu bernama *variabel* muncul dalam bayangan. Variabel persei seperti namanya - nilainya sangat beragam, dengan kata lain Anda dapat menyimpan apa saja dengan menggunakan variabel. Variabel seetulnya hanyalah merupakan bagian dari memori komputer tempat Anda menyimpan beberapa informasi. Tidak seperti konstanta literal, Anda perlu beberapa metode untuk mengakses nilai variabel ini, sehingga Anda perlu menamainya. 145 | 146 | ## Nama Penunjuk Identitas 147 | 148 | Variabiel adalah contoh penunjuk identitas. *Penunjuk Identitas* disematkan untuk suatu nama yang memberikan identitas terhadap *sesuatu*. Ada beberapa aturan yang harus diikuti untuk memberi nama identitas. 149 | 150 | - Karakter pertama dari identitas harus huruf (huruf besar ASCII atau huruf kecil ASCII atau karakter Unicode) atau garis bawah ('_') 151 | - Karakter sisa dari nama penanda identtitas dapat terdiri dari huruf (huruf besar ASCII atau huruf kecil ASCII atau karakter Unicode), garis bawah ('_') atau digit (0-9). 152 | - Penanda identitas bersifat case-sensitive (peka terhadap huruf besar dan kecil). Sebagai contoh, `namaku` dan `Namaku` *tidak sama*. Perhatikan huruf kecil `n` pada kata pertama dan huruf besar `N` pada kata kedua. 153 | - Contoh dari penanda identitas yang *valid* adalah `i`, `__nama_ku`,`nama_23`. Contoh penanda identitas yang ''invalid'' adalah `2hal`,`ini dengan spasi`,`nama-ku`,`>a1b2_c3` dan `"ini_dalam_tanda_kutip"`. 154 | 155 | ## Tipe Data 156 | 157 | Variabel dapat menyimpan nilai dari jenis data yang berbeda-beda yang dinamakan **tipe data**. Tipe dasarnya adalah nomor dan string, yang kita sudah diskusikan sebelumnya. Di bab berikutnya, kita akan lihat bagaimana menciptakan tipe data kita sendiri dengan menggunakan [classes](#object-oriented-programming). 158 | 159 | ## Objek 160 | 161 | Ingat, Python mereferensikan segala sesuatu yang digunakan di dalam program sebagai *objek*. Ini hanya dimaksudkan untuk perasaan umum saja. Alih-alih menyebut '*sesuatu*' kita sebut '*objek*'. 162 | 163 | Catatan untuk pengguna Pemrograman Berorientasi Objek (Object Oriented Programming) 164 | 165 | : Python sangat kuat di dalam orientasi objek. Segala sesuatu adalah objek termasuk nomor, string dan fungsi. 166 | 167 | Kita akan melihat bagaimana menggunakan variabel sejalan dengan konstanta literal. Simpan contoh berikut dan jalankan programnya. 168 | 169 | ## Bagaimana menulis program Python 170 | 171 | Cara yang baku untuk menyimpan dan menjalankan program Python adalah seperti ini: 172 | 173 | #. Buka editor pilihan Anda, seperti Komodo Edit. 174 | #. Ketik kode program seperti yang diberikan dalam contoh. 175 | #. Simpan sebagai berkas dengan nama seperti yang disebutkan. 176 | #. Jalankan interpreter dengan perintah `python3 program.py` untuk menjalankan program 177 | 178 | ## Contoh: Menggunakan Variabel dan Konstanta Literal. 179 | 180 | ~~~python 181 | Filename : var.py 182 | i = 5 183 | print(i) 184 | i = i + 1 185 | print(i) 186 | 187 | s = '''Ini adalah string dengan baris lebih dari satu. 188 | Ini baris kedua.''' 189 | print(s) 190 | ~~~ 191 | 192 | Keluaran: 193 | 194 | ~~~ 195 | $ python3 var.py 196 | 5 197 | 6 198 | Ini adalah string dengan baris lebih dari satu. 199 | Ini baris kedua. 200 | ~~~ 201 | 202 | Bagaimana cara kerjanya: 203 | 204 | Berikut bagaimana program tersebut bekerja. Pertama, kita tentukan nilai konstanta literalnya `5` ke dalam variabel `i` lewat penentuan operator (`=`). Baris ini disebut statemen/pernyataan sebab menyatakan sesuatu yang harus dikerjakan. Didalam kasus ini, kita menghubungkan variabel bernama `i` dengan nilai `5`. Kemudian kita menampilkan nilai `i` dengan fungsi `print` yang secara mengejutkan hanya menampilkan nilai variabel ke dalam layar. 205 | 206 | Kemudian kita menambahkan `1` ke dalam nilai yang disimpan di dalam `i` dan menyimpannya lagi. Kemudian kita menampilkannya lagi, dan seperti yang sudah kita duga, kita mendapatkan nilai `6`. 207 | 208 | Berikutnya juga mirip, kita menentukan string literal ke dalam variabel `s` lalu menampilkannya. 209 | 210 | Catatan untuk programmer bahasa statik 211 | 212 | : Variabel digunakan hanya untuk memberikan nilai terhadapnya. Tidak perlu menggunakan deklarasi atau definisi tipe data. 213 | 214 | ### Baris Logis dan Fisik 215 | 216 | Baris fisik adalah apa yang Anda *lihat* saat Anda menulis program. Sedangkan baris logis adalah apa yang *Python lihat* sebagai suatu statemen tunggal. Python secara implisit mengasumsikan bahwa setiap *baris fisik* berhubungan dengan *baris logis*. 217 | 218 | Sebagai contoh baris logis dalam statemen seperti `print('Hello World')` - jika ini berada dalam satu baris dirinya sendiri (sebagaimana yang Anda lihat di editor), maka ini juga berhubungan dengan baris fisik. 219 | 220 | Secara implisit, Python mendorong penggunaan statemen tunggal per baris yang dapat membuat kode lebih terbaca. 221 | 222 | Jika Anda ingin menentukan lebih dari satu baris logis dalam satu baris fisik, Anda harus secara spesifik menentukannya dalam titik koma (`;`) yang mengindikasikan akhir dari baris logis/statemen. Sebagai contoh, 223 | 224 | ~~~python 225 | i = 5 226 | print(i) 227 | ~~~ 228 | 229 | secara efektif sama dengan 230 | 231 | ~~~python 232 | i = 5; 233 | print(i); 234 | ~~~ 235 | 236 | dan sama juga jika ditulis dengan 237 | 238 | ~~~python 239 | i = 5; print(i); 240 | ~~~ 241 | 242 | bahkan sama juga dengan 243 | 244 | ~~~python 245 | i = 5; print(i) 246 | ~~~ 247 | 248 | Bagaimanapun juga, saya *sangat menyarankan* Anda tetap **menulis hingga maksimum satu baris untuk satu logika tunggal dalam satu baris fisik**. Idenya Anda tidak pernah menggunakan titik koma. Faktanya, saya *tidak pernah* atau melihat titik koma di program Python. 249 | 250 | Ada satu kondisi di mana konsep ini sangat bermanfaat: jika Anda memiliki baris kode yang panjang, Anda dapat memecahnya ke dalam bberapa baris fisik dengan menggunakan garis miring terbalik (backslash). Ini direferensikan dengan nama **penggabungan baris eksplisit**: 251 | 252 | ~~~python 253 | s = 'Ini adalah string. \ 254 | Ini melanjutkan string.' 255 | print(s) 256 | ~~~ 257 | 258 | Perintah tersebut akan menghasilkan keluaran: 259 | 260 | ~~~ 261 | Ini adalah string. Ini melanjutkan string. 262 | ~~~ 263 | 264 | Mirip dengan hal tersebut, 265 | 266 | ~~~python 267 | print\ 268 | (i) 269 | ~~~ 270 | 271 | sama dengan 272 | 273 | ~~~python 274 | print(i) 275 | ~~~ 276 | 277 | Kadang, muncul asumsi implisit yang tidak membutuhkan garis miring terbalik. Dalam kasus ini di mana baris logisnya dimulai dengan kurung kurawal, dimulai dengan kurung kotak atau dimulai dengan curly braces (~), tapi tidak diletakkan di akhir baris. Ini dinamakan **penggabungan baris implisit***. Anda dapat melihat penerapan hal ini saat kita menulis program dengan menggunakan [lists](#list) di bab berikutnya. 278 | 279 | ### Indentasi 280 | 281 | Spasi sangat penting di Python. Sebetulnya, **spasi di awal baris sangat penting**. Ini dinamakan **indentasi**. Setiap baris logika yang diawali dengan spasi kosong (baik spasi maupun tabs) digunakan untuk menentukan level indentasi dari baris logika, dan pada akhirnya digunakan untuk menentukan kelompok statemen. 282 | 283 | Ini berarti bahwa statemen yang dijalankan secara bersamaan **harus** punya indentasi yang sama. Setiap set statemen/pernyataan dinamakan **blok*. Kita akan melihat contoh bagaimana pentingnya blok di bab berikutnya. 284 | 285 | Satu hal yang perlu Anda ingat adalah indentasi yang salah akan menimbulkan pesan kesalahan. Sebagai contoh: 286 | 287 | ~~~python 288 | i = 5 289 | print('Nilainya adalah ', i) # Salah! Perhatikan spasi tunggal di awal baris. 290 | print('Saya ulangi, nilainya adalah ', i) 291 | ~~~ 292 | 293 | Ketika Anda menjalankan ini, Anda akan mendapatkan pesan kesalahan: 294 | 295 | ~~~ 296 | File "whitespace.py", line 4 297 | print('Nilainya adalah ', i) # Salah! Perhatikan spasi tunggal di awal baris. 298 | ^ 299 | IndentationError: unexpected indent 300 | ~~~ 301 | 302 | Perhatikan ada satu spasi kosong di awal baris kedua. Pesan kesalahan ini diindikasikan oleh Python, dengan mengatakan bahwa sintaks programnya tidak valid atau dengan kata lain program tidak ditulis dengan benar. Ini berarti bahwa *Anda tidak dapat sembarangan memulai blok atau statemen* (kecuali untuk blok utama yang secara default digunakan terus, tentu saja). Dalam kasus Anda dapat menggunakan blok baru, akan dijelaskan secara lebih detail dalam bab berikutnya seperti dalam [Arus Kontrol](#control-flow) 303 | 304 | Bagaimana Melakukan Indentasi 305 | 306 | : Selalu gunakan spasi untuk indentasi, dengan pemberhentian tapnya 4 spasi. Editor yang baik seperti Komodo Edit akan secara otomatis melakukan hal ini untuk Anda. Pastikan Anda menggunakan jumlah spasi yang konsisten untuk identasi, atau program Anda akan menampilkan pesan kesalahan. 307 | 308 | Catatan untuk programmer bahasa statik 309 | 310 | : Python akan selalu menggunakan indentasi untuk blok dan tidak pernah menggunakan kurung kurawal. Jalankan `from __future__ import braces` untuk mempelajari lebih jauh. 311 | 312 | ## Rangkuman 313 | 314 | Sekarang kita telah melewati banyak pernik-pernik detail, dan kita dapat melanjutkan untuk hal-hal yang lebih menarik seperti statemen pengatur arus (control flow statements). Pastikan Anda sudah nyaman dengan apa yang Anda baca di bab ini. 315 | -------------------------------------------------------------------------------- /09-functions.pd: -------------------------------------------------------------------------------- 1 | # Fungsi 2 | 3 | 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 *pemanggilan* terhadap fungsi. Kita sudah pernah menggunakan beberapa fungsi yang sudah tertanam secara baku seperti `len` dan `range`. 4 | 5 | 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. 6 | 7 | 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: 8 | 9 | Contoh (simpan dengan nama `fungsi1.py`): 10 | 11 | ~~~python 12 | def apaKabar(): 13 | print('Apa kabar dunia!') # blok ini milik fungsi apaKabar() 14 | # Akhir fungsi 15 | 16 | apaKabar() # memanggil fungsi 17 | apaKabar() # memanggil fungsi sekali lagi 18 | ~~~ 19 | 20 | Keluaran: 21 | 22 | ~~~ 23 | $ python3 fungsi1.py 24 | Apa kabar dunia! 25 | Apa kabar dunia! 26 | ~~~ 27 | 28 | Bagaimana Cara Kerjanya: 29 | 30 | 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. 31 | 32 | Perhatikan bahwa kita dapat memanggil fungsi dua kali, yang artinya kita tidak perlu menuliskan kode yang sama lagi untuk menginginkan keluaran sama. 33 | 34 | ## Parameter Fungsi 35 | 36 | 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. 37 | 38 | 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*. 39 | 40 | Contoh (simpan dengan nama `func_param.py`): 41 | 42 | ~~~python 43 | def printMaks(a, b): 44 | if a > b: 45 | print(a, 'adalah angka tertinggi') 46 | elif a == b: 47 | print(a, 'adalah sama dengan', b) 48 | else: 49 | print(b, 'adalah angka tertinggi') 50 | 51 | printMaks(3, 4) # langsung diberikan nilai terhadap parameter a dan b saat fungsi dipanggil 52 | 53 | x = 5 54 | y = 7 55 | 56 | printMax(x, y) # memberi variabel sebagai argumen. Variabel ini harus didefinisikan dulu sebelumnya. 57 | ~~~ 58 | 59 | Keluaran: 60 | 61 | ~~~ 62 | $ python3 func_param.py 63 | 4 adalah angka tertinggi 64 | 7 adalah angka tertinggi 65 | ~~~ 66 | 67 | Bagaimana Cara Kerjanya: 68 | 69 | 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. 70 | 71 | 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. 72 | 73 | ## Variabel Lokal 74 | 75 | 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. 76 | 77 | Contoh (simpan dengan nama `func_local.py`): 78 | 79 | ~~~python 80 | x = 50 81 | 82 | def func(x): 83 | print('x adalah', x) 84 | x = 2 85 | print('Mengganti nilai lokal x ke ', x) 86 | 87 | func(x) 88 | print('x masih tetap', x) 89 | ~~~ 90 | 91 | Keluaran: 92 | 93 | ~~~ 94 | $ python3 func_local.py 95 | x adalah 50 96 | Mengganti nilai lokal x ke 2 97 | x masih tetap 50 98 | ~~~ 99 | 100 | Bagaimana Cara Kerjanya: 101 | 102 | 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. 103 | 104 | 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. 105 | 106 | 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. 107 | 108 | ## Menggunakan Statemen Global 109 | 110 | 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`. 111 | 112 | 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. 113 | 114 | Contoh (simpan dengan nama `func_global.py`): 115 | 116 | ~~~python 117 | x = 50 118 | 119 | def func(): 120 | global x 121 | 122 | print('x adalah ', x) 123 | x = 2 124 | print('Mengganti nilai global x ke', x) 125 | 126 | func() 127 | print('Nilai dari x adalah ', x) 128 | ~~~ 129 | 130 | Keluaran: 131 | 132 | ~~~ 133 | $ python3 func_global.py 134 | x adalah 50 135 | Mengganti nilai global x ke 2 136 | Nilai dari x adalah 2 137 | ~~~ 138 | 139 | Bagaimana Cara Kerjanya: 140 | 141 | 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. 142 | 143 | Anda dapat menentukan lebih dari satu variabel global, dengan menggunakan statemen `global` yang sama, misalnya `global x, y, z`. 144 | 145 | ## Nilai Argumen Baku 146 | 147 | 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 (`=`). 148 | 149 | 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. 150 | 151 | Contoh (simpan dengan nama `func_default.py`): 152 | 153 | ~~~python 154 | def katakan(pesan, kali = 1): 155 | print(pesan * kali) 156 | 157 | katakan('Apakabar') 158 | katakan('Dunia', 5) 159 | ~~~ 160 | 161 | Keluaran: 162 | 163 | ~~~ 164 | $ python3 func_default.py 165 | Apakabar 166 | DuniaDuniaDuniaDuniaDunia 167 | ~~~ 168 | 169 | Bagaimana Cara Kerjanya: 170 | 171 | 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`. 172 | 173 | 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. 174 | 175 | Penting 176 | 177 | : 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. 178 | 179 | 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*. 180 | 181 | ## Argumen Kata Kunci 182 | 183 | 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. 184 | 185 | 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. 186 | 187 | Contoh (simpan dengan nama `func_key.py`): 188 | 189 | ~~~python 190 | def func(a, b=5, c=10): 191 | print('a adalah ', a, ' dan b adalah ', b, ' dan c adalah ', c) 192 | 193 | func(3, 7) 194 | func(25, c=24) 195 | func(c=50, a=100) 196 | ~~~ 197 | 198 | Keluaran: 199 | 200 | ~~~ 201 | $ python3 func_key.py 202 | a adalah 3 dan b adalah 7 dan c adalah 10 203 | a adalah 25 dan b adalah 5 dan c adalah 24 204 | a adalah 100 dan b adalah 5 dan c adalah 50 205 | ~~~ 206 | 207 | Bagaimana Cara Kerjanya: 208 | 209 | Fungsi tersebut bernama `func` dan hanya punya satu parameter tanpa nilai argumen baku, diikuti oleh dua parameter dengan nilai argumen baku. 210 | 211 | Pada penggunaan pertama, `func(3, 7)`, parameter `a` memperoleh nilai `3`, parameter `b` memeperoleh nilai `7` dan `c` memperoleh nilai baku `10`. 212 | 213 | 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`. 214 | 215 | 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. 216 | 217 | ## Parameter VarArgs 218 | 219 | Kadang Anda ingin mendefinisikan fungsi yang dapat mengambil parameter dalam jumlah *berapapun*, ini dapat dilakukan dengan menggunakan tanda bintang (simpan dengan nama `total.py`): 220 | 221 | ~~~python 222 | def total(awal=5, *angkas, **kuncis): 223 | hitung = awal 224 | for angka in angkas: 225 | hitung += angka 226 | for kunci in kuncis: 227 | hitung += kuncis[kunci] 228 | return hitung 229 | 230 | print(total(10, 1, 2, 3, sayur=50, buah=100)) 231 | ~~~ 232 | 233 | Keluaran: 234 | 235 | ~~~ 236 | $ python3 total.py 237 | 166 238 | ~~~ 239 | 240 | Bagaimana Cara Kerjanya: 241 | 242 | Ketika kita mendefinisikan parameter bintang seperti `*param`, maka seluruh argumen setelahnya akan dikumpulkan ke dalam tuple yang disebut `param`. 243 | 244 | 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`. 245 | 246 | Kita akan eksplorasi tentang tuples dan dictionaries di [bab berikutnya](#data-structures). 247 | 248 | ## Parameter Hanya-Kata-kunci 249 | 250 | 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`): 251 | 252 | ~~~python 253 | def total(awal=5, *angkas, angka_tambahan): 254 | hitung = awal 255 | for angka in angkas: 256 | hitung += angka 257 | hitung += angka_tambahan 258 | print(hitung) 259 | 260 | total(10, 1, 2, 3, angka_tambahan=50) 261 | total(10, 1, 2, 3) 262 | # Akan menampilkan pesan kesalahan, karena kita tidak memberikan argumen baku untuk nilai `angka_tambahan` 263 | ~~~ 264 | 265 | Keluaran: 266 | 267 | ~~~ 268 | $ python3 keyword_only.py 269 | 66 270 | Traceback (most recent call last): 271 | File "keyword_only.py", line 12, in 272 | total(10, 1, 2, 3) 273 | TypeError: total() needs keyword-only argument extra_number 274 | ~~~ 275 | 276 | Bagaimana Cara Kerjanya: 277 | 278 | 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. 279 | 280 | Catat bahwa penggunaan `+=` merupakan jalan pintas. Jadi untuk mengatakan `x = x + y`, Anda dapat menuliskan `x += y`. 281 | 282 | 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)`. 283 | 284 | ## Statemen return 285 | 286 | 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. 287 | 288 | Contoh (simpan dengan nama `func_return.py`): 289 | 290 | ~~~python 291 | def maximum(x, y): 292 | if x > y: 293 | return x 294 | elif x == y: 295 | return 'Nilai angkanya sama' 296 | else: 297 | return y 298 | 299 | print(maximum(2, 3)) 300 | ~~~ 301 | 302 | Keluaran: 303 | 304 | ~~~ 305 | $ python3 func_return.py 306 | 3 307 | ~~~ 308 | 309 | Bagaimana Cara Kerjanya: 310 | 311 | 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. 312 | 313 | Catat bahwa statemen `return` tanpa nilai sama dengan `return None`. `None` 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`. 314 | 315 | 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: 316 | 317 | ~~~python 318 | def sebuahFungsi(): 319 | pass 320 | ~~~ 321 | 322 | Statemen `pass` digunakan di Python untuk mengindikasikan blok statemen yang kosong. 323 | 324 | Catatan 325 | 326 | : Ada fungsi tertanam yang bernama `max` yang sudah mengimplementasikan fungsi 'find maximum', jadi gunakan fungsi tertanam sebisa mungkin. 327 | 328 | ## DocStrings 329 | 330 | 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! 331 | 332 | Contoh (simpan dengan nama `func_doc.py`): 333 | 334 | ~~~python 335 | def printMax(x, y): 336 | '''Mencetak nilai tertinggi dari dua angka. 337 | 338 | Kedua angka yang diberikan harus berupa integer.''' 339 | x = int(x) # konversi ke integer, jika memungkinkan 340 | y = int(y) 341 | 342 | if x > y: 343 | print(x, ' adalah nilai paling tinggi') 344 | else: 345 | print(y, ' adalah nilai paling tinggi') 346 | 347 | printMax(3, 5) 348 | print(printMax.__doc__) 349 | ~~~ 350 | 351 | Output: 352 | 353 | ~~~ 354 | $ python3 func_doc.py 355 | 5 adalah nilai paling tinggi 356 | Mencetak nilai maksimal dari dua angka. 357 | 358 | Kedua angka yang diberikan harus berupa integer. 359 | ~~~ 360 | 361 | Bagaimana cara kerjanya: 362 | 363 | String dari baris logis pertama dari sebuah fungsi adalah *docstring* dari fungsi tersebut. Catat bahwa DocStrings juga berlaku untuk [Modules](#modules) dan [classes](#object-oriented-programming) yang akan kita pelajari di bab berikutnya. 364 | 365 | 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. 366 | 367 | 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](#object-oriented-programming). 368 | 369 | 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`. 370 | 371 | 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. 372 | 373 | ## Ringkasan 374 | 375 | Kita sudah lihat banyak aspek dari sebuah fungsi, namun tolong dicatat bahwa belum semua aspek sudah dibahas. Bagaimanapun juga, kita telah membicarakan banyak aspek yang nantinya akan Anda gunakan sebagai fungsi Python dalam tugas sehari-hari. 376 | 377 | Berikutnya, kita akan melihat bagaimana cara membuat modul Python. 378 | -------------------------------------------------------------------------------- /22-translations.pd: -------------------------------------------------------------------------------- 1 | # Terjemahan 2 | 3 | Telah tersedia banyak terjemahan dari buku ini dalam berbagai bahasa, terima kasih banyak untuk para sukarelawan yang tak kenal lelah! 4 | 5 | Jika Anda ingin membantu terjemahan buku ini, silakan lihat para sukarelawan dan bahasa di bawah ini, dan silakan putuskan sendiri apakah Anda ingin memulai terjemahan baru atau meneruskan proyek terjemahan yang sudah berjalan. 6 | 7 | Jika anda berencana untuk memulai terjemahan baru, mohon baca [Cara Penerjemahan](#translation-howto). 8 | 9 | ## Bahasa Arab 10 | 11 | Di bawah ini tautan untuk versi bahasa Arab. Terima kasih untuk Ashraf Ali Khalaf yang telah menerjemahkan buku ini. Anda bisa membaca seluruh isi buku secara daring [di sini](http://www.khaledhosny.org/byte-of-python/index.html) atau Anda bisa mengunduhnya dari [sourceforge.net](http://downloads.sourceforge.net/omlx/byteofpython_arabic.pdf?use_mirror=osdn). Untuk info lebih lanjut [klik di sini](http://itwadi.com/byteofpython_arabi). 12 | 13 | ## Bahasa Portugis Brazil 14 | 15 | Ada dua terjemahan: 16 | 17 | [Samuel Dias Neto](http://www.samueldiasneto.com/aprendendopython/index.html) (samuel.arataca-at-gmail-dot-com) telah membuat terjemahan bahasa Portugis Brazil saat Python yang digunakan masih versi 2.3.5. 18 | 19 | Terjemahan milik Samuel dapat diakses di [aprendendopython](http://www.samueldiasneto.com/aprendendopython/index.html). 20 | 21 | [Rodrigo Amaral](http://rodrigoamaral.net) (rodrigoamaral-at-gmail-dot-com) juga secara sukarela menerjemahkan buku ini ke dalam bahasa Portugis Brazil. 22 | 23 | Terjemahan milik Rodrigo saat ini tersedia di [http://www.swaroopch.org/notes/Python_pt-br:Indice](http://www.swaroopch.org/notes/Python_pt-br:Indice). 24 | 25 | ## Catalan 26 | 27 | Moises Gomez (moisesgomezgiron-at-gmail-dot-com) secara sukarela menerjemahkan buku ini ke dalam bahasa Catalan. Terjemahannya masih dalam pengembangan, dan saat ini masih tersedia di [erstwhile wiki](http://www.swaroopch.com/notes/). 28 | 29 | > Moisès Gómez - Saya seorang pengembang aplikasi juga guru dalam bahasa pemrogaman (biasanya untuk orang-orang yang tidak punya pengalaman membuat program sebelumnya). 30 | > 31 | > Beberapa waktu lalu, saya ingin belajar membuat program dengan Python, dan hasil karya Swaroop sangat membantu. Jernih, jelas dan lengkap. Tepat seperti yang saya butuhkan. 32 | > 33 | > Setelah menyelesaikannya, Saya pikir masyarakat di negara saya juga dapat memperoleh keuntungan darinya. Tapi bahasa Inggris menjadi halangan. 34 | > 35 | > Jadi, kenapa tidak menerjemahkannya? Dan saya telah mengerjakannya di versi BoP sebelumnya. 36 | > 37 | > Di negara saya, ada dua bahasa resmi. Saya pilih bahasa Catalan dengan asumsi bahwa orang lain juga akan menerjemahkannya ke dalam bahasa Spanyol yang lebih luas. 38 | 39 | ## Cina 40 | 41 | Berikut versi bahasa Cina di [http://www.swaroopch.org/notes/Python_cn:Table_of_Contents](http://www.swaroopch.org/notes/Python_cn:Table_of_Contents). 42 | 43 | Juan Shen (orion-garisbawah-val-at-163-dot-com) sudah secara sukarela menerjemahkan buku ini ke dalam bahasa Cina. 44 | Saat ini tersedia di [http://www.pycn.org/python%E5%9C%A8%E7%BA%BF%E6%89%8B%E5%86%8C](http://www.pycn.org/python%E5%9C%A8%E7%BA%BF%E6%89%8B%E5%86%8C). 45 | 46 | > Saya lulusan sarjana Wireless Telecommunication Graduate School, Beijing University of Technology, China PR. Minat riset saya saat ini adalah sinkronisasi, perkiraan kanal dan deteksi pengguna-jamak untuk sistem multicarrier CDMA. Python merupakan bahasa pemrograman yang paling banyak saya gunakan untuk simulasi harian dan karya riset, secara lebih khusus dengan bantuan Python Numeric. Saya sudah belajar Python setengah tahun sebelumnya, namun sebagaimana Anda ketahui, bahasa ini sangat mudah dimengerti, mudah digunakan dan mendukung produktivitas. Persis seperti yang ditulis dalam buku Swaroop 'Python sekarang telah menjadi bahasa pemrograman favorit saya'. 47 | > 'A Byte of Python' adalah tutorial saya saat belajar Python. Penjelasannya sangat jelas dan efektif untuk membimbing Anda ke dalam dunia Python dalam waktu singkat. Tidak terlalu panjang, namun secara efisien mencakup semua hal penting di Python. Saya pikir 'A Byte of Python' harus direkomendasikan dengan sangat untuk para pemula sebagai tutorial Python pertama mereka. Saya mendedikasikan terjemahan saya kepada jutaan pengguna Python potensial di Cina. 48 | 49 | ## Chinese Traditional 50 | 51 | Fred Lin (gasolin-at-gmail-dot-com) secara sukarela telah menerjemahkan buku ini ke dalam bahasa Tradisional Cina. 52 | 53 | Salinan tersedia di [http://code.google.com/p/zhpy/wiki/ByteOfZhpy](http://code.google.com/p/zhpy/wiki/ByteOfZhpy). 54 | 55 | Fitur yang menarik dari terjemahan ini adalah tersedianya *kode program berbahasa Cina yang bisa dieksekusi* berdampingan dengan kode program python aslinya. 56 | 57 | > **Fred Lin** - Saya saat ini bekerja sebagai engineer firmware jaringan di Delta Network, dan saya juga kontributor untuk framework web TurboGears. 58 | > 59 | > Sebagai _evangelist_ python (:-p), saya perlu materi untuk mempromosikan bahasa Python. Dan 'Byte of Python' adalah buku yang paling tepat untuk para pemula maupun progreammer yang berpengalaman. 'A Byte of Python' mengelaborasi hal-hal yang esensial dari Python dengan kadar yang terjangkau untuk semua. 60 | > 61 | > Terjemahan dibuat berdasarkan versi bahasa Cina yang disederhanakan, ditambah banyak penulisan ulang agar pas pada versi Wiki dan kualitas bacaan. 62 | > 63 | > Versi Cina tradisional juga diberikan lengkap dengan kode program Python berbahasa Cina yang bisa dieksekusi, yang bisa dilakukan lewat proyek terbaru saya yakni `zhpy` (python dalam bahasa Cina) (telah diperkenalkan pada publik sejak Agustus 07). 64 | > 65 | > zhpy(dibaca (Z.H.?, atau zippy) dibangun di atas lapisan Python, digunakan agar bisa berinteraksi dengan Python berbahasa Cina (tradisional atau disederhanakan). Proyek ini tujuan utamanya murni untuk pendidikan. 66 | 67 | ## Prancis 68 | 69 | Gregory (coulix-at-ozforces-dot-com-dot-au) secara sukarela telah menerjemahkan buku ini ke dalam bahasa Perancis. 70 | 71 | Gérard Labadie (Palmipede) juga telah melengkapi terjemahan buku ini dalam bahasa Perancis, dimulai dengan [http://www.swaroopch.org/notes/Python_fr:Table_des_Mati%C3%A8res](http://www.swaroopch.org/notes/Python_fr:Table_des_Mati%C3%A8res). 72 | 73 | ## Jerman 74 | 75 | Lutz Horn (lutz-dot-horn-at-gmx-dot-de), Bernd Hengelein (bernd-dot-hengelein-at-gmail-dot-com) dan Christoph Zwerschke (cito-at-online-dot-de) secara sukarela telah menerjemahkan buku ini ke dalam bahasa Jerman. 76 | 77 | Terjemahan mereka bisa dilihat di [http://abop-german.berlios.de](http://abop-german.berlios.de). 78 | 79 | *Lutz Horn* mengatakan: 80 | 81 | > Saya 32 tahun dan sarjana Matematika dari Universitas Heidelberg, Jemran. Saat ini saya bekerja sebagai pengembang perangkat lunak dalam proyek yang didanai publik berupa portal web yang berkaitan dengan ilmu komputer dalam bahasa Jemran. Bahasa utama yang saya gunakan secara profesional Java, namun saya mencoba sebanyak mungkin menggunakan Python di belakang layar. Terutama untuk analisis teks dan konversi data yang sangat mudah dilakukan di Python. Saya tidak terlalu familier dengan toolkit GUI, mengingat pemrograman yang saya lakukan lebih banyak digunakan untuk aplikasi webm dan antar muka untuk pengguna menggunakan framework Java seperti Struts. Saat ini saya berusaha menggunakan Python lebih banyak di fitur pemrograman berbasis fungsi dan generator. Setelah melihat secara sekilas terhadap Ruby, saya sangat terkesan dengan penggunan indentasi blok di bahasa Ini. Secara umum saya suka budaya dinamis dalam bahasa Ruby dan Python, yang memungkinkan saya melakukan apa yang tidak bisa saya lakukan lewat bahasa statis seperti Java. Saya telah mencari banyak referensi untuk pengenalan bahasa pemrograman yang cocok untuk pengguna yang sama sekali awam. Saya sebelumnya telah menemukan buku 'How to Think Like a Computer Scientist: Learning with Python' dan 'Dive into Python'. Buku pertama bagus untuk pemula tapi terlalu panjang untuk diterjemahkan. Buku kedua tidak cocok untuk pemula. Saya pikir buku 'A Byte of Python' berada di antara keduanya, mengingat buku ini tidak panjang, ditulis langsung menuju poin yang diinginkan, namun cukup lengkap untuk diajarkan kepada pemula. Di samping itu, saya luka struktur DocBook yang sederhana, membuat hasil penerjemahan dapat dikeluarkan dalam berbagai format secara mudah. 82 | 83 | *Bernd Hengelein* mengatakan: 84 | 85 | > Lutz dan saya akan mengerjakan terjemahan berbahasa Jerman bersama-sama. Kami baru saja selesai dengan intro dan pembukaan, tapi kami akan tetap menginformasikan kepada Anda perkembangan yang kami capai. Ok, sedikit catatan pribadi tentang saya. Saya 34 tahun dan bermain dengan komputer sejak 1980, saat "Commodore C64" menguasai panggung. Meskipun C++ adalah bahasa utama yang saya (harus) gunakan setiap hari, namun saya setiap saat mencari hal-hal baru untuk dipelajari. Tahun lalu saya jatuh cinta terhadap Python, bahasa yang sangat istimewa, baik terhadap kemungkinannya maupun terhadap kecantikannya. Saya pernah baca di Internet bahwa ada seseorang yang menyukai Python karena kecantikannya, berasal dari kecantikan kode yang dihasilkannya. Menurut saya dia sangat benar. Saat saya memutuskan untuk belajar Python, saya perhatikan bahwa dokumentasi berbahasa Jerman masih sedikit. Saat menemukan buku Anda saya langsung punya ide secara spontan untuk menerjemahkannya ke dalam bahasa Jerman. Beruntungnya, Lutz juga punya ide yang sama sehingga kami dapat membagi pekerjaan. Saya sangat mengharapkan kerja sama yang baik! 86 | 87 | ## Yunani 88 | 89 | Komunitas Ubuntu Yunani [telah menerjemahkan buku ini dalam bahasa Yunani](http://wiki.ubuntu-gr.org/byte-of-python-el), untuk digunakan di pengajaran Python satu arah yang dijalankan di forum kami. Kontak [@savvasradevic](https://twitter.com/savvasradevic) untuk informasi lebih lanjut. 90 | 91 | ## Bahasa Indonesia 92 | 93 | Daniel (daniel-dot-mirror-at-gmail-dot-com) pernah menerjemahkan buku ini ke dalam bahasa Indonesia di [http://python.or.id/moin.cgi/ByteofPython](http://python.or.id/moin.cgi/ByteofPython). 94 | 95 | W. Priyambodo juga menerjemahkan ke dalam bahasa Indonesia. Terjemahan masih dalam pengembangan dan bisa cek di sini [http://www.swaroopch.org/notes/Python_id:Daftar_Isi](http://www.swaroopch.org/notes/Python_id:Daftar_Isi). 96 | 97 | Terjemahan bahasa Indonesia yang Anda pegang ini merupakan terjemahan dari Ahmad Sofyan (asofyan-at-gmail-dot-com). 98 | 99 | ## Italia 100 | 101 | Enrico Morelli (mr-dot-mlucci-at-gmail-dot-com) dan Massimo Lucci (morelli-at-cerm-dot-unifi-dot-it) secara sukarela telah menerjemahkan buku ini ke dalam bahasa Italia. 102 | 103 | Terjemahan berbahasa Italia saat ini tersedia di [www.gentoo.it/Programmazione/byteofpython](http://www.gentoo.it/Programmazione/byteofpython). Terjemahan baru masih dalam perkembangan dan dimulai di [http://www.swaroopch.org/notes/Python_it:Prefazione](http://www.swaroopch.org/notes/Python_it:Prefazione). 104 | 105 | > **Massimo Lucci dan Enrico Morelli** - kami bekerja di Universitas Florence (Italia) - Departemen Kimia. Saya (Massimo) sebagai insinyur layanan dan administrator sistem untuk Spektometer Resonansi Magnetik Nuklir; Enrico sebagai insinyur layanan dan administrator sistem untuk CED dan sistem paralel/cluster. Kami telah menggunakan python untuk kegiatan pemrograman selama sekitar tujuh tahun, dan berpengalaman di lingkungan Linux sejak sepuluh tahun terakhir. Di Italia, kami bertanggung jawab dan administrator untuk situs web www.gento.it, yang merupakan situs untuk distribusi Linux Gentoo dan www.nmr.it (saat ini masih dalam pengembangan) untuk aplikasi Resonansi Magnetis Nuklir dan Organisasi Kongres dan Manajemen. Itu saja! Kami terkesan dengan bahasa yang Anda gunakan di buku Anda, dan kami pikir pendekatan ini sangat penting bagi pengguna baru Python (kami berpikir sekitar seratus mahasiswa dan periset yang bekerja di lab kami). 106 | 107 | ## Jepang 108 | 109 | Berikut versi bahasa Jepang, tersedia di [http://www.swaroopch.org/notes/Python_ja:Table_of_Contents](http://www.swaroopch.org/notes/Python_ja:Table_of_Contents). 110 | 111 | Shunro Dozono (dozono-at-gmail-dot-com) saat ini menerjemahkan buku ini ke dalam bahasa Jepang. 112 | 113 | ## Mongol 114 | 115 | Ariunsanaa Tunjin (luftballons2010-at-gmail-dot-com) secara sukarela telah menerjemahkan buku ini ke dalam bahasa Mongol. 116 | 117 | _Pembaruan di Nov 22, 2009_ : Ariunsanaa sedang berada di tahap akhir terjemahan. 118 | 119 | ## Norwegia (bokmål) 120 | 121 | Eirik Vågeskar ([http://www.swaroopch.org/notes/User:Vages](http://www.swaroopch.org/notes/User:Vages)) seorang pelajar sekolah menengah atas di [Sandvika videregående skole](http://no.wikipedia.org/wiki/Sandvika_videreg%C3%A5ende_skole) Norwegia, seorang [blogger](http://forbedre.blogspot.com/) dan saat ini menerjemahkan buku ini ke dalam bahasa Norwegia (bokmål). Terjemahan masih belum selesai, dan Anda dapat mengecek di [http://www.swaroopch.org/notes/Python_nb-no:Innholdsfortegnelse](http://www.swaroopch.org/notes/Python_nb-no:Innholdsfortegnelse) untuk informasi lebih lanjut. 122 | 123 | > _Eirik Vågeskar_: Saya selalu ingin membuat program, namun karena bahasa yang saya pergunakan sangat jarang penggunanya, proses belajar buat saya menjadi lebih sulit. Hampir semua buku dan tutorial dibuat dalam bahasa Inggris yang bersifat teknis, begitu teknisnya sehingga sebagian besar lulusan sekolah sulit memahami bahasa yang digunakan dalam tutorial tersebut. Saat saya menemukan buku ini, semua masalah saya terselesaikan. "A Byte of Python" menggunakan bahasa non teknis yang sederhana untuk menjelaskan bahasa pemrograman dengan cara yang mudah dimegerti, dan ini membuat belajar Python menjadi lebih menyenangkan. Setelah membaca separuh dari buku, saya memutuskan bahwa buku ini layak untuk diterjemahkan. Saya harap terjemahan yang saya lakukan dapat membantu orang-orang yang memiliki situasi yang mirip dengan saya alami (terutama bagi anak muda), dan mungkin juga dapat menyebarkan ketertarikan terhadap bahasa pemrograman bagi orang awam. 124 | 125 | ## Polandia 126 | 127 | Dominik Kozaczko (dkozaczko-at-gmail-dot-com) secara sukarela telah menerjemahkan buku ini ke dalam bahasa Polandia. Terjemahan dan perkembangannya dapat dilihat di sini: [Ukąś Pythona](http://wiki.lo5.bielsko.pl/index.php/Uk%C4%85%C5%9B_Pythona). 128 | 129 | *Kabar terbaru* : Terjemahan sudah selesai dan siap disebarkan tanggal 2 Oktober 2009. Terimakasih untuk Dominik, dua murid dan teman-temannya untuk segenap upaya dan waktunya. 130 | 131 | > *Dominik Kozaczko* - Saya guru Ilmu Komputer dan Informatika 132 | 133 | ## Portugis 134 | 135 | Fidel Viegas (fidel-dot-viegas-at-gmail-dot-com) secara sukarela telah menerjemahkan buku ini ke dalam bahasa Portugis. 136 | 137 | ## Rumania 138 | 139 | Paul-Sebastian Manole (brokenthorn-at-gmail-dot-com) secara sukarela telah menerjemahkan buku ini ke dalam bahasa Rumania. 140 | 141 | > *Paul-Sebastian Manole* - Saya mahasiswa tingkat dua Ilmu Komputer di Universitas Spiru Haret. Saya lebih cenderung programmer otodidak dan telah memutuskan untuk belajar bahasa baru, Python. Dari penelusuran di Internet, tidak ada cara yang lebih baik selain membaca ''A Byte of Python''. Buku ini sangat terkenal (selamat kepada penulisnya yang telah menulis buku yang sangat mudah ini). Saya mulai menyukai Python jadi saya putuskan untuk menerjemahkan buku karya Swaroop ini ke dalam bahasa Rumania. Meskipun saya satu dan satu-satunya yang berinisiatif, namun jika Anda bisa membantu, silakan bergabung dengan saya. 142 | 143 | Terjemahan ini dapat dilihat di [http://www.swaroopch.org/notes/Python_ro](http://www.swaroopch.org/notes/Python_ro). 144 | 145 | ## Russia dan Ukraina 146 | 147 | Averkiev Andrey (averkiyev-at-ukr-dot-net) secara sukarela telah menerjemahkan buku ini ke dalam bahasa Rusia, dan mungkin Ukraina (jika waktu mengizinkan) 148 | 149 | Vladimir Smolyar (v_2e-at-ukr-dot-net) telah memulai halaman terjemahan berbentuk Wiki berbahasa Rusia. Anda dapat membaca versi pengembangannya di [http://www.swaroopch.org/notes/Python_ru:Table_of_Contents](http://www.swaroopch.org/notes/Python_ru:Table_of_Contents). 150 | 151 | ## Slovakia 152 | 153 | Albertio Ward (albertioward-at-gmail-dot-com) telah menerjemahkan buku ini ke dalam bahsa Slovakia di [fatcow.com/edu/python-swaroopch-sl/](http://www.fatcow.com/edu/python-swaroopch-sl/) : 154 | 155 | > Kami adalah organisasi nirlaba dengan nama “Translation for education”. Kami mewakili sekelompok masyarakat, terutama mahasiswa dan profesor dari Universitas Slovanik. Di sini terdiri atas mahasiswa dari beberapa departemen: linguistik, kimia, biologi dan sebagainya. Kami mencoba cari publikasi yang menarik dari Internet yang relevan bagu kami dan rekan-rekan kami di universitas. Kadang kami mencari artikel sendiri; dan tidak jarang profesor kami yang memilihkan materi untuk diterjemahkan. Setelah memperoleh izin dari pengarang, kami menerjemahkan artikel dan menerbitkannya di blog yang tersedia untuk rekan dan kolega kami. Penerbitan terjemahan ini sangat membantu mahasiwa dalam kegiatan belajar rutin mereka. 156 | > 157 | > Mengapa saya memilih artikel Anda untuk diterjemahkan? Terjemahan ini kami tujukan untuk membantu masyarakat Bulgaria memahami artikel ini secara detail. Setelah melakukan penelitian terhadap tingkat kebaruan dan relevansi topik, buku Anda sangat penting bagi masyarakat di negara kami. Dan mungkin saja akan menjadi populer di sana. Kendala bahasa tidak ada lagi karena sudah ada terjemahan yang saya lakukan. 158 | 159 | ## Spanyol 160 | 161 | Alfonso de la Guarda Reyes (alfonsodg-at-ictechperu-dot-net), Gustavo Echeverria (gustavo-dot-echeverria-at-gmail-dot-com), David Crespo Arroyo (davidcrespoarroyo-at-hotmail-dot-com) dan Cristian Bermudez Serna (crisbermud-at-hotmail-dot-com) secara sukarela telah menerjemahkan buku ini ke dalam bahasa Spanyol. Terjemahannya masih dalam perkembangan, dan Anda dapat membaca terjemahan dalam bahasa Spanyol (Argentina) mulai dari [http://www.swaroopch.org/notes/Python_es-ar:Tabla_de_Contenidos](http://www.swaroopch.org/notes/Python_es-ar:Tabla_de_Contenidos). 162 | 163 | *Gustavo Echeverria* mengatakan: 164 | 165 | > Saya bekerja sebagai pengembang software di Argentina. Bahasa yang saya gunakan di pekerjaan kebanyakan C# dan teknologi .Net tapi hanya Python dan Ruby pada proyek-proyek pribadi. Saya kenal Python beberapa tahun lalu dan langsung jatuh hati. Tidak lama mengenal Python, saya menemukan buku ini dan membantu saya dalam memahami bahasa Python. Lalu saya secara sukarela menerjemahkan buku ini ke dalam bahsa Spanyol. Sekarang, setelah menerima beberapa permintaan, saya mulai menerjemahkan "A Byte of Python" dengan bantuan Maximiliano Soler. 166 | 167 | *Cristian Bermudez Serna* mengatakan: 168 | 169 | > Saya mahasiswa teknik komunikasi di universitas Anioquia (Kolombia). Bulan lalu, saya mulai belajar Python dan menemukan buku yang istimewa ini, jadi saya secara sukarela menerjemahkannya dalam bahasa Spanyol. 170 | 171 | ## Swedia 172 | 173 | Mikael Jacobsson (leochingkwake-at-gmail-dot-com) secara sukarela menerjemahkan buku ini ke dalam bahasa Swedia. 174 | 175 | ## Turki 176 | 177 | Türker SEZER (tsezer-at-btturk-dot-net) dan Bugra Cakir (bugracakir-at-gmail-dot-com) secara sukarela telah menerjemahkan buku ini ke dalam bahasa Turki. 178 | 179 | *Catatan* : Ganti `-at-` dengan `@` , `-dot-` dengan `.` dan `-garisbawah-` dengan `_` di alamat email yang disebutkan di halaman ini. Strip yang ada di email tetap seperti asalnya. 180 | --------------------------------------------------------------------------------