10.3.Menyimpan Objek Python dalam Format JSON

Format JSON mendekati dictionaries dan list pada python, walaupun demikian pickle tidak mendukung format tersebut. Ini disebabkan format JSON tergolong baru dalam hal penyimpanan data. Tetapi python menyediakan modul khusus untuk JSON.

1. >>> vdata=dict(nama='Budi', namapanggilan='Ubud')
2. >>>komplit=dict(vdata=vdata,tanggallahir=[21,'Mei',1990], gender='pria')
3. >>> komplit 
4. {'vdata': {'nama': 'Budi', 'namapanggilan': 'Ubud'}, 'gender': 'pria', 'tanggallahir': [21, 'Mei', 1990]}
5. >>> 

Contoh diatas mirip dengan data JSON. Sekarang kita tinggal mengkonversikannya kedalam JSON.

1. >>> import json
2. >>> dataJSON=json.dumps(komplit)
3. >>> dataJSON
4. '{"vdata": {"nama": "Budi", "namapanggilan": "Ubud"}, "gender": "pria", "tanggallahir": [21, "Mei", 1990]}'
5. >>> xx=json.loads(dataJSON)
6. >>> xx
7. {'vdata': {'nama': 'Budi', 'namapanggilan': 'Ubud'}, 'tanggallahir': [21, 'Mei', 1990], 'gender': 'pria'}
8. >>> xx==komplit
9. True
10. >>> json.dump(komplit,fp=open('c:/testjson.txt','w'),indent=4)
11. >>> print(open('c:/testjson.txt').read())
12. {
13.     "vdata": {
14.         "nama": "Budi",
15.         "namapanggilan": "Ubud"
16.     },
17.     "gender": "pria",
18.     "tanggallahir": [
19.         21,
20.         "Mei",
21.         1990
22.     ]
23. }
24. >>> 

--

10.2.Pickle

Modul pickle adalah salah satu alat yang powerful,  seperti juga eval yang mengkonversikan string menjadi objek. Perbedaanya adalah, eval bisa menghapus semua file yang ada di komputer kita bila kita mengijinkannya. Tetapi bila kita tidak mempercayai sumber data dalam sebuah file, maka pickle adalah alat yang ideal.

Pickle adalah alat yang lebih advance sehingga dapat memyimpan segala objek langsung ke file.

1. >>> a={'aa':1,'bb':2}
2. >>> lokasi='c:/testpickle.pkl'
3. >>> vfile=open(lokasi,'wb')  #'b' pada 'wb' adalah untuk binary
4. >>> import pickle
5. >>> pickle.dump(a,vfile)
6. >>> vfile.close()
7. >>>

Data tersimpan dalam binary, ini diindikasikan pada baris ke 3 vfile=open(lokasi,'wb'), b pada wb berarti kita membuat file yang berisi binary.

Lalu kita buka file tersebut.

1. >>> vfile=open(lokasi,'wb')
2. >>> pickle.dump(a,vfile)
3. >>> vfile.close()
4. >>> vfile=open(lokasi,'rb')
5. >>> hasil=pickle.load(vfile)
6. >>> hasil
7. {'bb': 2, 'aa': 1}
8. >>> 

Dan kita masih bisa melihat data bakunya pada file tersebut:

1. >>> open(lokasi,'rb').read()
2. b'\x80\x03}q\x00(X\x02\x00\x00\x00bbq\x01K\x02X\x02\x00\x00\x00aaq\x02K\x01u.'
3. >>> 

Baris 1 ( open(lokasi,'rb').read() ), rb adalah read binary.

10.1. Menyimpan Objek dalam File

Untuk menulikan objek-objek python kedalam file txt (penggunaan perintah 'open' selalu menggunakan string) tidak selalu secara otomatis memformatnya sehingga semua data akan ditulis secara memanjang tanpa ada baris baru.  

1. >>> lokasi='c:/test2.txt' # string lokasi file
2. >>> a,b,c=10,11,12        # int a,b,c
3. >>> vstring='hello'        # string
4. >>> vDict={'da':20, 'db':21, 'dc':22} #dictionary
5. >>> vList=[30,31,32]     #list
6. >>> vfile=open(lokasi,'w')   
7. >>> vfile.write('%s,%s,%s\n' %(a,b,c))
8. 9
9. >>> vfile.write(vstring+'\n')
10. 6
11. >>> vfile.write(str(vDict)+'\n')
12. 31
13. >>> vfile.write(str(vList)+'\n')
14. 13
15. >>> vfile.close()   # tulis data kedalam file dan tutup
16. >>> vfileRead=open(lokasi)
17. >>> vfileRead.readlines()
18. ['10,11,12\n', 'hello\n', "{'da': 20, 'dc': 22, 'db': 21}\n", '[30, 31, 32]\n']
19. >>> 

