See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/337649120

Pemrograman Python Analisis Data Eksperimen

Book · November 2011

CITATIONS READS

0 5,311

1 author:

Eko Sulistya
Universitas Gadjah Mada
5 PUBLICATIONS   0 CITATIONS   

SEE PROFILE

All content following this page was uploaded by Eko Sulistya on 30 November 2019.

The user has requested enhancement of the downloaded file.

Jurusan Fisika FMIPA UGM

Pemrograman Python
Analisis Data Eksperimen Fisika
Eko Sulistya

2011

Jurusan Fisika, Sekip Utara, Bulaksumur Yogyakarta

Daftar isi
Kata Pengantar .................................................................................... 1
I. Pendahuluan .................................................................................... 4
1.1 Latar belakang ........................................................................... 4
1.2 Rumusan masalah ...................................................................... 4
1.3 Tujuan......................................................................................... 5
2 Pengantar singkat bahasa pemrograman Python ........................... 5
2.1 Yang dihadapi dalam membuat program : rumus .................... 5
2.1.1 Menggunakan Python sebagai kalkulator .......................... 5
2.1.2 Tentang Program dan Pemrograman .................................. 6
2.1.3 Perangkat untuk Menulis Program .................................... 7
2.1.4 Menggunakan Idle untuk Menulis Program ....................... 8
2.1.5 Bagaimana Menjalankan Program ................................... 10
2.1.6 Verifikasi Hasil Program ................................................... 10
2.1.7 Menggunakan Variabel ..................................................... 11
2.1.8 Pemilihan Nama Variabel ................................................. 12
2.1.9 Kata-kata Kunci dalam Python ......................................... 13
2.1 10 Komentar ......................................................................... 13
2.1.11 Memformat Tampilan Teks dan Angka .......................... 14
2.2 Loop dan List ............................................................................ 15
2.2.1 Penyelesian yang sangat sederhana ................................. 16
2.2.2 While .................................................................................. 17
2.2.3 Ekspresi Boolean (atau logical) ......................................... 18
2.2.4 List ..................................................................................... 19
2.2.5 For ...................................................................................... 21
2.3 Fungsi ....................................................................................... 22
2.3.1 Fungsi dengan satu variabel ............................................. 23
2.3.2 Variabel lokal dan variabel gobal ...................................... 24
2.3.3 Fungsi dengan beberapa variabel (argumen) ................... 25
2.3.4 Variabel keluaran (hasil = return) yang lebih dari satu .. 25
2.3.5 Fungsi tanpa nilai keluaran .............................................. 26

2
 3 Regresi linear .................................................................................. 28
3.1 Metode kuadrat terkecil ........................................................... 28
3.2 Metode kebolehjadian maksimum ........................................... 29
3.3 Parameter a dan b .................................................................... 30
3.4 Goodness-of-fit .......................................................................... 31
3.5 Koefisien korelasi ..................................................................... 32
4 Implementasi .................................................................................. 33
4.1 Membaca file data .................................................................... 33
4.2 Memformat dan memplot data ................................................ 36
4.3 Fungsi untuk membuka file, membaca, mengolah dan
memplot data .......................................................................................... 38
4.4 Fungsi untuk regresi linear ..................................................... 41
4.5 Plot data hasil regresi linear.................................................... 42
4.6 Goodnes-of-fit, chi-kuadrat ...................................................... 45
4.7 Sedikit dekorasi ........................................................................ 46
4.8 Interaktif .................................................................................. 47
5 Penutup ........................................................................................... 49
6. Referensi/Daftar bacaan ................................................................ 50
7 Lampiran (source kode) .................................................................. 51

3
I. Pendahuluan
1.1 Latar belakang
Membuat grafik hasil praktikum merupakan tugas yang tidak
bisa dihindari oleh setiap mahasiswa yang melakukan Praktikum
Fisika Dasar, sehingga setiap praktikan selalu bisa dipastikan pernah
membuat grafik hasil praktikum. Walaupun demikian, ada keluhan
bahwa mahasiswa yang telah mengambil Praktikum Fisika Dasar
ditengarai tetap tidak bisa membuat grafik dengan benar, sehingga
perlu diadakan kuliah tambahan yang khusus membahas tentang
grafik.

Tidak diketahui penyebab yang pasti mengapa mahasiswa tidak

memiliki kemampuan membuat grafik dengan baik dan benar
walaupun telah melaksanakan Praktikum Fisika selama 2 semester,
yaitu Praktikum Fisika Dasar I dan Praktikum Fisika Dasar II.
Tulisan ini tidak bermaksud untuk mencari penyebab itu, namun
hanya bertujuan untuk memberikan contoh bagaimana membuat
grafik dengan komputer berdasarkan metode yang telah teruji secara
eksperimental dan telah digunakan secara umum, yaitu metode
kuadrat terkecil, khususnya untuk regresi linear. Bahasa
pemrograman yang digunakan adalah Python.

Bahasa pemrograman Python dikategorikan sebagai multi-

purpose programming language. Apa saja bisa, dan kebutuhan apa
saja bisa dilakukan dengan bahasa Python. Mulai dari database
sederhana, komputasi sains, sampai dengan pemrograman web, bisa
dilakukan dengan Python.

Grafik hasil dari program ini dapat disimpan dalam file

berformat gambar (png = portable netwrok graphics), walaupun tidak
(belum) boleh digunakan dalam laporan praktikum, namun dapat
digunakan sebagai acuan, atau pembanding grafik yang dibuat dengan
tangan.

1.2 Rumusan masalah

Bagaimana membuat suatu program pembuat grafik linear untuk
data-data praktikum Fisika Dasar yang dapat digunakan sebagai
contoh/pembanding oleh mahasiswa dan untuk latihan membuat
grafik yang baik dan benar.

4
1.3 Tujuan
 Membuat program pembuat grafik regresi linear untuk
data praktikum Fisika Dasar yang : sederhana, open-
source, multi-platform
 Belajar pemrograman dengan bahasa Python sebagai dasar
untuk pemrograman yang lebih lanjut dan lebih kompleks

2 Pengantar singkat bahasa pemrograman Python

2.1 Yang dihadapi dalam membuat program : rumus
Rumus yang akan ditinjau adalah persamaan gerak dari sebuah
bola yang dilemparkan vertikal ke atas. Dari hukum Newton ke-2
tentang gerak, dapat diperoleh model matematik untuk gerakan bola,
yaitu posisi vertikal bola, disebut y, bervariasi terhadap waktu t
menurut persamaan

1 2
y(t )  v0t  gt (2.1)
2

dengan v0 adalah kecepatan awal bola, g adalah percepatan

gravitasi dan t adalah waktu. Dari persamaan di atas menunjukkan
bahwa sumbu-y dipilih sedemikian sehingga y = 0 pada saat t = 0.

Waktu yang diperlukan bola dari mulai saat dilemparkan

vertikal ke atas sampai ke ketinggian mula-mula dapat diperoleh
dengan menyelesaikan persamaan (1.1) untuk y(t) = 0,

1 2  1  2v0
v0t  gt  t  v0  gt   0  t = 0 atau t 
2  2  g

Jadi bola kembali ke posisi awal setelah 2v0 g detik, dan dengan
demikian masuk akal bila membatasi persamaan (2.1) hanya untuk
t  0,2v0 g . Pemrograman untuk menghitung ketinggian bola yang
dilemparkan vertikal ke atas dengan kecepatan awal v0 dibatasi untuk
t antara 0 sampai 2v0/g.

2.1.1 Menggunakan Python sebagai kalkulator

Program yang akan dibuat adalah menyelesaikan persamaan

(2.1) untuk nilai-nilai v0, g dan t tertentu. Dengan memilih v0  5 m/s
dan g  9,81 m/s2 , maka bola akan kembali ke ketinggian awal setelah

5
t  2v0 g  1 s , yang berarti kita hanya tertarik pada interval waktu 0
sampai 1 detik. Seandainya kita ingin menghitung ketinggian bola
pada waktu t = 0,6 s, maka dari persamaan (2.1)

1
y  5  0,6   9,8  0,62
2

Penulisan aritmatika di atas dapat diselesaian dan hasilnya bisa

ditampilkan dengan satu baris program Python :

print 5*0.6-0.5*9.8*0.6**2

Satu baris perhitungan di atas dituliskan dengan command line

Python, atau disebut terminal (Gambar 1.1). Untuk menutup jendela
command line digunakan instruksi : Exit().

Gambar 2.1 Jendela command line Python

Empat operator aritmatika standar dituliskan sebagai +,−,* dan /

dalam Python dan sebagian besar bahasa pemrograman lain, namun
untuk pangkat, Python menggunakan dobel-*, seperti pada baris
perintah di atas, 0,62 dituliskan sebagai 0.6**2.

2.1.2 Tentang Program dan Pemrograman

Sebuah program komputer hanyalah suatu urutan instruksi

kepada komputer yang dituliskan dalam bahasa komputer.
Kebanyakan program komputer agak-agak mirip dengan bahasa
Inggris, namun sangat lebih sederhana. Jumlah kata yang berkaitan
dengan instruksi kepada komputer sangat terbatas jumlahnya,
sehingga untuk melaksanakan satu operasi yang kompleks kita harus
menggabungkan sejumlah besar jenis instruksi yang berbeda-beda.
Teks program, yang berisi urutan instruksi-instruksi disimpan dalam
satu atau lebih file. Komputer hanya dapat melakukan pekerjaan
persis seperti apa yang diperintahkan kepadanya.

6
 Persepsi lain tentang “program” adalah sebuah file yang dapat
