Kepython

Saturday, 21 March 2015

5.3.7.Fraction

Dimulai dari Python 2.6 fractions diperkenalkan, untuk memperbaiki kekurangan dari floating-point.

Untuk menuliskan satu per tiga pada python adalah fractions.Fraction(1,3), atau setengah fractions.Fraction(1,2). Dan seperti biasa modul fractions tidak dimunculkan pada default, sehingga kita harus import fractions nya dahulu.

>>> from fractions import Fraction
>>> a=Fraction(1,2)
>>> a
Fraction(1, 2)
>>> a+a
Fraction(1, 1)
>>> 1*a
Fraction(1, 2)
>>>

Pada contoh diatas kita membuat setengah ditambah setengah hasilnya satu per satu. Memang bukan angka yang kita harapkan juga, tetapi lebih baik ketimbang floating-point (menurut saya).

Penggunaan Fraction juga bisa menggunakan decimal.

>>> Fraction(.25)
Fraction(1, 4)
>>>

Gam..................pang.

Kita coba dengan yang lain (coba seperti percobaan dengan decimal).

>>> a=Fraction(3,10)
>>> b=Fraction(9,10)
>>> a+a+a-b
Fraction(0, 1)
>>>

yes! ini yang kita cari bukan? (BUKAN!!!!!)

5.3.6.Decimal

Masalah utama pada type 'floating-point' adalah kepresisian angka, karena sedikit berbeda dengan apa yang kita harapkan, misalnya kita mengkalkulasi angka 0,3:

>>> a=0.3

>>> b=0.9

>>> a+a+a-b

-1.1102230246251565e-16

>>>

Pada perhitungkan diatas kita menginginkan penjumlahan dan perngurangan menghasilakan angka nol (0), tetapi hasil dari kalkulasi pyton berbeda, walaupun sangatlah kecil. Untuk mendapatkan kepresisian yang kita inginkan kita gunakan fungsi dari decimal.Decimal().

>>> import decimal
>>> a=decimal.Decimal('0.3')
>>> b=decimal.Decimal('0.9')
>>> a+a+a-b
Decimal('0.0')
>>>

Pada baris pertama kita mengimpor semua fungsi yang ada dimodul decimal, baik yang kita perlukan maupun yang tidak kita perlukan, ini sama juga dengan kita mengimport modul 'math'. Kita balik dahulu ke import 'math' ya. Pada modul math ada yang namanya 'pi' yaitu 3.14... , ada fungsi sin(), cos(), sqrt() dan lain-lain. Nah semua fungsi itu akan dikenali oleh python bila kita panggil. Dan ini pemborosan memory, kita hanya ingin menggunakan satu fungsi saja, dan kita mengimport seluruh modul math.

Ok balik lagi ke decimal. Tadi kita mengimport seluruh fungsi dari decimal, yang memboroskan memory, bila kita menggunakan komputer yang memorynya lebih dari 2 GB mungkin ga masalah, yang masalah bila kita menggunakan sebuah komputer yang memiliki memory 512 MB atau kurang seperti pada komputer rasberry pi, arduino, atau beagleboard, mungkin akan masalah. Sebaiknya kita mengeffisiensikan dan membiasakan mengimport sesuatu yang kita perlukan saja.

Untuk mengimport fungsi Decimal dari modul decimal kita tulis (sebaiknya kita restart dahulu python IDLE nya dengan (ctrl + F6) ) 'from decimal import Decimal'.

>>> ============= RESTART ==============

>>> from decimal import Decimal

>>>

Nah sekarang kita hanya memiliki fungsi Decimal dari modul decimal saja.

>>> a=Decimal('.3')

>>> b=Decimal('.9')

>>> a+a+a-b

Decimal('0.0')

>>>

Dan kita hanya perlu menuliskan Decimal(' ') saja, tidak perlu decimal.Decimal(' '). Apabila kita menuliskan Decimal(0.3) tanpa tanda petik:

>>> a=Decimal(.3)
>>> b=Decimal(.9)
>>> a+a+a-b
Decimal('-5.551115123130313080847263336E-17')

Hehehe... kacau lagi. Ini juga sama disebabkan oleh kepresisiannya, Decimal memiliki tingkat kepresisian 28 digit (default). Sehingga tanpa kita sadari pada contoh diatas oleh python diterjemahkan memiliki 28 digit. Kita coba menset kepresisiannya

>>> from decimal import getcontext
>>> getcontext().prec=4
>>> Decimal(1)/Decimal(7)
Decimal('0.1429')
>>> getcontext().prec=2
>>> Decimal(1)/Decimal(3)
Decimal('0.33')
>>>

5.3.5.Operasi Bitwise