Sekarang file yang kita buat berada di drive c, bernama test2.txt, lalu kita cek file tersebut dengan notepad. Bisa juga kita buka dengan python menggunakan perintan 'open' seperti perintah pada baris ke 16 dan 17. Bisa pula kita langsung menjadikannya sebuah string dengan perintah 'open'.

1. >>> vfile=open(lokasi).read()
2. >>> vfile
3. "10,11,12\nhello\n{'da': 20, 'dc': 22, 'db': 21}\n[30, 31, 32]\n"
4. >>> 

Bila kita ingin menbaca perbaris:

1. >>> vfile=open(lokasi)
2. >>> baris1=vfile.readline()
3. >>> baris1
4. '10,11,12\n'
5. >>> baris1.rstrip()  #menhapus akhir dari baris
6. '10,11,12'
7. >>> baris1
8. '10,11,12\n'
9. >>> baris2=vfile.readline()
10. >>> baris2.rstrip()
11. 'hello'
12. >>>

Pada variable baris1 (string '10,11,12') adalah satu variable string. bila kita ingin menggunakan salah satunya saja, kita harus memisahkan terlebih dahulu.

1. >>> pisahString=baris1.split(',')
2. >>> pisahString
3. ['10', '11', '12\n']

Sekarang kita memiliki variable list yang bernama 'pisahString' (masih berbentuk string), kita tinggal memanggil index list yang kita perlukan.

1. >>> vInt1=int(pisahString[0])
2. >>> vInt1
3. 10
4. >>> vIntSemua=[int(x) for x in pisahString]
5. >>> vIntSemua
6. [10, 11, 12]
7. >>> 

Pada baris ke-4 kita membuat variable list yang bernama 'vIntSemua' isinya integer, bukan string lagi. Dan kita tidak perlu menghapus dengan perintah 'rstrip' untuk menghapus karakter '\n', karena dengan 'int' dan beberapa fungsi konversi tidak memperhitungkan tempat kosong disekitar angka.

Sekarang kita mencoba untuk mengkonversikan list dan dictionary, dengan menggunakan perintah 'eval'

1. >>> baris3=vfile.readline()
2. >>> baris3
3. "{'da': 20, 'dc': 22, 'db': 21}\n"
4. >>> baris4=vfile.readline()
5. >>> baris4
6. '[30, 31, 32]\n'
7. >>> vcampur=[baris3,baris4]
8. >>> vcampur
9. ["{'da': 20, 'dc': 22, 'db': 21}\n", '[30, 31, 32]\n']
10. >>> eval(vcampur[0])
11. {'da': 20, 'dc': 22, 'db': 21}
12. >>> eval(vcampur[1])
13. [30, 31, 32]
14. >>> pisah=[eval(x) for x in vcampur]
15. >>> pisah
16. [{'da': 20, 'dc': 22, 'db': 21}, [30, 31, 32]]
17. >>> 

Selanjutnya kurang lebih sama dengan yang pertama.

10.Files

Python mensupport string dan binary, tetapi pada Python 3.x ada perbedaan diantara keduanya, yaitu:

1. Text file mewakili normal string termasuk unicode encoding dan decoding secara otamatis.
2. Binary file mewakili bytes string dan mengijinkan program untuk mengakses file tanpa peringatan.

Kebanyakan programer hanya bekerja dengan ASCII, dan menggunakan file text dasar sebagai string normal. Tetapi semua string secara teknik merupakan Unicode pada Python 3.x dan Python2.x. Sehingga pengguna ASCII tidak menyadarinya.

Bila kita menggunakan bahasa internasional atau data berorientasi byte, secara garis besar kita harus menggunakan dua buah file, satu untuk string dan yang lain untuk byte.

Untuk membuka sebuah file, python memiliki fungsi open, yang akan menghasilkan objek file, dengan syntax 

open(namafile, mode). 

namafile adalah alamat file+nama file.

mode adalah cara membuka file tersebut dengan 'r' (read) yang merupakan default hanya membaca file saja, 'w' untuk membuat, dan membuka file. Kedua-duanya harus berupa string.