dijalankan dengan cara “dobel-klik” untuk melakukan sebuah
pekerjaan. Kadang file ini berupa file teks berisi instruksi (seperti
halnya pada Python), dan kadang file itu berupa terjemahan dari
keseluruhan teks program menjadi bahasa yang lebih dekat ke
komputer (bahasa mesin), yang lebih efisien, namun cukup sulit
dibaca oleh manusia. Semua program dalam bab ini terdiri dari teks
singkat yang tersimpan dalam satu file, sedangkan program yang
sering kita gunakan, sebagai contoh Firefox, atau Internet Explorer,
untuk membaca halaman web, terdiri dari teks program yang
didistribusikan dalam sejumlah besar file, ditulis oleh sejumlah besar
orang dan dalam waktu selama beberapa tahun. Salah satu file berisi
terjemahan dari keseluruhan program menjadi bahasa mesin, dan
inilah yang dijalankan dengan cara men”dobel klik”. Secara umum,
kata “program” dapat berarti file tunggal seperti Firefox atau yang
lain, dapat pula berarti kumpulan dari beberapa file yang berisi
instruksi-instruksi tekstual.

Kata “pemrograman” jelas berkaitan dengan penulisan program,

namun prosesnya tidak hanya sekedar menulis instruksi yang benar.
Pertama, kita harus paham bagaimana sebuah masalah dapat
diselesaikan dengan cara memberikan sejumlah urutan instruksi
kepada komputer. Pada umumnya inilah hal yang paling sulit pada
pemrograman. Kedua, kita harus menuliskan urutan instruksi-
instruksi tersebut dalam bahasa komputer dengan benar dan
menyimpannya dalam sebuah file (program). Ketiga, kita harus
menjalankan program itu, mengecek kebenaran hasilnya, dan kadang
masuk fase keempat yaitu menemukan kesalahan dalam program
kemudian membetulkannya. Penguasaan proses-proses tersebut
memerlukan banyak latihan, yang berarti membuat banyak program,
dan berusaha untuk membuat program-program itu “jalan”.

2.1.3 Perangkat untuk Menulis Program

Karena program berisi teks, maka kita memerlukan bantuan

program lain yang bisa untuk menuliskan teks itu dan menyimpannya
ke dalam sebuah file teks. Kita mungkin sudah terbiasa dan memiliki
pengalaman yang cukup dalam hal menuliskan teks dengan komputer,
namun untuk menuliskan program kita memerlukan program khusus,
yang disebut editor, yang menyimpan teks persis seperti apa yang kita
tuliskan. Program pengolah kata yang banyak digunakan, misalnya
Microsoft Word, ditujukan untuk menghasilkan hasil cetakan yang
indah, bukanlah perangkat yang bagus untuk menuliskan program,
meskipun bisa juga menyimpan file dalam format teks murni.

7
 Emacs, Xemacs dan Vim adalah editor yang umum digunakan
untuk menulis program pada sistem Linux atau Unix, termasuk
komputer Mac. Dalam Windows disarankan menggunakan Notepad++,
bisa juga Emacs atau Vim versi Windows. Semua program tersebut
bukan merupakan bagian dari paket instalasi standar Windows.
Editor khusus untuk program Python yang merupakan bagian dari
software Python disebut Idle biasanya sudah ikut terinstall pada saat
menginstall Python.

2.1.4 Menggunakan Idle untuk Menulis Program

Idle adalah Python Shell, semacam GUI editor teks untuk

menuliskan program Python baik secara interaktif (seperti command
line) atau untuk menuliskan beberapa baris instruksi dan
menyimpannya ke dalam satu file program. Program satu baris seperti
pada Gambar 2.1 dituliskan dalam Idle seperti ditunjukkan pada
Gambar 2.2.

Penulisan pada Idle dengan cara di atas masih merupakan

pemrograman interaktif seperti pada jendela terminal Python. Efektif
untuk instruksi yang hanya beberapa baris, namun jika program
terdiri dari sejumlah besar baris instruksi (dan biasanya begitu) maka
baris-baris instruksi disimpan ke dalam file. Untuk menuliskan
instruksi program yang akan disimpan ke dalam file, diperlukan
jendela editor yang baru, dengan menu : FileNew Window pada
Python Shell.

Gambar 2.2 Python Shell Idle yang berisi satu baris program

8
 Gambar 2.3 Jendela editor untuk menuliskan program

Satu baris instruksi sudah dituliskan pada editor, selanjutnya

disimpan ke dalam file dengan menu : FileSave.

Ekstensi .py harus dituliskan supaya dikenali oleh Idle sehingga

pada saat diedit, Idle mengatur tampilan sesuai dengan aturan
pemrograman Python, seperti indentasi dan pewarnaan untuk
keyword. Spasi (karakter kosong) dan tab (indentasi) sangat penting
dalam penulisan program Python, demikian juga keyword. Kesalahan
penulisan keyword mudah dideteksi dari pewarnaan oleh Idle, seperti
ditunjukkan pada Gambar 2.3. Kata print mempunyasi warna yang
berbeda karena print merupakan keyword Python. Kesalahan
indentasi (dengan tab) tidak mudah dideteksi, sehingga pada saat
dijalankan akan menyebabkan Error. Oleh karena itu dalam
pemrograman dengan Python (dan bahasa pemrograman komputer
yang lain tentu saja), diperlukan kehati-hatian dalam mengetikkan
baris instruksi.

9
 Gambar 2.4

2.1.5 Bagaimana Menjalankan Program

Gambar 2.5 Jendela Command Prompt untuk menjalankan file

program

File program bab1_1.py yang sudah disimpan dapat dijalankan

melalui jendela terminal, atau dos prompt pada Windows. Pada
Windows, Command Prompt dijalankan dari menu : StartAll
ProgramsAccessoriesCommand Prompt. Untuk menjalankan
program Python yang sudah disimpan, lokasi file program itu harus
diketahui, dan Command Prompt jalan di lokasi file itu.

Bagi yang sudah terbiasa dengan Windows Explorer, Command

Prompt bisa langsung dijalankan pada suatu folder yang dipilih
dengan cara meng-klik kanan nama folder itu kemudian memilih Dos
Prompt pada jendela popup yang muncul.

Gambar 2.6 Membuka Command Prompt (Dos Prompt) di folder yang

dipilih

2.1.6 Verifikasi Hasil Program

Hasil dari program harus dikontrol dengan hati-hati, apakah

hasil tersebut benar. Apa yang ditampilkan sebagai hasil program
tidak bisa dianggap selalu benar. Komputer hanya menjalankan sesuai
apa yang diperintahkan, sehingga kesalahan rumus, baik karena salah
ketik angka, atau karena salah menggunakan konsep, tidak akan

10
diperiksa oleh komputer. Komputer hanya memperhatikan sintaks
apakah sesuai dengan aturan bahasa pemrograman, jika benar,
mengolahnya, kemudian memberikan hasil. Jika ternyata hasil yang
diberikan komputer tidak benar, maka kesalahan dalam program
harus dicari dan dibenarkan.

Pada contoh satu baris program yang telah dibuat di muka dapat
dengan mudah dicek dengan menggunakan kalkulator. Dengan v0 = 5 ,
g = 9,8 dan t = 0.6, perhitungan dengan kalkulator menghasilkan
1,236. Cocok dengan yang dihasilkan oleh program.

2.1.7 Menggunakan Variabel

Jika kita ingin menghitung nilai y(t) untuk beberapa nilai t, maka
diperlukan pengubahan nilai t di dua tempat pada program satu-baris
yang telah dibuat sebelumnya. Pengubahan suatu nilai dalam suatu
program seperti itu lebih efektif dan sederhana bila instruksi
matematik dinyatakan dalam variabel, atau simbol. Hal ini berarti
bahwa kita dapat mendefinisikan v0, g, t dan y sebagai suatu variabel
dalam program, dengan cara memberikan nilai awal untuk v0, g, dan t
kemudian mengkombinasikan ketiganya sesuai dengan ruas kanan
persamaan (1.1) dan memasukkan hasil perhitungan ke variabel y.

Alternatif penulisan program sebelumnya dengan menggunakan

variabel dituliskan dalam teks berikut ini.

v0=5
g=9.8
t=0.6
y=v0*t-0.5*g*t**2
print y

Teks di atas dituliskan pada jendela Idle, dengan membuka

jendela baru : FileNew Window. Pada pemrograman dengan Python,
variabel tidak perlu dideklarasikan lebih dulu. Nama variabel
langsung dituliskan dan nilainya dituliskan setelah tanda sama
dengan.

Gambar 2.7 menampilkan baris-baris instruksi program yang

telah dimodifikasi yang ditulis pada Idle.

11
 Gambar 2.7 Jendela editor berisi baris-baris program yang
menggunakan variabel

Program kedua seperti yang tertulis pada Gambar 2.7 nampak

lebih mudah dibaca dan dipahami karena lebih dekat dengan
persamaan matematis (2.1). Juga lebih mudah dimodifikasi nilainya.
Misalnya akan mengganti nilai t maka hanya diperlukan mengganti
pada satu tempat saja, yaitu baris ke-3, tidak dua tempat seperti pada
program sebelumnya.

Untuk menjalankannya, program kedua harus disimpan lebih

dulu, misalnya dengan nama bab1_2.py. Jalankan pada jendela
Command Prompt.

Gambar 2.8 Jendela Dos Prompt untuk menjalankan program

bab1_2.py

Hasilnya sesuai dengan hasil program pertama.

2.1.8 Pemilihan Nama Variabel

Pemilihan nama variabel yang deskriptif dan dekat dengan

persamaan matematis yang akan diselesaikan adalah penting agar
program mudah dibaca dan lebih mudah untuk pengecekan kebenaran
program. Nama variabel dapat mengandung huruf dan angka dari 0
sampai 9, namun karakter pertama tidak boleh angka. Python

12
membedakan huruf besar dan huruf kecil, jadi v0 selalu berbeda
dengan V0.

Bisa saja kita mengganti nama variabel v0 menjadi

kecepatan_awal, g menjadi percepatan_gravitasi, t menjadi
waktu, dan seterusnya. Walaupun itu diperbolehkan dalam Python,
namun penulisan program menjadi tidak efektif. Aturan yang
disarankan adalah memberi nama variabel sesuai dengan persamaan
matematis yang akan diselesaikan.

2.1.9 Kata-kata Kunci dalam Python

Beberapa kata dipergunakan sebagai kata kunci dalam Python