Python juga mensupport operasi bitwise seperti pada bahasa C. Apa itu bitwise? Dasar dari bitwise adalah binary bit, angka binary dimaninpulasi untuk mendapatkan nilai yang lain. Contohnya nilai dari integer 20 adalah 10100.

>>> bin(0),bin(1),bin(2),bin(3),bin(4),bin(5),bin(6),bin(7),bin(8)
('0b0', '0b1', '0b10', '0b11', '0b100', '0b101', '0b110', '0b111', '0b1000')
>>>

Cara menghitung binary secara manual:

2⁷	2⁶	2⁵	2⁴	2³	2²	2¹	2⁰
128	64	32	16	8	4	2	1

Jadi untuk mencari binary dari integer 10, lihat pada table,

yang kita perlukan adalah 8 + 2 untuk menjadi 10.

Jadi pada tabel yang nilai 8 () dan nilai 2() menjadi angka 1 dan yang lain tetap nol menjadi 1010,

dengan kata lain untuk membuat angka 10 dengan binary number diperlukan 4 bit dan untuk membuat angka 36 diperlukan 6 bit yaitu 101000.

2⁷	2⁶	2⁵	2⁴	2³	2²	2¹	2⁰
0	0	0	0	1	0	1	0
0	0	1	0	1	0	0	0

Kita uji di python:

>>> bin(10),bin(36)
('0b1010', '0b100100')
>>>

Dengan bitwise kita menggeser bit-bit tersebut kekiri atau kekanan, contoh untuk binary(10) adalah 1010, bila kita geser kekiri 2 bit maka akan menjadi 101000, ada penambahan 2 bit dikanan angka, dan sekarang menjadi 2⁵+ 2³ = 32 + 8 = 40. Dalam pengoperasian bitwise, istilah 'geser kekiri' diatas adalah Shift left dimana lambang dari python adalah (<<) tanda lebih kecil dua kali.

>>> int(0b101000)
40
>>> 10 << 2
40
>>>

Dan bila angka binary (10) kita geser kekanan maka hasilnya akan menjadi binary 10 atau integer 2. Dalam python, 'geser kekanan' adalah Shift right.

>>> 10>>2
2
>>>

Apa yang pada contoh diatas? untuk binary dari integer 10 adalah 1010 lalu digeser kekanan 2 bit, angka 10 yang sebelah kanan (warna merah)1010 akan terhapus, jadi binary-nya adalah 10, dan binary 10 adalah integer 2.

Sekarang kita menggunakan operator 'and' (&) dan 'or' (|) pada bilangan binary.

>>> 10 & 12
8
>>> 10 | 12
14

Binary 10 adalah 1010 dan 12 adalah 1100 sehingga untuk 10 &12 adalah :

10 =	1	0	1
12 =	1	1	0	&(and)
Hasil =	1	0	0	= 8

dan 10 | 12 :

10 =	1	0	1
12 =	1	1	0	\| (or)
Hasil =	1	1	1	= 14

Dan untuk bitwise XOR :

10 =	1	0	1
12 =	1	1	0	XOR
Hasil =	0	1	1	= 6

>>> 10 ^ 12
6
>>>

ada yang menarik dengan bin ini, yaitu dengan len():

>>> x=934377
>>> len(bin(x))
22
>>> bin(x)
'0b11100100000111101001'
>>>

Binary 934377 adalah '11100100000111101001' berjumlah 20 angka, dan bila kita menggunakan len(bin(x)) jumlahnya adalah 22, ini dikarenakan '0b' yang ada didepan juga dihitung.

Thursday, 19 March 2015

5.3.4.Hexadecimal, Octadecimal, dan Binary

Kenapa harus ada hex, octa dan binary? Dalam kehidupan nyata kita menggunakan base-10 dimana pengulangan angka setiap 10 angka, dan ketika masuk kedalam komputer para programer memdapatkan kenyamanan dengan menggunakan type number tersebut, memudahkan pemetaan ke bytes dan bit.

Hexadecimal merupakan base-16 mulai dari angka 0 sampai hurup f (0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f). Penulisannya mulai dari 0(nol) + x (hurup 'x') dan kemudian angka hexa-nya.

>>> 0x00 # nol - x -nol - nol
0
>>> 0xff # nol - x - f - f
255
>>> 0xfff
4095
>>> 0x12c56f
1230191
>>>
>>> 0x00,0x99,0xaa,0x19af
(0, 153, 170, 6575)
>>>
>>> 0xffff,0xffffffffff
(65535, 1099511627775)
>>>

Octadecimal merupakan base-8, mulai dari angka 0 sampai 7 ( 0,1,2,3,4,5,6,7 ). Penulisannya mulai dari 0(nol) + o (hurup 'o') dan kemudian angka octa-nya.

>>> 0o00 # nol - hurup 'o' - nol - nol
0
>>> 0o77 # nol - hurup 'o' -tujuh - tujuh
63
>>> 0o7777
4095
>>> 0o77777777
16777215
>>>