Ketika kita membuat sebuah objek file dengan 'open', kita bisa memanggil metode read atau write dengan file external yang terkait. Dalam semua kasus, text file dibuat dengan string pada python, isi file masuk pada python berupa string, dan kemudian ditulis dengan metode write sebagai string.

Metode membaca (reading) dan menulis (writing) bisa dilakukan dengan bermacam cara. 

1. >>> testFile=open('testFilePython.txt','w') # Membuat file 'testFilePython'
2. >>> testFile.write('hello file\n')                  # Menulikan satu baris kedalamnya
3. 11
4. >>> testFile.close()                                     # Menutup file dan menuliskan ke file
5. >>>

Sekarang kita periksa file yang kita buat, biasanya file yang kita buat tersebut berada di folder pyhon dalam drive c, yang bernama PythonXX  (C:\Python34\testFilePython.txt). Lalu kita buka file tersebut dengan notepad.

Bila kita ingin membaca file yang baru kita buat, kita harus membuka lagi filenya, karena kita telah menutup file dengan perintah 'close()' seperti pada baris no.4.

1. >>> testFile=open('testFilePython.txt')   # membuka file dengan mode read
2. >>> testFile.readline()                            # membaca baris
3. 'hello file\n'
4. >>> testFile.close()
5. >>>

Untuk membuat baris kedua pada file. File 'testFile' harus dibuka kembali dengan mode 'w' (write). Dan bila kita membuka file dengan open mode 'w', file kita akan dibuat baru, tanpa data, dengan kata lain file lama dihapus oleh python.

Tidak perlu dilakukan perintah dibawah ini.

1. >>> testFile=open('testFilePython.txt','w')    # membuat file baru dan kosong.
2. >>> 

Bila kita buka file 'testFilePython.txt' kita akan mendapati sebuah file kosong.

Jadi sebelum kita membuat file baru, kita harus menyimpan data awal dahulu. 

1. >>> testFile=open('testFilePyhon.txt')  # membaca file
2. >>> a=testFile.readline()                      # membuat string yang berisi isi dari file
3. >>> a
4. 'hello file\n'
5. >>> testFile.close()
6. >>> testFile=open('testFilePython.txt','w')  # membuat file baru
7. >>> testFile.write(a+'baris kedua\n')         # mengisi baris lama + baris baru
8. 23
9. >>> testFile.close()
10. >>> testFile=open('testFilePython.txt')
11. >>> testFile.readline()                      # print baris 1
12. 'hello file\n'
13. >>> testFile.readline()                      # print baris berikutnya
14. 'baris kedua\n'
15. >>> testFile.readline()                     # print baris berikutnya
16. ''
17. >>> testFile.close()                         # menutup file
18. >>> testFile=open('testFilePython.txt')  
19. >>> testFile.readlines()                    # membaca seluruh baris
20. ['hello file\n', 'baris kedua\n']
21. >>> open('c:/Python34/testFilePyhon.txt').readlines()  # pc window
22. ['hello file\n', 'baris kedua\n']
23. >>> 

Cara ini adalah bukan yang terbaik untuk membaca dan menuliskan text kedalam sebuah file, karena :

1. cara ini menampilkan semua format mentah yang ada pada file, contohnya baris baru tidak berada pada baris baru, tetapi dipisahkan dengan '\n' yang berarti baris baru. 
2. Juga semua output dari perintah read adalah string bukan objek, sehingga bila data kita adalah integer atau yang lain, kita harus mengkonversikannya terlebih dahulu.
3. Semua text yang kita buat tidak langsung dituliskan kedalam disk, melainkan dibuffer terlebih dahulu dengan close(), flush().
4. close() adalah fungsi untuk memutuskan hubungan dengan external file, tetapi masih ada didalam memory.

9.Tuples

Tuples bekerja seperti list, tetapi tuples tidak bisa diubah tempatnya dan bisanya ditulis secara berseri dalam tanda 'kurung ()'. 

Tuples itu seperti list dan string, tuples memiliki posisi pada objek-objeknya, diakses menggunakan index dan dapat dipotong-potong.

Karena tuples tidak dapat dimodifikasi, sehingga kita tidak bisa mengubah ukurannya tanpa mengkopi. 

Operasi biasa tuples dibuat sebagai suatu objek yang berseri, dan dipisahkan dengan koma. Untuk membuat tuples kosong kita tidak perlu mengisikan apapun didalamnya.