sehingga tidak boleh digunakan sebagai nama variabel. Sebagai
contoh : print, break, and, class, continue, dan lain sebaginya. Kata-
kata kunci yang lengkap dapat dilihat dengan memberikan instruksi
pada GUI Python (Idle) : >>> help(‘keywords’). Semua kata kunci
ditampilkan pada Gambar 2.9.

Gambar 2.9 Jendela Idle yang menampilkan kata-kata kunci Python

Kata-kata kunci dapat diubah menjadi nama variabel, misalnya

dengan menambahkan garis bawah pada akhir kata kunci. Jadi else
adalah kata kunci, tetapi else_ adalah nama variabel.

2.1 10 Komentar

Komentar dalam pemrograman digunakan agar mudah dipahami

oleh orang lain yang tidak menulis program itu, atau mempermudah si
penulis program bila suatu saat akan melakukan modifikasi. Baris
komentar dalam Python diawali dengan karakter #. Apapun yang
tertulis setelah karakter itu akan diabaikan oleh Python. Gambar 1.10

13
menampilan program yang sama dengan sebelumnya namun ditambah
dengan komentar-komentar.

# program untuk menghitung tinggi bola yang dilempar ke

udara
v0=5 # kecepatan awal
g=9.8 # percepatan gravitasi
t=0.6 # waktu
y=v0*t-0.5*g*t**2 # posisi vertikal
print y

Program di atas sama persis dengan program yang ditampilkan

pada Gambar 2.7, namun program yang terakhir ini lebih mudah
dimengerti oleh manusia dengan adanya komentar-komentar yang
ditambahkan.

Pada program-program yang panjang, yang terdiri dari banyak

baris, memerlukan komentar yang informatif dan pemilihan variabel
yang cocok (baik) sehingga mudah dipahami oleh orang lain maupun
pemrogram sendiri.

2.1.11 Memformat Tampilan Teks dan Angka

Pada progam-program yang sudah dibuat sebelumnya, hasil

program hanya ditampilkan dalam angka saja. Lebih informatif jika
hasil program ditampilkan dengan keterangan, seperti misalnya :

Pada saat t = 0.6 s, bola berada pada ketinggian 1.24

meter.

dengan penulisan jumlah desimal yang sesuai (y hanya akurat sampai

pada centimeter saja). Format penulisan seperti di atas, baris
instruksinya dalam Python adalah:

print 'Pada saat t=%g s, bola berada pada ketinggian %.2f

meter.' % (t,y)

Perintah print pada baris instrukti di atas adalah untuk

menampilkan variabel string, semua karakter yang berada di dalam
tanda petik. Tanda petik bisa tunggal, atau dobel. String yang akan
ditampilkan di atas, menggunakan sintaks printf, berarti string
tersebut memiliki beberapa ‘slot’, dimulasi dengan karakter %, dalam
contoh di atas adalah %g dan %.2f. Slot-slot tersebut adalah letak
variabel yang akan ditampilkan. Ada dua slot yang disiapkan, berarti
ada dua variabel yang harus ditempatkan dalam slot-slot tersebut.
Variabel pertama, t, masuk ke slot yang pertama. Slot ini memiliki
spesifikasi format %g, karakter % menyatakan letaknya dan karakter

14
berikutnya menyatakan format penulisan. Karakter g berarti bahwa
bilangan real harus dituliskan se-compact mungkin. Variabel
berikutnya, y, masuk ke slot kedua. Format penulisannya adalah .2f
yang berarti bilangan real dituliskan dalam 2 angka di belakang koma.
Karakter f pada spesifikasi format tersebut adalah dari kata float, dari
floating-point number. Program yang lengkap dengan format penulisan
keluaran seperti ditunjukkan berikut ini.
# program untuk menghitung tinggi bola yang dilempar ke udara
v0=5 # kecepatan awal
g=9.8 # percepatan gravitasi
t=0.6 # waktu
y=v0*t-0.5*g*t**2 # posisi vertikal
print 'Pada saat t=%g s, bola berada pada ketinggian %.2f meter.'
% (t,y)

2.2 Loop dan List

Contoh program yang akan dibuat berikutnya adalah
menampilkan tabel konversi suhu Celcius dan Fahrenheit, dengan
kolom pertama berisi nilai-nilai suhu pada skala Celcius dan kolom
kedua berisi nilai-nilai suhu pada skala Fahrenheit. Persamaan
konversi dari Celcius ke Fahrenheit adalah

9
F C  32 (2.2)
5

dan tabel yang akan dibuat seperti di bawah ini

-20 -4.0
-15 5.0
-10 14.0
-5 23.0
0 32.0
5 41.0
10 50.0
15 59.0
20 68.0
25 77.0
30 86.0
35 95.0
40 104.0

15
2.2.1 Penyelesian yang sangat sederhana

Nilai skala suhu Fahrenheit dapat langsung dihitung dengan

persamaan 2.2., sehingga tabel konversi dapat diperoleh dengan
menuliskan beberapa baris perhitungan.

C=−20; F=9.0/5*C+32; print C,F

C=−15; F=9.0/5*C+32; print C,F
C=−10; F=9.0/5*C+32; print C,F
C=−5; F=9.0/5*C+32; print C,F
C=0; F=9.0/5*C+32; print C,F
C=5; F=9.0/5*C+32; print C,F
C=10; F=9.0/5*C+32; print C,F
C=15; F=9.0/5*C+32; print C,F
C=20; F=9.0/5*C+32; print C,F
C=25; F=9.0/5*C+32; print C,F
C=30; F=9.0/5*C+32; print C,F
C=35; F=9.0/5*C+32; print C,F
C=40; F=9.0/5*C+32; print C,F

Hasil program :

>>>
-20 -4.0
-15 5.0
-10 14.0
-5 23.0
0 32.0
5 41.0
10 50.0
15 59.0
20 68.0
25 77.0
30 86.0
35 95.0
40 104.0
>>>

Diperoleh tabel yang diharapkan dengan format yang tidak rapi,

namun bisa diatasi dengan perintah print yang bisa diatur, yaitu
dengan printf. Hal yang kurang baik dengan cara pemrograman
seperti di atas adalah penulisan statement (perintah) yang diulang-
ulang. Pertama, membosankan, dan yang kedua, manfaat komputer
adalah untuk perhitungan yang berulang (repetition), sehingga setiap
bahasa pemrograman pasti ada cara untuk mengulang perhitungan
secara otomatis. Cara pengulangan dalam pemrograman adalah loops,
dan dalam Python (dan bahasa pemrogaman yang lain) ada dua cara,
yaitu while dan for.

16
2.2.2 While

While digunakan untuk mengulang sekumpulan perintah selama

kondisi (syarat) yang diberikan masih berlaku. Nilai suhu dalam
Celcius yang akan dikonversi mulai dari −20 sampai 40 dengan
interval 5, jadi kondisi untuk menjalankan perintah adalah, mulai dari
suhu −20 dan jika suhu Celcius nilainya lebih kecil atau sama dengan
40. Secara matematis, urutan perintahnya adalah :

C  20
while C  40 ulangi perintah berikut
9
F C  32
5
tulis C , F
tambahkan 5 ke C

Dituliskan dalam Python :

C = -20 # nilai awal C

dC = 5 # interval penambahan C
while C <= 40: # kondisi
F = (9.0/5)*C + 32 # hitung F
print C, F # tulis C dan F
C = C + dC # ubah nilai C

Hasil program :

-20 -4.0
-15 5.0
-10 14.0
-5 23.0
0 32.0
5 41.0
10 50.0
15 59.0
20 68.0
25 77.0
30 86.0
35 95.0
40 104.0

Sama dengan hasil sebelumnya. Yang penting (dan harus) adalah

bahwa blok perintah yang akan diulang (dimulai setelah tanda titik
dua, : ) harus dituliskan menjorok (indent), dan Python otomatis
meletakkan indent pada tempat yang seharusnya. Beda dengan C atau
C++ yang menggunakan tanda { } untuk menandai blok perintah.

17
 Jika aturan tersebut dilanggar, pada saat dijalankan, akan
muncul peringatan :

Gambar 2.10 Pemberitahuan jika ada kesalahan sintaks pemrograman

Pada jendela editor (IDLE) Python menunjukkan tempat di mana
seharusnya di-indent, ditunjukkan pada Gambar 2.11. Kesalahan
semacam itu mudah diperbaiki, tinggal klik mouse pada awal baris
(pada huruf F), kemudian tekan sekali tombol Tab. Demikian
seterusnya sampai akhir blok.

Gambar 2.11 Kursor yang berada pada lokasi kesalahan program

Ada cara yang lebih singkat untuk menuliskan C = C + dC,
yaitu

C += dC # ekivalen dengan C = C + dC

dan yang lain :

C -= dC # ekivalen dengan C = C – dC
C *= dC # ekivalen dengan C = C*dC
C /= dC # ekivalen dengan C = C/dC

2.2.3 Ekspresi Boolean (atau logical)

Pada contoh di atas, digunakan ekspresi boolean C <= 40 yang

memiliki nilai True dan False. Ekspresi yang lain adalah :

C == 40 # C sama dengan 40
C != 40 # C tidak sama dengan 40

18
 C >= 40 # C lebih besar atau sama dengan 40
C > 40 # C lebih besar dari 40
C < 40 # C lebih kecil dari 40

Ekspresi boolean tidak hanya untuk angka, tetapi semua ekspresi

yang bisa mempunyai nilai benar (True) atau salah (False) dapat
digunakan. Bisa juga menggunakan kata not untuk menyatakan tidak
sama dengan. Jika C == 40 bernilai True, maka not C == 40 bernilai
False.

Ekspresi boolean dapat digabung dengan and dan or. Untuk and,
kondisi gabungan bernilai True jika kedua kondisi bernilai True,
sedangkan untuk or, kondisi gabungan bernilai True jika salah satu
kondisi bernilai True.

>>> x = 0; y = 1.2
>>> x >= 0 and y <1
False
>>> x >=0 or y < 1
True
>>> x > 0 or not y > 1
False
>>> -1 < x <= 0 # sama dengan : -1 < x and x <= 0
True
>>> not (x > 0 or y > 0)
False
>>>

