gistfile1.txt

* Now talking on #uvt
* Topic for #uvt is: "Diskusi Kelompok Program Python 2012"
* Topic for #uvt set by basic123 at Fri Sep 14 14:50:54 2012
-ChanServ- [#uvt] "Selamat Datang di Kelas UVT"
* #uvt :http://www.uvt.web.id
* fr4w4_ has quit (Quit: Page closed)
* basic123 (~pythonuni@111.94.107.157) has joined #uvt
* ChanServ gives channel operator status to basic123
<basic123> wah, belum pada datang ya
<basic123> Pak fajran: assalamualaikum
<fajran> wa 'alaikum salaam
<fajran> iya kosong nih :D
<basic123> padahal undangan sudah tersebar
<basic123> tunggu 10 menit dulu pak... saya cari dulu di FB, mungkin ada di sana.
* samuderaVoidLabs (~samuderaV@118.97.95.70) has joined #uvt
<samuderaVoidLabs> Assalamualaikum
<basic123> walaikum salam
* samuderaVoidLabs is now known as samudera
* satmo54 (~satmo54@114.79.3.107) has joined #uvt
<basic123> Ok, 3 menit lagi dimulai
* arifazik (~quassel@114.79.49.106) has joined #uvt
* Se7enTime (~se7entime@114.79.52.16) has joined #uvt
<basic123> Yup, lima orang mahasiswa pak fajran... silakan dimulai
<fajran> mari dimulai.. :D
<fajran> assalamu 'alaikum wr. wb semua
<satmo54> wa'alaikum salam wr. wb.
<fajran> kali ini kita akan mulai icip2 pemrograman GUI bermasis GTK+ dg PyGTK
<fajran> udah masang pygtk kah?
<samudera> waalaikumussalam
<satmo54> sudah paaak :D
<fajran> tuk ngetes, coba jalanin ini
<fajran> from gi.repository import Gtk
<fajran> kode2 tuk memulai udah saya taro di https://github.com/fajran/uvt-python-2012/tree/master/P3
<fajran> semuanya sukses ngejalanin 1 baris tadi?
<samudera> iya pak
<fajran> ok sip
<fajran> mari lihat contoh pertama https://github.com/fajran/uvt-python-2012/blob/master/P3/01.py
<fajran> belajar seluk beluk GTK+ nya sambil jalan aja ya
<fajran> jadi.. kita skr akan mencoba membuat aplikasi GUI
<fajran> dalam pemrograman GUI ada istilah "gui toolkit"
<fajran> GUI toolkit itu singkatnya adalah pustaka yg membantu tuk membuat aplikasi GUI
<fajran> pustaka ini berisi fungsi2/kelas2 tuk membuat window, tombol, teks editor, dan lain2
<fajran> di Linux, selain GTK+, contoh GUI toolkit lain yg terkenal juga adalah Qt
<fajran> si GUI toolkit ini akan menangani urusan gambar menggambar (contoh: bagaimana menggambar tombol?)
<fajran> trus urusan event handling (misalnya: kalau tombol keyboard dipencet pada saat sebuah teks editor aktif, maka harus memunculkan huruf)
<fajran> dan lain sebagainya
<fajran> nah kembali ke PyGTK
<fajran> PyGTK ini adalah python "wrapper" alias pembungkus dari library GTK+
<fajran> GTK+ sendiri ditulis pakai bahasa C. Dengan adanya wrapper ini makanya library GTK+ bisa diakses via python
<fajran> nah.. sekarang mari kita coba jalankan contoh pertama tadi
<fajran> silakan dicoba :D
* profbins (~androirc@120.168.1.146) has joined #uvt
<fajran> salin/download ini https://raw.github.com/fajran/uvt-python-2012/master/P3/01.py
<fajran> trus jalanin python 01.py
<basic123> Hello World GUI
<basic123> saya tarik pakai git kodenya
<samudera> git clone https://github.com/samuderapase/uvt-python-2012.git
<samudera> udah sy fork barusan :D
<fajran> muncul window?
<fajran> bisa ditutup?
<fajran> kalo iya, mari kita bahas
<basic123> ya, bisa ditutup
<satmo54> window kosong ngga ada tombolnya pak :D
<fajran> oke mari kita bahas baris per baris
<fajran> from gi.repository import Gtk
<fajran> itu adalah cara tuk mengaktifkan modul Gtk di python
<fajran> cara sebelumnya itu cuma "import gtk"
<fajran> namun sejak bbrp tahun lalu (saya ngga terlalu ngikutin sejarahnya)
<fajran> GObject yg menjadi "framework" penulisan kode GTK+ dibuat lebih gampang dibuat wrappernya
* arifazik_ (~quassel@114.79.52.162) has joined #uvt
<fajran> kalau mau tau lebih detil, coba googling ttg "GObject Introspection" saya sendiri ngga begitu tau ttg ini
* arifazik has quit (Ping timeout: 256 seconds)
<fajran> nah sejak itu, cara memanggil modul Gtk jadi berubah menjadi
<fajran> from gi.repository import Gtk
<fajran> lanjut ke baris selanjutnya
<fajran> window = Gtk.Window()
<fajran> Gtk.Window adalah sebuah kelas yang dipakai tuk menggambar sebuah jendela di layar
<fajran> di situ kita membuat sebuah objek bernama "window" dari kelas Gtk.Window
<fajran> sampe di sini, objek window sudah terbuat namun belum akan ada perubahan apa2 karena Gtk nya sendiri belum dimulai
<fajran> lanjut..
<fajran> window.connect("delete-event", Gtk.main_quit)
<fajran> ini adalah cara tuk menyambungkan sebuah "event".. nanti akan saya bahas lebih lanjut
<fajran> baris tsb bisa dibaca seperti ini: jika ada event bernama "delete-event" sampai ke si "window", maka jalankan fungsi Gtk.main_quit
<fajran> Gtk.main_quit adalah fungsi tuk mengakhiri aplikasi Gtk
<fajran> event "delete-event" adalah event yg muncul jika window ditutup
* dotovr (dfffe302@gateway/web/freenode/ip.223.255.227.2) has joined #uvt
<fajran> dg kata lain, jika window ditutup, maka akhiri aplikasi Gtk
<fajran> apa itu event? nanti kita bahas :D
<fajran> baris selanujutnya...
<fajran> window.set_title("Hello World!")
<fajran> yg ini mestinya gampang ditebak
<fajran> :D
<fajran> set judul jendela menjadi "Hello World!"
<fajran> lalu..
<fajran> window.show()
<fajran> setiap "widget" alias komponen seperti tombol, text entry, window itu akan berada dalam posisi "tidak tampil" pada saat widget tsb dibuat
<fajran> agar tampil, maka kita perlu panggil method show()
<fajran> okeh.. sekarang si jendela udah siap
<fajran> mari kita mulai aplikasi Gtk nya
<fajran> Gtk.main()
<fajran> perintah tsb akan memulai yg namanya GTK "main loop"
* thanmustoki (~oki@unaffiliated/thanmustoki) has joined #uvt
* ChanServ gives channel operator status to thanmustoki
<fajran> Gtk akan mulai menampilkan jendela, widget dll di layar
<fajran> akan mulai menerima event, dll
<fajran> setelah baris itu dipanggil, munculah si jendela di layar :D
<fajran> sampe di sini, ada yg mau nanya?
<arifazik_> oke pak..
<fajran> dokumentasi PyGTK yg terakhir sepertinya masih tuk versi 2.. tapi mungkin ngga beda jauh dg versi 3
<fajran> http://developer.gnome.org/pygtk/stable/
<fajran> tuk kelas Gtk.Window, coba cek http://developer.gnome.org/pygtk/stable/class-gtkwindow.html
<fajran> di situ ada daftar method, daftar event, 
<fajran> sepertinya yg ini lebih enak dibaca http://www.pygtk.org/docs/pygtk/class-gtkwindow.html
<fajran> kalo liat di dokumentasi tsb, ada bagian namanya "Ancestry"
<fajran> isinya tentang silsilah kelas Gtk.Window
<fajran> tau silsilah (alias kelas anu merupakan turunan dari kelas apa aja) itu berguna tuk mencari method dan event
<fajran> oiya nama lain dari event adalah signal
<fajran> kalau lihat dokumentasi Gtk.Window, di situ ngga ada keterangan tentang event "delete-event"
<fajran> namun kalau ditelusuri ke kelas induknya, "delete-event" ini adalah milik Gtk.Widget
<fajran> berhubung Gtk.Window adalah turunan dari Gtk.Widget, maka Gtk.Window juga akan memiliki event "delete-event" tadi
<fajran> begitu jg method2 yg dimiliki oleh kelas induk
* arifazik (~quassel@114.79.52.129) has joined #uvt
* arifazik_ has quit (Ping timeout: 245 seconds)
<fajran> ada yg mau nanya?
<arifazik> event?
<arifazik> :)
<fajran> selain event :D
<fajran> lanjut dulu aja ya
<arifazik> oke pak..
<fajran> kalo begitu, mari kita lihat contoh 2
<fajran> https://raw.github.com/fajran/uvt-python-2012/master/P3/02.py
<fajran> di situ kita mulai memasukkan tombol :D
<fajran> tombol itu dibuat dg kelas Gtk.Button
<fajran> kalau liat di dokumentasi Gtk.Window
<fajran> Gtk.Window itu turunan dari kelas Gtk.Container
<fajran> Gtk.Container adalah sebuah widget yg bisa berisi widget lain
<fajran> nah dg kata lain, Gtk.Window bisa berisi widget lain misalnya Gtk.Button
<fajran> dokumentasi Gtk.Button ada di http://www.pygtk.org/docs/pygtk/class-gtkbutton.html
<fajran> untuk memasukkan widget ke dalam sebuah widget container, kita pakai method add()
<fajran> jadi..
<fajran> button = Gtk.Button("ini label")
<fajran> window.add(button)
<fajran> sama seperti sebelumnya, si tombol jg mesti diset agar tampil dg memanggil method show()
<fajran> button.show()
<fajran> nah.. silakan coba jalankan contoh 2 ini
<fajran> si tombol punya event bernama "clicked" yg akan dipanggil jika si tombol di-klik
<fajran> di contoh 2 tadi, event ini akan dihubungkan ke sebuah fungsi bernama "cetak_halo"
<fajran> fungsi yg menerima event ini istilahnya adalah event handler
<fajran> setiap fugnsi yg menjadi event handler pasti perlu menyediakan (minimal) 1 buah parameter
<fajran> di contoh 2, saya namai parameternya dg "sender"
<fajran> pada saat event terjadi, fungsi event handler akan dipanggil, dan nilai parameter pertama (sender) berisi objek yg membuat event tadi
<fajran> pada contoh 2, jika tombol di-klik, maka cetak_halo akan dipanggil dg parameter berupa objek tombol
<fajran> err.. seprtinya agak rumit saya menjelaskannya.. perlu diulang?
<arifazik> saya bisa memahaminya pak..
<arifazik> :D
<basic123> lanjut saja pak
<fajran> baiklah
<fajran> yaa itu sekalian tentang event :D
<fajran> lanjut ke contoh 3 berarti https://raw.github.com/fajran/uvt-python-2012/master/P3/03.py
<fajran> contoh 3 ini sebenarnya sama saja dengan contoh 2
<fajran> namun dibuat agar lebih objek oriented
<fajran> jadi kita buat kelas turunan Gtk.Window bernama Jendela
<fajran> di dalamnya kita siapkan semuanya seperti judul, penanganan "delete-event", resize
* profbins has quit (Quit: AndroIRC - Android IRC Client ( http://www.androirc.com ))
<fajran> dan juga menambahkan tombol ke dalamnya
<fajran> silakan dicoba
<fajran> :D
<fajran> di sini saya masukkan sebuah variabel tuk menampung angka
<fajran> jika tombol dipencet, maka angka akan ditambahkan
<fajran> lalu ditampilkan sebagai label tombol
<fajran> bisa dicerna kah contoh 3 itu? :D
<arifazik> bisa..
<fajran> oke mari lanjut ke contoh 4 https://github.com/fajran/uvt-python-2012/raw/master/P3/04.py
<fajran> di contoh 4 kita berkenalan dg kelas Gtk.Box
<fajran> ini adalah widget container yg dapat berisi banyak widget di dalamnya
<fajran> widget yg dimasukkan akan ditampilkan berderetan secara horizontal atau vertikal
<fajran> by default, widget2 yg dimasukkan akan ditampilkan secara horizontal
<fajran> tapi kita bisa mengubah menjadi vertikal dg cara menyebutkan orientasi pada saat membuat objek dari kelas Gtk.Box
<fajran> contohnya
<fajran> horizontal_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
<fajran> vertical_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
<fajran> di contoh 4 ini saya menggunakan Gtk.Box untuk menampilkan sebuah teks input dan tombol
<fajran> kelas tuk menampilkan teks input adalah Gtk.Entry
<fajran> di situ saya membuat sebuah Gtk.Box, lalu dimasukkan ke dalam Gtk.Window
<fajran> lalu saya buat objek Gtk.Entry dan Gtk.Button dan memasukkannya ke objek Gtk.Box
<fajran> jadi secara hirarki, window berisi 1 widget yaitu box
<fajran> dan box tsb berisi 2 widgets yaitu entry dan button
<fajran> di contoh tsb, saya menggunakan method pack_start() dan bukan add() tuk memasukan entry ke dalam box
<fajran> pack_start() ini adalah method milik Gtk.Box sendiri yang tidak berasal dari Gtk.Container
<fajran> kotak.pack_start(self.isian, True, True, 5)
<fajran> ada 4 parameter yg perlu kita masukkan
<fajran> yg pertama adalah widget yg ingin dimasukkan
<fajran> tuk parameter 2 dan 3 (yaitu expand dan fill), saya masih agak bingung menjelaskannya
<fajran> parameter ke 4 adlaah padding yg artinya jarak antara pinggiran widget dengan si box itu sendiri
<fajran> dokumentasi ada di http://www.pygtk.org/docs/pygtk/class-gtkbox.html#method-gtkbox--pack-start
<fajran> expand dan fill itu tuk mengatur besar area di dalam box yg akan dipakai oleh widget di dalamnya
<fajran> jika box adalah sebuah rumah
<fajran> maka tiap widget di dalamnya akan berada di dalam kamar terpisah
<fajran> ukuran kamar ini, by default akan sama dengan ukuran widget
<fajran> sbg contoh, misalnya lebar entry adalah 100
<fajran> lebar button adalah 50
<fajran> maka ukuran kamar masing2 adalah 100 dan 50
<fajran> ukuran rumah terkecil tentunya 100 + 50 = 150
<fajran> nah, andaikan rumah diperbesar menjadi 200
<fajran> maka akan ada ruang tak terpakai  berukuran 50
<fajran> 100 (entry) + 50 (button) + 50 (kosong) = 200 (box)
<fajran> jika expand diset menjadi true, maka ruangan kosong tadi akan dialokasikan ke kamar yg mengatur expand=True
<fajran> jadi pada contoh 4 tadi, saya set expand=True tuk si entry
<fajran> maka kondisi yg ada adalah
<fajran> 150 (entry) + 50 (buton) = 200 (box)
<fajran> ukuran si entry sendiri bisa aja tetap 100, tapi kamar yg dialokasikan untuknya lebih besar yaitu 150
<fajran> nah jika parameter fill disetmenjadi True juga, maka ukuran si entry akan diubah mengikuti ukuran kamar
<fajran> pack_start() dan juga pack_end() itu mirip dengan add()
<fajran> namun punya parameter expand, fill, dan padding tadi
<fajran> selain itu, pack_start() akan menempatkan widget anak di urutan awal
<fajran> dan pack_end() di urutan akhir
<fajran> ... wah panjang juga.. ada yg mau nanya?
<arifazik> oke pak..
<basic123> hmm, lagi diserap dulu ilmunya... baru belajar pak.
<fajran> intinya sih begini
<fajran> di gtk kita berurusan dg widget
<fajran> window itu widget
<fajran> di dalam window kita bisa naro widget lain
<fajran> karena window adalah widget khusus bernama container
<fajran> container itu ada banyak jenisnya, salah satunya box
* fbrn (~aris@202.152.202.93) has joined #uvt
<fajran> box ini bisa menampilkan widget2 yg dimasukkan ke dalamnya secara berjejeran
<fajran> baik horizontal maupun vertikal
<fajran> nah begitu :D
<satmo54> kalau pake pack_end berarti entry ada di setelah tombol pak?
<fajran> satmo54, iya pak
<fajran> ada cara lain tuk menyusun widget, yaitu dengan Glade :D
<fajran> Glade itu aplikasi (dan library) tuk merancang GUI dengan GUI
<fajran> jadi tinggal drag n drop widgets saja
<satmo54> kayanya asyik pak :D
<fajran> nah.. itu ada di contoh 6 :D
<fajran> udah pada masang glade kah?
<basic123> sudah pak
<fajran> saya sempat bikin contoh 5 yg isinya adalah web browser sederhana :D
<fajran> jadi.. sebuah window berisi sebuah box vertikal
<fajran> di dalamnya ada box horizontal dan sebuah "webview"
<fajran> di dalam box horizontal ada entry dan tombol
<fajran> nah "webview" adalah komponen dari WebKit yg menampilkan halaman web
<fajran> silakan dicek kalau berminat :D
<fajran> tp tuk skr, kita loncat ke contoh 6 aja
<fajran> silakan buka glade lalu buka berkas kalkulator.glade
<arifazik> installing.. :D
<satmo54> ada 3 box ya pak? :D
<fajran> yup
<fajran> lapisan pertama itu box vertikal
<fajran> di dalamnya ada 2 buah box horizontal
<fajran> glade ini hanya untuk menyusun user interface
<fajran> dan juga menempelkan event
<fajran> alias signal
<fajran> masih perlu kode python agar user interface yg dibuat di glade bisa tampil dan berfungsi
<fajran> nah supaya bisa bekerja dg baik ada bbrp hal yg perlu diperhatikan
<fajran> 1. tiap widget itu punya nama
<fajran> coba cek di General => Name
<fajran> nama widget ini akan diakses dari kode program
<fajran> jadi tuk widget2 yg akan dipakai, sebaiknya diberi nama yg relevan
<fajran> selain itu..
<fajran> 2. nama signal/event handler
<fajran> coba cek tombol Tambah
<fajran> buka Tab "Signals"
<fajran> di situ saya set "handler" tuk event "clicked" adalah "tambah"
<fajran> mari kita lihat contoh 6
<fajran> https://github.com/fajran/uvt-python-2012/blob/master/P3/06-kalkulator.py
<fajran> setelah user interface yg dibuat di glade disimpan, kita akan menjumpai berkas berekstensi ".glade"
<fajran> isinya itu adalah dokumen XML
<fajran> yg berisi hirarki widget dengan segala konfigurasinya
<fajran> nah tuk mengubah dokumen XML ini menjadi widget2 GTK, kita bisa menggunakan kelas Gtk.Builder
<fajran> builder = Gtk.Builder()
<fajran> setelah itu kita masukkan berkas glade tadi
<fajran> builder.add_from_file("kalkulator.glade")
<fajran> nah setelah itu, kita bisa mengakses widget2 yg kita buat di glade
<fajran> kita akses dg cara mengambilnya terlebih dahulu
<fajran> window = builder.get_object("window_kalkulator")
<fajran> kalau dilihat di glade, si window saya beri nama "window_kalkulator"
<fajran> dg perintah di atas, variabel window akan berisi objek window dg segala widget di dalamnya
<fajran> sama seperti sebelumnya, kita set event "delete-event" agar mematikan Gtk supaya setelah window ditutup aplikasi tidak bengong
<fajran> window.connect("delete-event", Gtk.main_quit)
<fajran> dan juga set agar si window ditampilkan
<fajran> namun agar kita tidak mengeset satu2 setiap widget di dalamnya, kita bisa panggil method show_all() dan bukan sekedar show()
<fajran> window.show_all()
<fajran> setelah itu, kita mulai si Gtk
<fajran> Gtk.main()
<fajran> silakan tanya kalau ada yg mau nanya :D
<satmo54> sip pak :D
<satmo54> berarti kalo kita mau tambahnya main, tinggal buat fungsi tambah ya pak?
<fajran> maksudnya?
<satmo54> event-handler tambah pak, biar berfungsi kita tinggal buat fungsinya ya pak?
<fajran> oh itu ada di contoh berikutnya
<fajran> mari kita buka :D
<samudera> itu pak kalkulator.glade disesuikan dgn .py nya atau dibuat tidak mengikuti script .py nya ..
<satmo54> oh, maaf terburu2 XD
<fajran> samudera, nama berkas itu terserah pak bisa apa aja
<samudera> ooo
<samudera> berarti tinggal handle dgn methodsnya pak?
<samudera> builder.add_from_file("kalkulator.glade")
<fajran> iya tinggal diganti ke nama lain
<samudera> oke pak
<samudera> ngerti :D
<fajran> nah mari kita buka contoh 7 https://github.com/fajran/uvt-python-2012/blob/master/P3/07.py
<fajran> tadi di glade saya set 4 tombol agar memiliki event handler tuk clicked yg bernama "tambah", "kurang", "kali", dan "bagi"
<fajran> nah sama seperti cara manual, kita perlu menghubungkan si event ini ke event handlernya
<fajran> di glade kita sudah sebut nama dari event handler
<fajran> skr kita buat fungsinya
* arifazik has quit (Ping timeout: 268 seconds)
<fajran> ada 2 cara tuk menghubungkan nama di glade dengan fungsi
<fajran> yg saya pakai di contoh 7 itu adalah dg cara membuat kelas
<fajran> saya buat kelas bernama Aksi dengan 4 method dengan nama yang sama dengan nama event handler yg saya buat di glade
* arifazik (~quassel@114.79.48.70) has joined #uvt
* arifazik has quit (Read error: Connection reset by peer)
<fajran> setelah itu, buat objeknya
<fajran> aksi = Aksi()
<fajran> lalu sambungkan
<fajran> builder.connect_signals(aksi)
* arifazik (~quassel@114.79.54.70) has joined #uvt
<fajran> nah si Gtk.Builder akan menyambungkan event2 itu
<fajran> tombol "Tambah" saya set agar ketika ada event "clicked" mencari event handler bernama "tambah"
<fajran> setelah si gtk builder menyambungkan dg kelas event handler Aksi
<fajran> maka method "tambah" di dalam kelas Aksi akan dipanggil ketika tombol "Tambah" di-click
<fajran> bagaimana?
<arifazik> kelas aksi itu ada dmana pak?
<fajran> ada di contoh 7
<arifazik> * maaf komputer saya tdi tewas.. :)
<samudera> hahaa
<basic123> sedikit-sedikit paham pak, silakan lanjut pak
<fajran> oke
<fajran> contoh lanjutan ada di contoh 8
<fajran> https://github.com/fajran/uvt-python-2012/blob/master/P3/08.py
<fajran> saya ambil objek 2 entries di atas: entry_satu dan entry_dua
<fajran> dan juga label di bawah: label_hasil
<fajran> 3 widgets ini lalu masuk ke kelas Aksi
<fajran> dan akan digunakan pada saat event terjadi
<fajran> 2 nilai dari entry_satu dan entry_dua akan dioperasikan (tambah/kurang/kali/bagi)
<fajran> lalu hasilnya ditaro di dalam label
<basic123> kiri dan kanan ya pak
<fajran> iya
<basic123> jadi 08.py ini kalkulator gui-nya
<fajran> iya itu versi lengkapnya
<arifazik> get_object, get_text??
<fajran> arifazik, jadi kan glade itu menghasilkan berkas xml
<fajran> lalu xml ini "diwujudkan" menjadi gtk object beneran dg bantuan Gtk.Builder
<fajran> nah tuk mengakses setiap widget yg kita buat di glade, kita pakai method get_object
<fajran> contohnya
<fajran> window = builder.get_object("window_kalkulator")
<fajran> get_text() itu method milik dari Gtk.Entry tuk mengambil tulisan yg kita masukkan di text input
<fajran> dokumentasi Gtk.Entry ada di http://www.pygtk.org/docs/pygtk/class-gtkentry.html
<fajran> itu versi gtk 2 nya sih
<arifazik> iya pak..  klo yang builder.get_object("entry_satu") berarti ngambil entry field yang di glade..?
<fajran> arifazik, ya betul pak
<fajran> makanya tiap widget yg kita buat di glade, andai widget tsb mau dipakai dari kode, sebaiknya dikasih nama yg jelas
<arifazik> oke pak sip.. berarti setelah diambikl baru di masukkan ke class aksi..
<fajran> iya pak
<fajran> soalnya saya mau mengakses entry_satu, entry_dua, dan label_hasil dari kelas aksi
<fajran> ada lagi yg mau ditanyakan pak?
<samudera> pak
<samudera>   File "08.py", line 30, in bagi
<samudera>     hasil = a / b
<samudera> ZeroDivisionError: float division by zero
<samudera> itu klu inputan 0
<samudera> error pak ya
<fajran> iya pastinya error kalau dibagi 0 
<fajran> silakan diperbaiki :D
<samudera> oke pak
<fajran> eh saya udah pernah ngejelasin tentang exception atau belum?
<arifazik> belum kyknya..
<samudera> berarti pak tinggal tambahin :  except ValueError:
<fajran> try: .. except ValueError: ..
<samudera> ooo
<fajran> http://docs.python.org/2/tutorial/errors.html
<samudera> oke pak
<fajran> tuk pygtk ini, coba baca2 jg http://python-gtk-3-tutorial.readthedocs.org/en/latest/index.html
* satmo54 has quit (Quit: Lost terminal)
<fajran> itu bagus tutorialnya
* satmo54 (~satmo54@114.79.1.107) has joined #uvt
<samudera> iya pak
<fajran> ada lagi?
<fajran> tentang exception, nanti di facebook aja ya
<basic123> oke pak
<samudera> oke pak
<satmo54> oke pak
<basic123> tugas bagaimana pak?
<basic123> proyek
<fajran> proyek kita bahas di facebook jg bagaimana?
<fajran> saya mesti pulang skr :D
<fajran> oiya, desember insya Allah saya di jakarta
<basic123> yup, sdh lewat waktunya ya
<fajran> 12 des - 9 jan
<samudera> bisa pak di facebook
<fajran> baiklah
<fajran> tuk sesi kali ini, kita sudahi di sini dulu ya
<fajran> terima kasih atas perhatian rekan2 sekalian :D
<fajran> nanti kita lanjutkan lagi di facebook
<fajran> wassalamu alaikum wr. wb.
<basic123> terima kasih pak
<basic123> walaikum salam
<satmo54> wa'alaikum salam wr. wb.