Operasi	Keterangan
()	Tuple kosong
A=(1,)	Tuple yang berisi 1 objek
A=(1 , 'hallo' , 4.4)	Tuple yang berisi 3 objek
A=1 , 'hallo' , 4.4	Sama seperti diatas
a=('Hallo',(1,2))	Tuple berjenjang
a=tuple('hello')	a=('h', 'e', 'l', 'l', 'o')
a[i]	Index tuple i
a[i][j]	Index dari index
a[i:j]	Pemotongan dari index i sampai j

Dan ada juga operasi penggabungan tuple dengan tanda plus (+):

1. >>> a
2. ('h', 'e', 'l', 'l', 'o')
3. >>> b
4. (1, 2, 3)
5. >>> a+b
6. ('h', 'e', 'l', 'l', 'o', 1, 2, 3)
7. >>> 

Dan bisa juga menggunakan operasi pengulangan dengan tanda bintang (*):

1. >>> a*2
2. ('h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o')
3. >>> 

Untuk satu objek pada tuple ada perlakuan khusus untuk menyampaikan pada python bahwa ini adalah tuples. Pada contoh diatas dimana A=(1,) bukanlah suatu kesalahan penulisan. Tetapi itu untuk memerintahkan python menbuat tuple.

1. >>> b=(2)     # integer
2. >>> type(b)
3. <class 'int'>
4. >>> b=(2,)
5. >>> type(b)
6. <class 'tuple'>
7. >>> 

Dan pada A=1 , 'hallo' , 4.4 python langsung membuatnya dengan tuple, walaupun tidak ada tanda kurung. Tanda kurung dalam tuple diperlukan untuk memanggil funsi atau ekperesi yang besar dalam penjenjangan.

Walaupun tuple bisa dibuat dengan tanpa tanda kurung, sebaiknya kita menggunakannya, bila scripting yang jumlahnya banyak, kita tidak keliru dengan data type yang lain.

Kita juga bisa mengkonversikan dari tuples ke list, sehingga kita bisa memodifikasi data dari tuple tersebut, dan dari list dapat pula dikonversikan kembali ke tuple.

1. >>> a=('bbb','ccc','aaa','ddd')   # tuple a
2. >>> a
3. ('bbb', 'ccc', 'aaa', 'ddd')
4. >>> b=list(a)                             # membuat list b dari tuple a
5. >>> b
6. ['bbb', 'ccc', 'aaa', 'ddd']
7. >>> b.sort()                               # memsortir list b
8. >>> b
9. ['aaa', 'bbb', 'ccc', 'ddd']
10. >>> a=tuple(b)                          # mengganti tuple a dengan list b
11. >>> a
12. ('aaa', 'bbb', 'ccc', 'ddd')
13. >>> c=('bbb','ccc','aaa','ddd')        # membuat tuple c
14. >>> sorted(c)                             # memsortir tuple c tanpa mengubah c
15. ['aaa', 'bbb', 'ccc', 'ddd']
16. >>> c
17. ('bbb', 'ccc', 'aaa', 'ddd')
18. >>> 

Kita juga bisa membuat list dengan base pada tuple, misalnya kita ingin menambahkan 100 dari semua data tuple.

1. >>> a=(0,1,2,3,4,5)            # tuple a
2. >>> b=[x+100 for x in a]   # membuat list dari tuple dengan menambahkan 100
3. >>> b 
4. [100, 101, 102, 103, 104, 105]
5. >>> a
6. (0, 1, 2, 3, 4, 5)
7. >>> 

Walaupun tuple tidak dapat dimodifikasi, tetapi bila objek dalam tuple terdapat list, list tersebut tetap bisa dimodifikasi.

1. >>> a                                         # tuple a
2. (0, 1, 2, 3, 4, 5)
3. >>> b                                         # list b
4. [100, 101, 102, 103, 104, 105]
5. >>> b[1]                                     # index 1 dari list b
6. 101
7. >>> len(b)                                  # banyak data dari list b
8. 6
9. >>> a.index(1)                           # index 1 dari tuple a
10. 1
11. >>> a.index(2,2)                        # index 2 dari tuple a
12. 2
13. >>> a.count(3)                          # menghitung banyaknya angka 3
14. 1
15. >>>  a
16. (0, 1, 2, 3, 4, 5)
17. >>> b
18. [100, 101, 102, 103, 104, 105]
19. >>> c
20. (0, 1, [9, 8, 7], 2, 3)
21. >>> c[2][0]=a                            # menambahkan data list yang ada pada tuple 
22. >>> c
23. (0, 1, [(0, 1, 2, 3, 4, 5), 8, 7], 2, 3)
24. >>>