Pada contoh di atas, not digunakan untuk nilai kondisi gabungan

yang berada di dalam tanda kurung. Kondisi di dalam kurung bernilai
True karena salah satu bernilai True, yaitu y > 0, sehingga not
menghasilkan nilai kondisi False.

2.2.4 List

Pada contoh-contoh sebelumnya, sebuah variabel hanya berisi

satu nilai saja. Dalam Python, beberapa nilai dapat digabung ke dalam
satu grup dan disimpan dalam sebuah List. Sebagai contoh, nilai-nilai
suhu Celcius pada tabel konversi Celciuls  Fahrenheit.

>>> C = [-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35,
40]
>>> C[0]
-20
>>> C[-1]
40
>>>

19
 Anggota grup yang pertama diberi indeks 0. Indeks negatif
menyatakan pengambilan mulai dari indeks terakhir.

Anggota, atau unsur, atau elemen, dari suatu List dapat

ditambah dengan perintah append, ditambahkan pada akhir List.

>>> C.append(45)
>>> C
[-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45]

Bisa juga dengan menambahkan isi dari List yang lain.

>>> D = [50, 55]

>>> C = C + D # sama dengan C = C + [50, 55]
>>> C
[-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45,
50, 55]

Untuk menyisipkan satu nilai ke List digunakan perintah insert.

>>> C.insert(6, 7)
>>> C
[-20, -15, -10, -5, 0, 5, 7, 10, 15, 20, 25, 30, 35, 40, 45,
50, 55]
>>>

Perintah di atas adalah untuk menyisipkan nilai 7 pada indeks

ke-6. Untuk menghapus salah satu elemen :

>>> del C[6]

>>> C
[-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45,
50, 55]

Perintah del C[6] adalah menghapus elemen C pada indeks ke-

6. Jumlah elemen dari suatu List diperoleh dengan perintah len.

>>> len(C)
16
>>>

Untuk mengetahui apakah suatu nilai merupakan elemen dari

suatu List :

>>> 20 in C
True
>>> -20 in C
True
>>> 24 in C

20
False
>>>

2.2.5 For

Jika data-data (angka, string, dsb) sudah tersimpan dalam

sebuah List, langkah pemrograman biasanya adalah melakukan satu
operasi yang sama pada setiap elemen List. Ini bisa dilakukan dengan
For.

suhu = [0, 20, 40, 60, 80, 100]

for C in suhu:
print 'elemen dari suhu : ', C
print 'Daftar suhu memiliki ', len(suhu), ' elemen'

Hasil jalannya program :

>>>==========================RESTART========================
==
>>>
elemen dari suhu : 0
elemen dari suhu : 20
elemen dari suhu : 40
elemen dari suhu : 60
elemen dari suhu : 80
elemen dari suhu : 100
Daftar suhu memiliki 6 elemen
>>>

Dengan menggunakan List dan For, maka program membuat

tabel konversi suhu CelciusFahrenheit dapat diubah menjadi :

suhuC = [-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35,
40]
for C in suhuC:
F = (9.0/5)*C + 32
print C, F

Hasil jalannya program :

>>>=========================RESTART=========================
=
>>>
-20 -4.0
-15 5.0
-10 14.0
-5 23.0
0 32.0

21
5 41.0
10 50.0
15 59.0
20 68.0
25 77.0
30 86.0
35 95.0
40 104.0
>>>

Daftar tabel masih kurang rapi. Oleh karena itu digunakan

perintah print format (printf).

suhuC = [-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35,
40]
for C in suhuC:
F = (9.0/5)*C + 32
print '%5d %5.1f' % (C, F)

Hasil program :

Gambar 2.12 Hasil program dengan perintah pencetakan yang diatur

formatnya

2.3 Fungsi
Sebuah fungsi, dalam bahasa pemrograman, adalah sekumpulan
perintah yang mempunyai suatu tujuan tertentu, yaitu menghasilkan
satu atau beberapa variabel, atau hanya melakukan suatu tugas tanpa
menghasilkan variabel seperti menampilkan nilai atau
menggambarkan grafik.

22
2.3.1 Fungsi dengan satu variabel

Contoh fungsi dengan satu variabel adalah konversi sakal suhu

dari Celcius ke Fahrenheit, yang perhitungannya telah dilakukan
sebelumnya, yaitu berdasarkan persamaan (2.2)

def F(C):
return (9.0/5)*C + 32

Semua fungsi dalam Python dimulai dengan def, diikuti dengan

nama fungsi, dan kemudian di dalam kurung adalah
argumen/parameter fungsi. Jika argumen lebih dari satu, antar
argumen dibatasi dengan tanda koma. Pada contoh di atas hanya ada
satu argumen, yaitu C. Baris-baris perintah dalam fungsi harus ditulis
menjorok (indented). Pada akhir fungsi dituliskan return dan varibel
yang dihasilkan oleh fungsi itu.

Untuk menjalankan sebuah fungsi, kita harus memanggilnya.

Karena fungsi menghasilkan (return) sebuah nilai, kita harus
menyimpan nilai itu untuk penggunaan selanjutnya. Berikut ini
beberapa contoh.

>>> def F(C):

return (9.0/5)*C + 32

>>> a = 10
>>> F(a)
50.0
>>> temp = F(15.5)
>>> temp
59.900000000000006
>>> sum_temp = F(10) + F(20)
>>> sum_temp
118.0
>>>

Pada contoh di atas, fungsi menghasilkan bilangan desimal

(float). Dengan sedikit perubahan, kita dapat menghasilkan variabel
string :

>>> def F2(C):

nilai_F = (9.0/5)*C + 32
return '%.1f derajat Celcius sama dengan '\
'%.1f derajat Fahrenheit' % (C, nilai_F)

>>> s1 = F2(21)
>>> s1

23
 '21.0 derajat Celcius sama dengan 69.8 derajat
Fahrenheit'
>>>

2.3.2 Variabel lokal dan variabel gobal

Pada fungsi F2(C), variabel nilai_F adalah variabel lokal, yang

hanya dikenali di dalam lingkup fungsi itu.

>>> c1 = 37.5
>>> s2 = F2(c1)
>>> nilai_F

Traceback (most recent call last):

File "<pyshell#19>", line 1, in <module>
nilai_F
NameError: name 'nilai_F' is not defined
>>>

Demikian juga variabel yang dijadikan argumen fungsi adalah

variabel lokal. Sedangkan variabel global adalah variabel yang dapat
diakses pada keseluruhan program.

>>> def F3(C):

nilai_F = (9.0/5)*C + 32
print 'Variabel di dalam F3 : C=%s nilai_F=%s r=%s' %
(C, nilai_F, r)
return '%.1f derajat Celcius sama dengan '\
'%.1f derajat Fahrenheit' % (C, nilai_F)

>>> C = 60 # membuat variabel global

>>> r = 21 # variabel global
>>> s3 = F3(r)
Variabel di dalam F3 : C=21 nilai_F=69.8 r=21
>>> s3
'21.0 derajat Celcius sama dengan 69.8 derajat
Fahrenheit'
>>> C
60
>>> r
21
>>>

Pada contoh di atas, ada dua variabel C, yang satu lingkupnya

global (C = 60) dan yang satunya lokal (C = 21). Variabel r adalah
variabel global yang dikenal di dalam fungsi F3, dan di luar fungsi.

24
2.3.3 Fungsi dengan beberapa variabel (argumen)

Contoh fungsi dengan 2 argumen adalah seperti tertulis pada

persamaan (2.1), yaitu

1 2
y(t )  v0t  gt
2

>>> def yfunc(t, v0):

g = 9.81
return v0*t - 0.5*g*t**2

>>> y = yfunc(0.1, 6)
>>> y
0.55095
>>>

Pada fungsi di atas, variabel float g adalah variabel konstanta

lokal. Variabel t dan v0 juga variabel lokal. Beberapa cara
pemanggilan fungsi ditunjukkan pada perintah berikut.

>>> y = yfunc(0.1, v0=6)

>>> y
0.55095
>>> y1 = yfunc(t=0.1, v0=6)
>>> y1
0.55095
>>> y2 = yfunc(v0=6, t=0.1)
>>> y2
0.55095
>>>

Semuanya memberikan hasil yang sama. Dengan memberikan

nama variabel dalam argumen fungsi akan memudahkan dalam
pembacaan baris-baris kode.

2.3.4 Variabel keluaran (hasil = return) yang lebih dari satu

Fungsi Python juga dapat menghasilkan lebih dari satu variabel.

Misalkan kita ingin menghitung y dan turunannya terhadap waktu
(kecepatan).

>>> def yfunc(t, v0):

g = 9.81
y = v0*t - 0.5*g*t**2
dydt = v0 - g*t
return y, dydt

>>> posisi, kecepatan = yfunc(0.6, 3)

25
 >>> posisi, kecepatan
(0.034199999999999786, -2.886)
>>>

Jika suatu fungsi menghasilkan dua nilai, kita juga harus

menyiapkan 2 variabel untuk menampung nilai keluaran, sebagai
contoh pada kode di atas, 2 variabel itu adalah : posisi dan kecepatan.

Dengan perintah penulisan berformat, kita dapat membuat tabel

yang rapi, yang menunjukkan tiap langkah perubahan t, posisi, dan
kecepatan.
>>> nilai_t = [0.05*i for i in range(10)]
>>> for t in nilai_t:
posisi, kecepatan = yfunc(t, v0=5)
print 't=%-10g posisi=%-10g kecepatan=%-10g' %
(t,posisi,kecepatan)

t=0 posisi=0 kecepatan=5

t=0.05 posisi=0.237737 kecepatan=4.5095
t=0.1 posisi=0.45095 kecepatan=4.019
t=0.15 posisi=0.639638 kecepatan=3.5285
t=0.2 posisi=0.8038 kecepatan=3.038
t=0.25 posisi=0.943437 kecepatan=2.5475
t=0.3 posisi=1.05855 kecepatan=2.057
t=0.35 posisi=1.14914 kecepatan=1.5665
t=0.4 posisi=1.2152 kecepatan=1.076
t=0.45 posisi=1.25674 kecepatan=0.5855
>>>