Binary merupakan base-2, yaitu 0 ( nol ) dan 1 (satu). Penulisannya mulai dari 0(nol) + b (hurup 'b') dan kemudian angka binier-nya.

>>> 0b0 # nol - hurup 'b' - nol
0
>>> 0b000000000000000 # nol - hurup 'b' - nol semua
0
>>> 0b1 # nol - hurup'b' - satu
1
>>> 0b1111 # nol - hurup'b' -satu semua
15
>>> 0b11111111
255
>>> 0b1010101010111100100101
2797349
>>>

Sekarang kita lihat untuk angka 255 (dua ratus lima puluh lima) pada ketiga type tersebut (siapa tahu membunyikan bell di kepala). Dan harus selalu ingat, angka pertama itu bukan angka 1 (satu), melainkan 0 (nol)

>>> 0xff
255
>>> oct(255)
'0o377'
>>> bin(255)
'0b11111111'
>>>
>>> hex(64), oct(64), bin(64)
('0x40', '0o100', '0b1000000')
>>>
>>> hex(128), oct(128), bin(128)
('0x80', '0o200', '0b10000000')
>>>
>>> hex(512), oct(512), bin(512)
('0x200', '0o1000', '0b1000000000')
>>>

Dengan menggunakan fungsi 'int' bisa mengkonversikan sebuah string angka menjadi integer.

>>> int('255')
255
>>>

int('255') merupakan konversi dari sebuah string '255' menjadi integer (tidak ada yang aneh bukan?) sehingga :

>>> int('255',16)
597
>>>

(DUAR!) Maksud diatas adalah sebuah string '255' dengan base-16, kemudian dijadikan integer.

>>> hex(597)
'0x255'
>>> int(0x255)
597
>>>
>>> oct(1000)
'0o1750'
>>> int(0o1750)
1000
>>> int('1750',8)
1000
>>>
>>> int('ff',16)
255
>>>

Ada lagi fungsi yang sangat menarik yaitu 'eval ' . Fungsi ini cukup berbahaya, walaupun sedikit lebih pelan bekerjanya, fungsi ini meng-complie dan menjalankan sebuah string menjadi sebuah program, belum sampai disitu, program tersebut diasumsikan bekerja dengan sumber yang terpercaya, jadi hati-hati dengan fungsi ini.

>>> eval('1028')
1028
>>> eval('0xffffff')
16777215
>>> eval('0o7777')
4095
>>> eval('0b11111111')
255
>>>

5.3.3.Pembulatan

Pembulatan bisa keatas atau kebawah, pembulatan diperlukan ketika angka memiliki decimal yang terlalu banyak untuk kita pergunakan. Banyaknya decimal yang kita perlukan tergantung dari yang ingin kita lakukan. Untuk menghitung tabungan di bank, kita perlukan 2 digit dibelakang koma, tapi bila kita menghitung pembuatan prosessor misalnya, tingkat kepresisian perhitungan sampai nano meter, yang ukurannya 1e-9 meter, atau 1/1000,000,000 meter.

>>> import math
>>> math.floor(5.5)
5
>>> math.floor(-5.5)
-6
>>> math.trunc(5.5)
5
>>> math.trunc(-5.5)
-5
>>>

Math.floor() selalu membulatkan angka menjadi lebih rendah dari nilai aslinya, baik itu positif maupun negatif. Tapi math.trunc() membulatkan kearah angka nol. kita lihat deret baris dibawah ini:

6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -6

pada contoh diatas bila angka positif math.floor(5.5) dan math.trunc(5.5) menghasilkan angka 5, tidak masalah bukan.

Tapi bila angka negatif pembulat berbeda, pada math.floor(-5.5) menghasilkan -6 dan math.trunc(-5.5) menghasilkan angka -5. Ini disebabkan math.trunc() membulatkan angka negatif kearah nol, dengan kata lain math.trunc(+x) membulatkan kekanan (lihat deret baris diatas) dan math.trunc(-x) membulatkan kekiri.

Pembagian (dalam kontek pembulatan) ada dua devisi pada Python 3x, yaitu true dan floor, true (/) selalu menghasilkan floating point, terlepas dari number type. Dan floor (menggunakan double '/' (//) ) selalu membulatkannya kebawah atau menjadi lebih kecil. Dan hasil tergantung dari operasinya.

>>> 5 / 2
2.5
>>> 6 / 2
3.0
>>> 5 // 2
2
>>> 6 // 2
3
>>> 5.0 // 2
2.0
>>> 6 // 2.0
3.0
>>> a=5.0
>>> b=2
>>> a/b
2.5
>>> a//b
2.0
>>> int(a)/b
2.5
>>> int(a)//b
2
>>>