2.3.5 Fungsi tanpa nilai keluaran

Kadang diperlukan juga suatu fungsi yang hanya menjalankan

baris-baris perintah tanpa menghasilkan nilai keluaran. Misalkan kita
akan membuat tabel nilai pendekatan dan ralatnya dari penjumlahan
:

n i
1 x 
L( x ; n)     (2.3)
i 1 i  1  x 

Dapat ditunjukkan bahwa L(x;n) adalah pendekatan dari nilai

ln(1+x) untuk nilai n berhingga dan x  1 . Pendekatan itu menjadi
eksak untuk limit:

ln(1  x )  lim L( x ; n).

n

Pertama, dibuat dulu fungsi L(x;n) :

from math import log

26
def L(x, n):
jumlah = 0
for i in range(1, n+1):
jumlah += (1.0/i)*(x/(1.0+x))**i
nilai_jumlah = jumlah
suku_pertama_yg_diabaikan = (1.0/(n+1))*(x/(1.0+x))**(n+1)
exact_error = log(1+x) - nilai_jumlah
return nilai_jumlah, suku_pertama_yg_diabaikan, exact_error

yang menghasilkan tiga variabel keluaran dan memerlukan 2

parameter (argumen) masukan, yaitu x dan n. Fungsi di atas
memerlukan fungsi log dari modul math, sehingga pada awal kode
harus diimport terlebih dahulu.
from math import log

Selanjutnya, fungsi untuk membuat tabelnya adalah :

def tabel(x):
print '\nx=%g, ln(1+x)=%g' % (x, log(1+x))
for n in [1, 2, 10, 100, 500]:
nilai, berikutnya, error = L(x, n)
print 'n=%-4d %-10g (suku berikutnya : %8.2e '\
'error: %8.2e)' % (n, nilai, berikutnya, error)

Terakhir, untuk memanggil fungsi tabel, dengan nilai x = 10 :

tabel(10)

Secara lengkap, keseluruhan programnya adalah sebagai berikut,

yang disimpan dengan nama fungsi.py.

from math import log

def L(x, n):

jumlah = 0
for i in range(1, n+1):
jumlah += (1.0/i)*(x/(1.0+x))**i
nilai_jumlah = jumlah
suku_pertama_yg_diabaikan =
(1.0/(n+1))*(x/(1.0+x))**(n+1)
exact_error = log(1+x) - nilai_jumlah
return nilai_jumlah, suku_pertama_yg_diabaikan,
exact_error

def tabel(x):
print '\nx=%g, ln(1+x)=%g' % (x, log(1+x))
for n in [1, 2, 10, 100, 500]:
nilai, berikutnya, error = L(x, n)
print 'n=%-4d %-10g (suku berikutnya : %8.2e '\
'error: %8.2e)' % (n, nilai, berikutnya,
error)

27
tabel(10)

Hasil program :

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

x=10, ln(1+x)=2.3979
n=1 0.909091 (suku berikutnya : 4.13e-01 error:
1.49e+00)
n=2 1.32231 (suku berikutnya : 2.50e-01 error:
1.08e+00)
n=10 2.17907 (suku berikutnya : 3.19e-02 error: 2.19e-
01)
n=100 2.39789 (suku berikutnya : 6.53e-07 error: 6.59e-
06)
n=500 2.3979 (suku berikutnya : 3.65e-24 error: 6.22e-
15)
>>>

3 Regresi linear
Dalam eksperimen fisika, untuk menguji hubungan antara dua
variabel, y dan x, dilakukan dengan mengubah salah satu variabel,
disebut variabel bebas, biasanya x, kemudian mengukur variabel tak
bebas, y, sehingga diperoleh pasangan nilai (xi,yi) sebanyak N, yaitu
jumlah pengukuran yang telah dilakukan. Jika dari teori diketahui
bahwa hubungan antara x dan y adalah linear, maka dapat didekati
dengan persamaan

y = a + bx (3.1)

yang jika digambarkan dalam koordinat-xy akan berbentuk garis

lurus dengan titik potong pada sumbu-y bernilai a dan kemiringan b.
Nilai-nilai a dan b yang terbolehjadi diperoleh dari titik-titik data
dengan metode kuadrat terkecil.

3.1 Metode kuadrat terkecil

Data-data hasil pengukuran (xi,yi) terdiri dari pasangan nilai
variabel bebas dan variabel tak bebas. Nilai-nilai a dan b dicari
sedemikian sehingga memperkecil perbedaan antara yi dengan nilai
y(xi) yang dihitung dengan persamaan (3.1). Untuk sembarang nilai a
dan b, dapat dihitung selisih (beda) antara nilai ukur (yi) dengan nilai
hitung (y(xi)) :

28
 yi = yi – y(xi) = yi – a – bx (3.2)

Dengan pemilihan parameter yang tepat, maka perbedaan itu

bisa relatif kecil. Jika semua nilai persamaan dijumlahkan, dan
masing-masing beda cukup kecil akan diperoleh hasil penjumlahan
yang kecil pula. Namun demikian, penjumlahan seluruh nilai (3.2)
tidak bisa dijadikan ukuran baik tidaknya pendekatan persamaan
garis lurus terhadap data-data eksperimen, karena bisa saja
perbedaan (3.2) ada yang bernilai positif cukup besar, dan ada yang
bernilai negatif cukup besar, dan jika dijumlahkan saling
menghilangkan. Untuk menghindari hal itu, bisa saja nilai (3.2)
diambil harga mutlaknya, namun penyelesaian analitiknya menjadi
sulit, maka dipilih untuk menjumlahkan (3.2) setelah dikuadratkan
lebih dulu.

Tidak ada satu metode untuk mengoptimalkan parameter yang

dapat berlaku untuk semua masalah, namun ada satu metode
sederhana yang sudah teruji secara eksperimental, yaitu metode
kuadrat terkecil. Metode ini bisa disebut sebagai kasus khusus dari
metode yang lebih umum, method of maximum likelihood, metode
kebolehjadian maksimum.

3.2 Metode kebolehjadian maksimum

Hasil pengukuran terdiri dari distribusi sampel yang dicuplik
dari distribusi induk yang menentukan ukuran kebolehjadian
memperoleh data-data pengukuran itu. Untuk distribusi induk,
didefinisikan parameter-parameter a0 dan b0, yang memberikan
hubungan sesungguhnya antara y dan x dalam bentuk persamaan

y0(x) = a0 + b0x (3.3)

Dengan menganggap bahwa distribusi induk berbentuk

Gaussian, maka kebolehjadian Pi untuk memperoleh nilai ukur yi
dengan deviasi standar i di sekitar nilai sesungguhnya y0(xi)
diberikan oleh persamaan

1  1  y  y ( x ) 2 
 
Pi  exp   i 0 i
  (3.4)
σi 2π  2  σi  

Kebolehjadian memperoleh satu set pengukuran yang terdiri dari

sejumlah N nilai yi adalah hasil kali dari kebolehjadian tiap
pengukuran

29
 N  1   1  y  y ( x ) 2 
 
P ( a0 ,b0 )  Pi   
  exp    i 0 i
  (3.5)
i 1  σi 2π   2  σi  

Demikian juga, untuk setiap nilai parameter a dan b,

kebolehjadian memperoleh satu set hasil ukur adalah

N  1   1  y  y( x ) 2 
 
P ( a,b)   
  exp    i i
  (3.6)
i 1  σi 2π   2  σi  

dengan y(x) dihitung dari persamaan (1).

Karena perkalian dari faktor pertama pada persamaan (3.6)

adalah konstanta, tidak bergantung pada pemilihan a dan b, maka
memaksimumkan kebolehjadian P(a,b) sama dengan meminimumkan
jumlahan pangkat dari e pada persamaan (3.6). Jumlahan itu diberi
simbol 2 (chi kuadrat), yang didefisikan sebagai parameter goodness-
of-fit, ukuran baik-tidaknya fit,

N 2 2
 y  y( xi )  N 
1 
χ   i    yi  a  bxi  
2
  (3.7)
i 1  σi  i 1  σ i 

Jadi metode untuk memperoleh nilai parameter a dan b yang

optimum adalah bagaimana meminimumkan jumlahan kuadrat pada
persamaan (3.7) (metode kuadrat terkecil).

3.3 Parameter a dan b

Untuk memperoleh parameter a dan b yang optimum, persamaan
(3.7) didife-rensialkan masing-masing terhadap a dan b kemudian
disamakan dengan nol karena nilai persamaan (3.7) minimum.
Diperoleh dua persamaan simultan dengan dua besaran tidak
diketahui, yang dapat diselesaikan dengan metode determinan,
diperoleh (Bevington, 1980) :

30
 1  xi2 y x xy 
a    2  2i   2i  i 2 i

  σi σi σi σi 
1 1 xy x y 
b    2  i 2 i   2i  2i  (3.8)
  σi σi σi σi 
2
1  x 
xi2
   2  2    2i 
σi σi  σi 

dengan perkiraan ketidakpastian masing-masing sebesar

1 xi2
σ a2

 σ2
i
(3.9)
1 1
σb2

 σi2

3.4 Goodness-of-fit
Metode kuadrat terkecil didasarkan pada hipotesis bahwa fit
(pencocokan data) yang optimum adalah yang meminimumkan jumlah
berbobot dari seluruh besar simpangan data yi terhadap nilai hasil fit
y(xi). Besar jumlahan tersebut dicirikan oleh variansi s2, yang
merupakan perkiraan terhadap variansi hasil ukur 2. Untuk fungsi
y(xi) yang linear dalam m parameter dan dicocokkan pada sejumlah N
titik data,

 
  1   y  y  x   2 
2  i i 
s2 
1  σi  
(3.10)
N m 1  
N 
 1 
 2
 σi 

Jika persamaan (7) disubstitusikan ke persamaan (3.10)

diperoleh

1 χ2
s2 
N m 1
  N 
 1 
 2
 σi 

yang dapat dituliskan menjadi

31
 s2 χ2

σi2 ν

dengan σi2 adalah rata-rata berbobot dari variansi individuil,

dan ν  N  m adalah derajat kekebasan dari N data dengan m
parameter.

Nilai

χ2
χν2 
ν (3.11)

disebut chi-kuadrat tereduksi.

Jika fungsi pencocokan data yang diperoleh merupakan

pendekatan yang baik pada distribusi induk, maka nilai s2 merupakan
perkiraan yang baik terhadap variansi distribusi induk 2, dan nilai
chi-kuadrat tereduksi akan mendekati 1. Jadi untuk menguji apakah
hasil fit cocok untuk menggambarkan distribusi data, maka dihitung
chi-kuadrat tereduksi, dan apakah nilainya dekat dengan 1. Hasil fit
yang tidak cocok untuk menggambarkan titik-titik data akan
menyebabkan nilai chi-kuadrat tereduksi yang besar, jauh lebih besar
dari 1. Tetapi nilai chi-kuadrat tereduksi yang kecil dari satu tidak
otomatis menunjukkan kecocokan fit dengan data, namun hanya
merupakan konsekuensi dari kenyataan adanya ketidakpastian dalam
menentukan s2, dan nilai chi-kuadrat tereduksi akan berfluktuasi
pada tiap hasil eksperimen.

Jadi selama diperoleh nilai chi-kuadrat tereduksi yang tidak jauh

lebih besar dari 1, ada harapan bahwa fungsi pencocokan data bisa
digunakan, atau sesuai untuk menggambarkan distribusi data hasil
eksperimen. Diperlukan pengujian yang lebih lanjut, yaitu dengan
distribusi kebolehjadian chi-kuadrat tereduksi sebagai fungsi dari
derajat kebebasan. Namun pengujian itu tidak dibahas dalam tulisan
ini. Pembahasan yang memadai dapat dibaca dalam buku yang diacu
(Bevington, 1980).

3.5 Koefisien korelasi

Dengan metode regresi linear diperoleh parameter a dan b yang
merupakan parameter untuk persamaan garis linear y = a + bx
sebagai garis terbaik yang menggambarkan hubungan antara variabel
bebas x dengan variabel tak bebas y. Namun tentu saja kita tidak bisa

32
begitu saja menyimpulkan bahwa hubungan antara x dan y adalah
linear, karena regresi linear bisa diterapkan pada sembarang set hasil
ukur, dan pasti memberikan hasil berupa paramater a dan b. Kita
memerlukan suatu tolok ukur yang lain, yang tidak bergantung pada
hasil regresi linear, namun hanya bergantung pada nilai-nilai variabel
x dan y untuk menguji apakah ada korelasi linear antara keduanya.
Tolok ukur tersebut adalah koefisien korelasi linear. Untuk sebanyak
N set data hasil ukur (xi,yi), didefinisikan koefisien korelasi linear
(Bevington, 1980) :

N xi yi  xi yi

r 1 1
(3.12)
 N x 2   x 
2 2  N y2   y 
2 2
 i i 
  i i 


Nilai r berada pada daerah antara 0 sampai 1. Nilai 0 berarti

tidak ada hubungan linear sama sekali, dan nilai 1 berarti hubungan
antara x dan y adalah linear.

4 Implementasi
4.1 Membaca file data
Data-data hasil eksperimen disimpan dalam file teks yang terdiri
dari beberapa baris yang menyatakan jumlah pengukuran dan terdiri
dari 3 kolom. Kolom pertama untuk data variabel bebas (x), kolom
kedua untuk variabel terukur, atau variabel tak bebas (y) dan kolom
ketiga untuk ketidakpastian pada variabel hasil ukur (y). Ralat, atau
ketidakpastian pada variabel bebas (x) diabaikan.

Sebagai contoh, digunakan data-data pada soal nomor 6.5 dari

buku Data Reduction and Error Analysis for Physical Sciences
(Bevington, 1980).

6.5. A student hangs masses on a spring and measures the spring’s

extension as a function of the applied force in order to find the
spring constant k. Her measurements are :

Mass (kg) 200 300 400 500 600 700 800 900
Extension 5.1 5.5 5.9 6.8 7.4 7.5 8.6 9.4
(cm)

There is an uncertainty of 0.2 in each measurement of extension.

The uncertainty in the masses is negligible. For a perfect spring,
the extension L of the spring will be related to the applied force
by the relation kL = F, where F = mg and L = L – L0, and L is

33
 the unstretched length of the spring. Use these data and the
method of least squares to fing the spring constant k, and the
unstretched length of the spring L0, and their uncertainties. Find
2 for the fit and the associated probability.

Data-data dalam soal ditulis kembali dengan editor teks

(notepad) dengan format seperti yang diinginkan untuk program yang
akan dibuat, kemudian disimpan dengan nama : data.txt.

200 5.1 0.2

300 5.5 0.2
400 5.9 0.2
500 6.8 0.2
600 7.4 0.2
700 7.5 0.2
800 8.6 0.2
900 9.4 0.2

Antara kolom-kolom angka dipisahkan dengan sekali ketuk

spacebar. Sebelum menuliskan program, perintah-perintah dicoba
lebih dulu dalam jendela IDLE (Python shell). Dengan cara interaktif
seperti ini, maka sebaiknya file yang berisi data-data eksperimen
disimpan ke dalam folder yang sama dengan IDLE yang digunakan.
Dalam pemrograman ini digunakan Python versi 2.7, maka file
data.txt disimpan dalam folder : C:\Python27.

Perintah untuk membuka (menyiapkan) file untuk dibaca (read)

adalah :

>>> filedata = open('data.txt','r')

Argumen string pertama adalah nama file jika file berada dalam
folder yang sama dengan IDLE. Jika berada di folder yang lain,
argumen ini berisi path yang lengkap di mana file itu berada.
Argumen string kedua adalah kode operasi terhadap file yang dibuka,
apakah akan dibaca isinya, read = 'r', atau akan ditulisi, write =
'w'.

Jika setelah perintah di atas diisikan dan diakhiri dengan Enter,

lalu muncul kesalahan, berarti file yang akan dibuka tidak
diketemukan. Cara yang mudah untuk mengatasinya adalah dengan
cara menyalin file yang akan dibuka ke folder yang sama dengan
IDLE.

Setelah dibuka, isi file dibaca dan ditampilkan baris per baris :

34
 >>> for baris in filedata:
print baris

200 5.1 0.2

300 5.5 0.2

400 5.9 0.2

500 6.8 0.2

600 7.4 0.2

700 7.5 0.2

800 8.6 0.2

900 9.4 0.2

>>>

Perintah pertama :

>>> for baris in filedata:

adalah untuk membaca isi file baris per baris dan menyimpannya
ke dalam variabel string baris. Setelah perintah loop for harus
diakhiri dengan titik dua, kemudian tekan Enter, dan dituliskan
perintah yang dijalankan dalam loop : print baris, kemudian Enter 2
kali. Karena Python menggunakan simbol titik (.) untuk menandai
bilangan desimal (float), maka data-data juga disimpan dengan simbol
titik untuk bilangan desimal.

Tiap baris dalam file data terdiri dari tiga kolom yang
menyatakan tiga data, x, y dan e (ralat dalam y). Tiga data ini harus
dipisahkan agar diperoleh masing-masing nilai x, y dan e. Seperti telah
disinggung sebelumnya bahwa isi file data disimpan ke dalam variabel
string baris. Pada perintah yang terakhir, isi variabel ini adalah
baris terakhir dalam file, yaitu '900 9.4 0.2'.

>>> print baris

900 9.4 0.2
>>>

Data-data pada kolom dipecah dengan perintah :

>>> datanya = baris.split()

>>>

35
 Dengan perintah di atas, maka string baris dipecah dengan
karakter pemisah (whitespace) karakter kosong (spasi = spacebar), dan
disimpan ke dalam variabel datanya. Tipe dari variabel datanya
adalah list.

>>> type(datanya)
<type 'list'>
>>>

Variabel list fungsinya sama dengan array, dengan tiap anggota,

atau elemen ditandai dengan indeks, mulai dari angka 0.

>>> datanya
['900', '9.4', '0.2']
>>> datanya[0]
'900'
>>> datanya[1]
'9.4'
>>> datanya[2]
'0.2'
>>>

Dengan demikian data-data x, y dan e sudah terpisah, dengan x

memiliki indeks 0, y dengan indeks 1 dan e dengan indeks 2.

4.2 Memformat dan memplot data

Data-data yang sudah dipisahkan masih bertipe string,
sedangkan untuk dapat diolah harus berupa variabel angka. Jadi tiap
data diubah lebih dulu menjadi variabel angka, dalam hal ini berupa
variabel desimal (float).

>>> x = float(datanya[0])
>>> y = float(datanya[1])
>>> e = float(datanya[2])
>>> x, y, e
(900.0, 9.4, 0.2)
>>>

Dengan demikian diperoleh data-data x, y dan e yang bisa diolah

dengan operasi-operasi matematik, khususnya persamaan-persamaan
untuk metode kuadrat terkecil untuk garis lurus.

Pada perintah di atas hanya ada satu set data yang diperoleh
dari satu baris dalam file data. Untuk memperoleh seluruh set data
hasil pengukuran, maka perintah dijalankan dalam sebuah loop for
seperti yang telah disinggung di depan. Supaya nilai-nilai data dapat
diolah satu persatu, maka tiap set data, untuk x, y dan e disimpan

36
dalam variabel list. Isi dari varibel list, yaitu elemen di dalamnya
dapat ditambah, dengan perintah
nama_variabel_list.append(data_baru). Jadi, pertama buat
variabel list yang kosong, kemudian tiap iterasi ditambah dengan set
data baru yang dibaca dari file data.

>>> datax=[];datay=[];datae=[]
>>> filedata = open('data.txt','r')
>>> for baris in filedata:
datanya = baris.split()
x = float(datanya[0])
datax.append(x)
y = float(datanya[1])
datay.append(y)
e = float(datanya[2])
datae.append(e)

>>> datax
[200.0, 300.0, 400.0, 500.0, 600.0, 700.0, 800.0,
900.0]
>>> datay
[5.1, 5.5, 5.9, 6.8, 7.4, 7.5, 8.6, 9.4]
>>> datae
[0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2]
>>>

Pasangan data x, y dan e masing-masing sudah tersimpan dalam

variabel list. Titik-titik data (x,y) dapat digambarkan dengan modul
matplotlib.

>>> import matplotlib.pyplot as plt

>>> plt.plot(datax, datay, 'ko')
[<matplotlib.lines.Line2D object at 0x022D0970>]
>>>

Jika setelah perintah import muncul peringatan kesalahan,

berarti modul matplotlib belum terinstall, maka harus diinstall lebih
dulu. Parameter 'ko' pada perintah plot adalah untuk
menggambarkan titik data berbentuk lingkaran dengan warna hitam
(black = 'k'). Setelah perintah plot, gambar belum ditampilkan,
hanya diberikan lokasi memori tempat plot itu disimpan. Untuk
menampilkan gambar diberikan perintah :

>>> plt.show()

37
 Gambar 3.1 Plot titik-titik data

Gambar 3.1 menampilkan hasil plot. Untuk kembali ke jendela

IDLE, tampilan (jendela) Figure 1 harus ditutup. File yang sedang
dibuka harus ditutup setelah selesai digunakan.

>>> filedata
<open file 'data.txt', mode 'r' at 0x00CA7E38>
>>> filedata.close()
>>> filedata
<closed file 'data.txt', mode 'r' at 0x00CA7E38>
>>>

4.3 Fungsi untuk membuka file, membaca, mengolah dan

memplot data
Untuk keperluan pemrograman, proses membuka file, mambaca
data, mengolah data, menampilkan, memplot data dan menutup file
disatukan dalam sebuah fungsi. Sebuah fungsi memerlukan satu atau
lebih parameter masukan, dan akan menghasilkan satu atau beberapa
variabel. Pada fungsi yang akan dibuat, parameter masukan adalah
nama file data, sedangkan variabel keluaran adalah : datax, datay,
datae, dengan di dalamnya disisipkan perintah untuk menampilkan
(print), dan memplot data. Fungsi dibuat pada jendela editor IDLE
yang baru (pada menu IDLE : FileNew Window).

import matplotlib.pyplot as plt

38
 def bacafiledata(datafile):
filedata = open(datafile,'r')
datax = []; datay = []; datae = []; i = 0
for baris in filedata:
i +=1
datanya = baris.split()
x = float(datanya[0])
datax.append(x)
y = float(datanya[1])
datay.append(y)
e = float(datanya[2])
datae.append(e)
print 'x = %5.2f y = %5.2f e = %5.2f' % (x, y,
e)

filedata.close()
jumlahdata = i
print 'Jumlah data = ', jumlahdata
plt.grid(True)
plt.plot(datax, datay, 'ko')
plt.errorbar(datax, datay, xerr=None, yerr=datae,
fmt = ' ')
plt.show()
return jumlahdata, datax, datay, datae

jumlahdata, datax, datay, datae =

bacafiledata('data.txt')

Program di atas disimpan dengan nama bacafile.py dalam

folder yang sama dengan file data.txt.

Perintah baris terakhir adalah menjalankan fungsi

bacafiledata dengan paramater masukan 'data.txt' dan variabel
keluaran jumlahdata, datax, datay, dan datae. Selain
menghasilkan variabel-variabel tersebut, juga menampilkan plot data
dengan batang ralatnya.

39
 Gambar 3.2 Plot titik data dengan batang ralat

Perintah memplot data juga dapat (sebaiknya) dibuat dalam satu

fungsi yang terpisah, dengan parameter masukan : datax, datay
dan datae, tanpa variabel keluaran.

def gambar(x, y, e):

plt.grid(True)
plt.plot(x, y, 'ko')
plt.errorbar(x, y, xerr=None, yerr=e, fmt = ' ')
plt.show()

dan perintah bagian akhir dari program bacafile.py diubah

menjadi :

jumlahdata, datax, datay, datae =

bacafiledata('data.txt')
gambar(datax, datay, datae)

Variabel-variabel keluaran jumlahdata, datax, datay dan

datae akan digunakan dalam perhitungan regresi linear.

40
4.4 Fungsi untuk regresi linear
Fungsi regresi linear yang akan dibuat memerlukan parameter
masukan berupa data-data nilai x, y dan e (simbol  pada persamaan 8
dan 9) dan variabel keluaran a, b, a, dan b.

Karena banyaknya proses penjumlahan, diperlukan variabel

untuk menampung penjumlahan itu, yang ditunjukkan pada Gambar
berikut.

Fungsi regresilinear :

def regresilinear(x, y, e):

sum1=0.0; sum2=0.0; sum3=0.0; sum4=0.0; sum5=0.0
for i in range(0, jumlahdata):
sum1=sum1+(x[i]**2/e[i]**2)
sum2=sum2+(y[i]/e[i]**2)
sum3=sum3+(x[i]/e[i]**2)
sum4=sum4+(x[i]*y[i])/e[i]**2
sum5=sum5+1/e[i]**2
#hitung determinan
det = (sum5*sum1)-sum3**2
#parameter a dan b
a = ((sum1*sum2)-(sum3*sum4))/det
b = ((sum5*sum4)-(sum3)*(sum2))/det
#ralat
sigmaa2 = sum1/det
sigmab2 = sum5/det
sigmaa = sqrt(sigmaa2)
sigmab = sqrt(sigmab2)

return a, b, sigmaa, sigmab

Pada fungsi di atas, diperlukan perhitungan akar pangkat dua

(sqrt), pada saat menghitung sigmaa dan sigmab. Fungsi sqrt ini
berada di dalam modul math yang harus diimport lebih dulu sebelum

41
digunakan. Modul math merupakan bawaan Python, sehingga tidak
perlu mencari dan mengunduhnya. Jadi pada baris setelah
mengimport matplotlib, dituliskan :

from math import sqrt

Untuk menguji fungsi regresilinear, ditambahkan perintah pada

baris akhir program bukafile.py (pada perintah gambar diberi tanda
komentar, karena tampilan gambar tidak diperlukan untuk saat ini).

jumlahdata, datax, datay, datae = bacafiledata('data.txt')

#gambar(datax, datay, datae)
a, b, sigmaa, sigmab = regresilinear(datax, datay, datae)
print 'a= %8.6f b= %8.6f sigmaa= %8.6f sigmab= %8.6f' % (a,
b, sigmaa, sigmab)

Hasil jalannya program :

x = 200.00 y = 5.10 e = 0.20

x = 300.00 y = 5.50 e = 0.20
x = 400.00 y = 5.90 e = 0.20
x = 500.00 y = 6.80 e = 0.20
x = 600.00 y = 7.40 e = 0.20
x = 700.00 y = 7.40 e = 0.20
x = 800.00 y = 8.60 e = 0.20
x = 900.00 y = 9.40 e = 0.20
Jumlah data = 8
a= 3.692857 b= 0.006036 sigmaa= 0.183874 sigmab=
0.000309

Jadi berhasil diperoleh parameter-parameter regresi linear

bersama dengan ketidakpastiannya masing-masing. Parameter-
parameter tersebut selanjutnya digunakan untuk menggambarkan
grafik hasil fit linear.

4.5 Plot data hasil regresi linear

Fungsi gambar yang telah dibuat hanya untuk menggambarkan
titik-titik data dengan ketidakpastiannya. Setelah diperoleh
parameter-parameter regresi linear, perlu digambarkan garis hasil fit,
yang dianggap sebagai garis terbaik yang melewati titik-titik data.
Oleh karena itu dibuat fungsi untuk menggambarkan grafik hasil fit.

Garis hasil fit tidak lain adalah garis linear dari persamaan (3.1).
Nilai x dipilih dinaikkan dari nilai x minimum (atau mulai dari 0 jika
menginginkan titik potong diperlihatkan) sampai maksimum dengan
interval kenaikan yang dapat dipilih. Kemudian pada tiap nilai itu

42
dihitung nilai y dengan persamaan (3.1) dengan parameter a dan b
hasil regresi linear.

Jadi ditentukan dulu range untuk x, diberi nama xfit :

xfit = np.arange(0, max(datax)+100, 1)

Pada perintah di atas digunakan modul numpy (Numerical

Python) untuk membuat suatu array mulai dari 0 sampai nilai data-x
maksimum dengan interval kenaikan 1. Untuk dapat menggunakan
modul numpy, harus diimport lebih dahulu.

import numpy as np

Kemudian dibuat fungsi plot hasil regresi linear :

def plotregresi(x, a, b):
for i in range(0, len(x)):
y = a + b*x
plt.plot(x,y)

Pada fungsi di atas memerlukan tiga parameter masukan, yaitu

x, a dan b, dan tanpa variabel keluaran. Fungsinya hanya untuk
menggambarkan garis. Titik-titik data juga ditampilkan dengan
menjalankan fungsi gambar(x,y,e). Karena perintah plt.show()
sudah dituliskan pada fungsi gambar(x,y,e), maka fungsi
plotregresi(x,a,b) dijalankan lebih dulu.

xfit = np.arange(0, max(datax)+100, 1)

plotregresi(xfit, a, b)
gambar(datax, datay, datae)

Hasil jalannya program :

43
 Gambar 3.3 Garis hasil fit linear

Langkah berikutnya adalah menggambarkan ketidakpastian

garis, berupa dua garis dengan gradien maksimum dan minimum.
Nilai gradien maksimum diperoleh dari b + b dan gradien minimum
diperoleh dari b − b. Untuk garis dengan gradien maksimum, titik
potongnya minimum, a − a , sedangkan untuk garis dengan gradien
minimum, titik potongnya maksimum, a + a. Jadi persamaan untuk
garis maksimum adalah

y( x )   a  σ a   b  σb  x

dan persamaan garis minimum :

y( x )  ( a  σ a )  b  σb  x

yang dituliskan dalam sebuah fungsi :

def fitploterror(x,a,b):
for i in range(0, len(x)):
y = a + b*x
plt.plot(x,y,'g',linestyle='--')

44
 hampir sama dengan fungsi plotregresi, namun dengan warna
yang beda, green = 'g', dan dengan format garis berupa garis
putus-putus. Parameter masukan juga sama, yaitu x, a, dan b. Untuk
membuat garis yang berbeda, tinggal mengganti a dan b dengan nilai
yang sesuai. Perintahnya adalah :
xfit = np.arange(0, max(datax)+100, 1)
plotregresi(xfit, a, b)
fitploterror(xfit,a-sigmaa,b+sigmab)
fitploterror(xfit,a+sigmaa,b-sigmab)
gambar(datax, datay, datae)

Hasil program :

Gambar 3.4 Garis bantu (ketidakpastian)

4.6 Goodnes-of-fit, chi-kuadrat

Nilai 2 dihitung dengan persamaan (3.7), dan chi-kuadrat
tereduksi dengan persamaan (3.11) yang dituliskan dalam sebuah
fungsi dengan parameter masukan data-data pengukuran xi, yi, ei, a
dan b, dan variabel keluaran 2 (chi2).

def chikuadrat(x, y, e, a, b):

chi2 = 0
for i in range(0, jumlahdata):
chi2 +=((y[i]-a-b*x[i])/e[i])**2
chi2tereduksi = chi2/(len(x)-2)
return chi2tereduksi

45
 Perintah untuk menjalankan fungsi chikuadrat(x,y,e,a,b) :

chi_kuadrat = chikuadrat(datax, datay, datae, a, b)

print 'chi kuadrat = %.2f' % (chi_kuadrat)

Hasil program :

chi kuadrat = 1.02

Diperoleh nilai chi-kuadrat tereduksi yang mendekati 1, berarti

ada kebolehjadian yang besar bahwa fungsi linear hasil fit cocok untuk
menggambarkan data-data eksperimen. Ulasan yang lengkap terdapat
dalam buku (Bevington, 1980).

4.7 Sedikit dekorasi

Tampilan pada Gambar 3.4 sudah memberikan apa yang
diinginkan, yaitu grafik hasil eksperimen dengan garis terbaik dan
dua garis ‘bantu’ (cara yang umum dilakukan di Laboratorium Fisika
Dasar). Dengan Gambar itu mahasiswa bisa terbantu untuk membuat
sendiri grafiknya dengan tangan (suatu kemampuan yang ‘diharuskan’
dimiliki oleh praktikan).

Namun Gambar tersebut masih kurang lengkap. Belum ada label

untuk sumbu-sumbu, belum ada judul, dan legend. Skala pada sumbu
juga masih otomatis. Beberapa langkah berikut ini menambahkan
label pada tiap sumbu, menambahkan judul dan menambahkan
legenda.
def gambar(x, y, e):
plt.grid(True)
plt.title('Grafik massa beban vs pertambahan panjang pegas')
plt.xlabel('massa beban (gram)')
plt.ylabel('pertambahan panjang (cm)')
plt.legend(loc='upper left')
plt.plot(x, y, 'ko')
plt.errorbar(x, y, xerr=None, yerr=e, fmt = ' ')
plt.show()

Hasil program :

46
 Gambar 3.5 Tampilan grafik dengan label dan judul

4.8 Interaktif
Gambar terakhir yang dihasilkan oleh program sudah lengkap
dengan label pada sumbu, judul grafik dan legenda. Demikian juga,
file data yang dibuka dan digambarkan hanya file yang sama, yaitu
‘data.txt’. Supaya fleksibel, ada interaksi dengan pengguna, maka
nama file, label pada sumbu dan judul grafik diisikan oleh pengguna.

Masukan dari pengguna ditampung dalam sebuah fungsi, yang

diberi nama inisialisasi :

def inisialisasi():
namafile = raw_input('File yang akan dibaca? ')
sumbux = raw_input('Nama sumbu X ? ')
sumbuy = raw_input('Nama sumbu Y ? ')
judul = raw_input('Judul grafik ? ')
return namafile, sumbux, sumbuy, judul

Fungsi di atas tidak memerlukan argumen, atau parameter

masukan, namun menghasilkan 4 variabel string. Jika dijalankan,
hasil programnya ditunjukkan berikut ini.

47
 Gambar 3.6 Tampilan Python Shell (IDLE) saat menjalankan (run)
program bacafile.py
Ada dua tampilan hasil program, yaitu tampilan interaksi dengan
user, angka-angka data dan hasil-hasil perhitungan regresi linear, dan
tampilan grafiknya pada jendela matplotlib.

Grafik yang ditampilkan pada jendela matplotlib dapat disimpan

ke dalam file gambar dengan mengklik ikon disket. Bisa juga langsung
didimpan dengan baris perintah : plt.saveimage(namafile), namun
karena kita ingin memilih grafik tertentu yang ingin disimpan, maka
lebih baik menyimpannya melalui jendela matplotlib.

48
 Gambar 3.7 Tampilan grafik

5 Penutup
Sampai dengan hasil program yang terakhir, dapat dikatakan
bahwa telah berhasil dibuat program analisis data eksperimen
(Praktikum Fisika Dasar) menggunakan bahasa pemrograman
Python. Apa yang telah dibuat ini masih bagian yang sangat kecil dari
kemampuan bahasa Python. Namun, bagi penulis merupakan langkah
awal untuk mempelajari Python, dan menggunakannya dalam skala
yang lebih besar, khususnya menyelesaikan program S3.

49
6. Referensi/Daftar bacaan
Bevington, Philip R., and D. Keith Robinson, 1980, Data Reduction and
Error Analysis for the Physical Sciences, third edition, Mc-Graw
Hill Companies, Inc, New York

Langtangen, Hans P., 2009, A Primer on Scientific Programming With

Python, Springer-Verlag, Berlin

50
7 Lampiran (source kode)
#=================================================================
import matplotlib.pyplot as plt
from math import sqrt
import numpy as np

def inisialisasi():
namafile = raw_input('File yang akan dibaca? ')
sumbux = raw_input('Nama sumbu X ? ')
sumbuy = raw_input('Nama sumbu Y ? ')
judul = raw_input('Judul grafik ? ')
return namafile, sumbux, sumbuy, judul

def bacafiledata(datafile):
filedata = open(datafile,'r')
datax = []; datay = []; datae = []; i = 0
for baris in filedata:
i +=1
datanya = baris.split()
x = float(datanya[0])
datax.append(x)
y = float(datanya[1])
datay.append(y)
e = float(datanya[2])
datae.append(e)
print 'x = %5.2f y = %5.2f e = %5.2f' % (x, y, e)

filedata.close()
jumlahdata = i
print 'Jumlah data = ', jumlahdata
return jumlahdata, datax, datay, datae

def gambar(x, y, e):

plt.grid(True)
plt.title(judul)
plt.xlabel(sumbux)
plt.ylabel(sumbuy)
plt.legend(loc='upper left')
plt.plot(x, y, 'ko')
plt.errorbar(x, y, xerr=None, yerr=e, fmt = ' ')
plt.show()

def regresilinear(x, y, e):

sum1=0.0; sum2=0.0; sum3=0.0; sum4=0.0; sum5=0.0
for i in range(0, jumlahdata):
sum1=sum1+(x[i]**2/e[i]**2)
sum2=sum2+(y[i]/e[i]**2)
sum3=sum3+(x[i]/e[i]**2)
sum4=sum4+(x[i]*y[i])/e[i]**2
sum5=sum5+1/e[i]**2
#hitung determinan
det = (sum5*sum1)-sum3**2
#parameter a dan b
a = ((sum1*sum2)-(sum3*sum4))/det
b = ((sum5*sum4)-(sum3)*(sum2))/det

51
 sigmaa2 = sum1/det
sigmab2 = sum5/det
sigmaa = sqrt(sigmaa2)
sigmab = sqrt(sigmab2)

return a, b, sigmaa, sigmab

def plotregresi(x, a, b):

for i in range(0, len(x)):
y = a + b*x
plt.plot(x,y, label='Hasil fit')

def fitploterror(x,a,b):
for i in range(0, len(x)):
y = a + b*x
plt.plot(x,y,'g',linestyle='--')

def chikuadrat(x, y, e, a, b):

chi2 = 0
for i in range(0, jumlahdata):
chi2 +=((y[i]-a-b*x[i])/e[i])**2
chi2tereduksi = chi2/(len(x)-2)
return chi2tereduksi

def korelasi(x, y):

sum1 = 0; sum2 = 0; sum3 = 0; sum4 = 0; sum5 = 0
for i in range(0, len(x)):
sum1 += x[i]*y[i]
sum2 += x[i]
sum3 += y[i]
sum4 += x[i]**2
sum5 += y[i]**2
r1 = len(x)*sum1 - sum2*sum3
r2 = sqrt((len(x)*sum4 - sum2**2)*(len(x)*sum5 - sum3**2))
r = r1/r2
return r

namafile, sumbux, sumbuy, judul = inisialisasi()

jumlahdata, datax, datay, datae = bacafiledata(namafile)

r = korelasi(datax, datay)
print 'Koefisien korelasi = %.2f' % (r)

a, b, sigmaa, sigmab = regresilinear(datax, datay, datae)

print 'a= %8.6f b= %8.6f sigmaa= %8.6f sigmab= %8.6f' % (a, b,
sigmaa, sigmab)
chi_kuadrat = chikuadrat(datax, datay, datae, a, b)
print 'chi kuadrat = %.2f' % (chi_kuadrat)

xfit = np.arange(0, max(datax)+1, 1)

plotregresi(xfit, a, b)
fitploterror(xfit,a-sigmaa,b+sigmab)
fitploterror(xfit,a+sigmaa,b-sigmab)
gambar(datax, datay, datae)
#=================================================================

52

View publication stats