1 Pengenalan Bahasa Pemograman Python

12/12/22, 4:35 PM 1_Pengenalan_Bahasa_Pemograman_Python
</div>
Tim penyusun modul Dasar-dasar Python:
Dr. rer.nat. Wiwit Suryanto, M.Si.

Dr. T. Marwan Irnaka, M.Sc.
Prima Wira K.W., M.Sc., S.Si.
Anang Sahroni, S.Si.
Fittra Irwandhono, S.Si.
Iqbal Asyadad, S.Si.
Tujuan:
Memperkenalkan dasar pemrograman Python
Keluaran:
Peserta dapat menjalankan Python dan memahami penggunaannya
Waktu/Tempat:
Jumat, 19 November 2021 / JCB Online Full Day Course
In [ ]: from google.colab import drive

drive.mount('/content/drive')
Drive already mounted at /content/drive; to attempt to forcibly remount, call driv

e.mount("/content/drive", force_remount=True).
Workshop ini akan menggunakan bahasa pemrograman Python untuk

mengimplementasikan pengolahan ANT dari data seismik sampai mendapatkan kurva
dispersi. Karena tidak dilakukan di perangkat lunak siap pakai, implementasi akan dilakukan
from scratch sehingga peserta diharapkan dapat dengan lebih detail mendapatkan
gambaran setiap prosesnya. Python dipilih sebagai bahasa pemrograman yang digunakan
karena tergolong paling mudah digunakan dan sudah didukung banyak library yang
dibutuhkan untuk pengolahan ANT. Sebelum spesifik ke implementasi ANT menggunakan
Python, kita akan terlebih dahulu mempelajari secara sekilas dasar bahasa pemrograman
Python:
file:///C:/Users/HP/Downloads/1_Pengenalan_Bahasa_Pemograman_Python.html 1/27
1 Variabel dan Operasi

1.1 Variabel
Variabel adalah suatu nilai yang kita simpan di memori dan bisa kita panggil saat akan
digunakan. Contoh kasus variabel adalah seperti saat kita menyimpan memori di otak kita
bahwa nilai π (variabel) adalah 3,14. Saat mengingat atau memanggil π di memori otak kita
maka akan muncul angka 3,14. Cara kerja komputer juga demikian sehingga Python sebagai
salah satu bahasa pemrograman juga bertindak seperti itu. Dalam implementasinya cara
'menyimpan ingatan' ini dilakukan dengan cara yang mudah:
In [ ]: pi=3.14
Pada contoh di atas kita menyimpan di ingatan komputer bahwa nilai pi adalah 3.14 ,
dengan begitu kita dapat memanggilnya dengan cara:
In [ ]: pi
3.14
Out[ ]:
Variabel dalam Python sendiri dibedakan menjadi beberapa jenis seperti:
Integer : bilangan bulat

Float : floating point, bilangan dengan desimal
String : teks
Complex numbers : bilangan kompleks
Boolean : benar ( True ) atau salah ( False )
Python akan menginterpretasikan jenis variabel dari cara kita menulis variabel tersebut:
In [ ]: angka=1 #integer

Angka=1.0 #float
ANGKA="1" #string
ANGKA2='1' #string
bil_kompleks=5-1j #complex
bools=True #boolean True atau False
In [ ]: angka
1
Out[ ]:
Sama seperti ingatan manusia, jika suatu menyimpan ke memori dengan kata kunci yang
sama maka nilai sebelumnya akan dilupakan, contoh:
In [ ]: angka=2
In [ ]: angka
2
Out[ ]:
Saat kita panggil angka maka 2 yang akan muncul, bagaimana kalau nilai angka kita
ganti:
In [ ]: angka=3
In [ ]: angka
3
Out[ ]:
1.2 Operasi
Jika kita sudah bisa menyimpan suatu nilai ke dalam ingatan komputer dengan
mendefinisikan suatu variable , selanjutnya kita akan mengoperasikan variabel-variabel
tersebut. Beberapa operasi standar yang dapat kita lakukan adalah:
Simbol Operasi Kegunaan
+ penjumlahan
- pengurangan
* perkalian
/ pembagian
% mengembalikan sisa pembagian (modulo).
** pangkat
+= menambah dan mengganti
-= mengurangkan dan mengganti
== mengetes kesamaan
!= mengetes ketidaksamaan
Contoh implementasi operasi-operasi di atas:
In [ ]: angka1=3
angka2=5
angka3=angka1+angka2
print(angka3)
In [ ]: angka4=angka1-angka3
print(angka4)
-5
In [ ]: angka5=angka1**angka2
print(angka5)
243
In [ ]: angka5 = 5
In [ ]: angka5
5
Out[ ]:
In [ ]: angka5 += 1
In [ ]: angka5
6
Out[ ]:
Jenis variabel yang dioperasikan akan berpengaruh terhadap hasil operasinya, misalkan
operasi perkalian antar integer :
In [ ]: 10*10
100
Out[ ]:
In [ ]: type(10*10)
int
Out[ ]:
Hasil operasi di atas berupa integer karena variabel yang dikalikan sama-sama
integer . Jika salah satu atau kedua data merupakan float maka hasil dari operasi akan
berjenis float :
In [ ]: 10*10.0
100.0
Out[ ]:
In [ ]: type(10*10.0)
float
Out[ ]:
Bagaimana dengan operasi string ?
In [ ]: "1"+"3"
'13'
Out[ ]:
In [ ]: "13"-"3"
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-28-eb9139d5589d> in <module>()
----> 1 "13"-"3"
TypeError: unsupported operand type(s) for -: 'str' and 'str'
Operasi penjumlahan pada string akan 'menumpuk' string tersebut sedangkan operasi
pengurangan tidak bisa dijalankan. Operasi perkalian antar string juga akan
menghasilkan error:
In [ ]: "1"*"3"
---------------------------------------------------------------------------
<ipython-input-29-4c9654e4aaf1> in <module>()
----> 1 "1"*"3"
TypeError: can't multiply sequence by non-int of type 'str'
string bisa dikalikan dengan integer , hasil perkalian ini berupa penumpukan string
sebanyak angka yang dikalikan:
In [ ]: "1"*10
'1111111111'
Out[ ]:
operasi dengan float akan menghasilkan error:
In [ ]: "1"*3.
---------------------------------------------------------------------------
<ipython-input-31-555329547ba0> in <module>()
----> 1 "1"*3.
TypeError: can't multiply sequence by non-int of type 'float'
In [ ]: "1"*int(3.)
'111'
Out[ ]:
Apa yang terjadi apabila kita merubah 3.4 menjadi integer int(3.4) --> 3 atau 4? int(3.6) -->
3 atau 4?
2 Struktur Data
Data dalam geofisika biasanya merupakan kumpulan nilai atau angka yang erat kaitannya
dengan pengukuran. Kita akan menggunakan studi kasus pengukuran suhu suatu ruangan
setiap 4 jam dalam satu hari, dengan kata lain kita akan memiliki 6 angka hasil pengukuran.
Bagaimana mewakili 6 angka tersebut dalam Python?
Python menyediakan beberapa jenis struktur data yang bisa digunakan untuk menyimpan
data kita yang masing-masing memiliki fungsinya sendiri. Beberapa jenis struktur data yang
umum di dalam Python adalah:
List
Tuple
Dictionary
Sets
2.1 List
List ditulis dalam Python dengan [] yang bisa diisi berbagai macam variable yang
sama ataupun berbeda dan masing-masing variabel tersebut dipisahkan dengan tanda
koma ( , ):
In [ ]: suhu_24h=[34.0, 35.0, 34.3, 32.0, 31.1, 29.0]

print(suhu_24h)
[34.0, 35.0, 34.3, 32.0, 31.1, 29.0]
In [ ]: type(suhu_24h)
list
Out[ ]:
In [ ]: suhu_x=[10, 35.0, "ini komponen list", 32.0, False, 29.0]
In [ ]: print(suhu_x)
[10, 35.0, 'ini komponen list', 32.0, False, 29.0]
In [ ]: suhu_24h*suhu_24h
---------------------------------------------------------------------------
<ipython-input-38-a2d785108e7e> in <module>()
----> 1 suhu_24h*suhu_24h
TypeError: can't multiply sequence by non-int of type 'list'
dalam kasus pengukuran suhu ruangan tersebut kita mendapatkan 6 angka pengukuran
yang kemudian dituangkan dalam list di Python seperti di atas. Setiap element list
berasosiasi dengan index yang dimulai dengan angka 0 pada element pertama dan
seterusnya. Contoh apabila kita ingin mengambil pengukuran ketiga maka index nya
adalah 2:
In [ ]: pengukuran_3=suhu_24h[2]
print(pengukuran_3)
34.3
Kita juga dapat memanggil dari belakang dengan index -1 untuk element terakhir, -2
untuk element kedua dari akhir, dan seterusnya, seperti contoh:
In [ ]: pengukuran_terakhir=suhu_24h[-1]
print(pengukuran_terakhir)
29.0
In [ ]: print(suhu_24h[2]==suhu_24h[-4])
True
Dengan index kita juga bisa mengambil lebih dari 1 elemen dengan tambahan simbol : :
In [ ]: pengukuran_1dan2=suhu_24h[0:2]
print(pengukuran_1dan2)
[34.0, 35.0]
Element dalam list dapat diganti/mutable seperti pada contoh dibawah ini:
In [ ]: print(suhu_24h[0])
34.0
In [ ]: suhu_24h[0]=37.0
print(suhu_24h)
[37.0, 35.0, 34.3, 32.0, 31.1, 29.0]
list memiliki banyak sekali method yang digunakan untuk mengolah list tersebut,
opsi-opsi atau method tersebut dapat kita lihat dengan mengetikkan help :
In [ ]: help(suhu_24h)
Help on list object:
class list(object)
| list(iterable=(), /)
|
| Built-in mutable sequence.
|
| If no argument is given, the constructor creates a new empty list.
| The argument must be an iterable if specified.
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(self, value, /)
| Return self>value.
|
| __iadd__(self, value, /)
| Implement self+=value.
|
| __imul__(self, value, /)
| Implement self*=value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(self, /)
| Return a reverse iterator over the list.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(self, /)
| Return the size of the list in memory, in bytes.
|
| append(self, object, /)
| Append object to the end of the list.
|
| clear(self, /)
| Remove all items from list.
|
| copy(self, /)
| Return a shallow copy of the list.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| extend(self, iterable, /)
| Extend list by appending elements from the iterable.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| insert(self, index, object, /)
| Insert object before index.
|
| pop(self, index=-1, /)
| Remove and return item at index (default last).
|
| Raises IndexError if list is empty or index is out of range.
|
| remove(self, value, /)
| Remove first occurrence of value.
|
| Raises ValueError if the value is not present.
|
| reverse(self, /)
| Reverse *IN PLACE*.
|
| sort(self, /, *, key=None, reverse=False)
| Stable sort *IN PLACE*.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
In [ ]: print(suhu_24h)
[37.0, 35.0, 34.3, 32.0, 31.1, 29.0]
In [ ]: suhu_24h.count(35.0)
1
Out[ ]:
In [ ]: suhu_24h[5] = 35.0

print(suhu_24h)
[37.0, 35.0, 34.3, 32.0, 31.1, 35.0]
In [ ]: suhu_24h.count(35.0)
2
Out[ ]:
Berdasarkan petunjuk di atas kita akan mencoba 1 method yaitu pop yang petunjuknya
adalah:
pop(self, index=-1, /)
| Remove and return item at index (default last).
berdasarkan petunjuk tersebut maka pop akan mengambil elemen list sekaligus
menghapusnya dari list kita:
In [ ]: print("list sebelum pop", suhu_24h)

elemen_terhapus=suhu_24h.pop()
print("elemen yang dihapus",elemen_terhapus)
print("list setelah pop", suhu_24h)
list sebelum pop [37.0, 35.0, 34.3, 32.0, 31.1, 29.0]

elemen yang dihapus 29.0
list setelah pop [37.0, 35.0, 34.3, 32.0, 31.1]
2.2 Tuple
Tuple sangat mirip dengan List hanya saja Tuple merupakan sequence yang
elemennya tidak bisa diganti (immutable). Penulisan Tuple dalam Python menggunakan
tanda () :
In [ ]: suhu_24h_lock=(37.0, 35.0, 34.3, 32.0, 31.1, 29.0)
Pemanggilan element sama dengan list yaitu menggunakan index :
In [ ]: pengukuran_1=suhu_24h_lock[0]
print(pengukuran_1)
37.0
Jika kita coba mengedit element dalam tuple maka akan muncul error:
In [ ]: suhu_24h_lock[0]=29.0
---------------------------------------------------------------------------
<ipython-input-57-78847fe7475d> in <module>()
----> 1 suhu_24h_lock[0]=29.0
TypeError: 'tuple' object does not support item assignment
2.3 Sets
Sets adalah data dalam bentuk koleksi unik yang tak berurutan dan sifatnya immutable
seperti tuple . Secara sederhana sets bisa kita artikan sebagai himpunan dalam bahasa
Indonesia. Kegunaannya juga mirip seperti himpunan:
In [ ]: Sayur={"seledri", "tomat", "bayam"}

Sayur
{'bayam', 'seledri', 'tomat'}

Out[ ]:
elemen sets harus unik dan tidak ada yang duplikat:
In [ ]: Sayur={"seledri", "tomat", "bayam", "tomat"}

Sayur
{'bayam', 'seledri', 'tomat'}

Out[ ]:
Walaupun bersifat immutable tapi sets dapat ditambah elemennya:
In [ ]: Sayur.add("kol")
Sayur
{'bayam', 'kol', 'seledri', 'tomat'}

Out[ ]:
sets juga dapat dioperasikan dengan sets yang lain:
In [ ]: Buah={"tomat","apel","jeruk"}
Buah
{'apel', 'jeruk', 'tomat'}

Out[ ]:
dalam contoh pertama kita akan melihat elemen dari dua sets yang sama dengan
method intersection :
In [ ]: Sayur.intersection(Buah)
{'tomat'}
Out[ ]:
Dari contoh di atas kita seperti mencari irisan dari dua buah himpunan yaitu Sayur dan
Buah, karena tomat masuk keduanya maka tomat adalah irisannya. Contoh selanjutnya
adalah dengan metode difference dan union kira-kira apa yang terjadi?
In [ ]: Sayur.difference(Buah)
{'bayam', 'seledri'}
Out[ ]:
In [ ]: Sayur.union(Buah)
{'apel', 'bayam', 'jeruk', 'seledri', 'tomat'}

Out[ ]:
2.4 Dictionary
Dictionary menyimpan data di dalam keys bersifat alfanumerik, keys bisa
dianalogikan sebagai sebuah judul kolom yang masing-masing kolom tersebut terdapat
data. Penulisan dictionary mirip dengan sets yaitu menggunakan {} . Dalam contoh
di bawah ini masih menggunakan studi kasus pengukuran suhu, dengan dictionary kita
dapat mendefinisikan data lain yaitu waktu pengukuran dalam menit:
In [ ]: pengukuran_suhu={"waktu_menit":[10,20,30], "suhu":[29,30,27], "operator":"Kaka"}

print(pengukuran_suhu)
{'waktu_menit': [10, 20, 30], 'suhu': [29, 30, 27], 'operator': 'Kaka'}
Jika dalam list dan dalam tuple kita bisa mengambil elemen dengan menggunakan
indeks, dalam dictionary kita menggunakan keys dari data yang akan kita ambil.
Apabila kita ingin mengambil data waktu pengukuran maka kita menggunakan keys
waktu_menit :
In [ ]: waktu_pengukuran=pengukuran_suhu['waktu_menit']
waktu_pengukuran
[10, 20, 30]

Out[ ]:
Dengan memanggil waktu_pengukuran kita mendapatkan isi dari key tersebut yang
berupa list , seperti yang kita definisikan di atas.
3 Conditional (Pembuatan Keputusan)

Pada pembuatan suatu aplikasi pasti akan sampai dalam sebuah titik dimana kita harus
mengambil keputusan dan harus memilih satu dari beberapa pilihan tergantung kondisi.
Dalam implementasinya kita akan mengenal if , elif , dan else :
In [ ]: waktu_menit=20
if waktu_menit > 60:

print("pengukuran lebih dari 1 jam")
print("operator: Kaka")
elif waktu_menit > 30:
print("pengukuran lebih dari 0.5 jam")
# else:
# print("pengukuran kurang dari 0.5 jam")
print("test")
test
Pada contoh di atas kita membuat variabel waktu_menit , apabila nilai dalam variabel
tersebut melebihi 60 menit ( if waktu_menit > 60 ) maka akan dicetak tulisan:
pengukuran lebih dari 1 jam . Jika waktu kurang dari 60 maka tidak akan terjadi apa-
apa:

Kita bisa menambah percabangan lagi dengan else apabila waktu_menit tidak lebih
besar dari 60:

else:
print("pengukuran kurang dari 1 jam")
pengukuran kurang dari 1 jam
Untuk percabangan yang lebih dari 2 maka kita perlu menggunakan elif atau else-if:

elif waktu_menit == 60:
print("pengukuran tepat 1 jam")
else:
pengukuran tepat 1 jam
Conditional ini dapat bertingkat ( nested ), contoh apabila pengukuran selesai setelah
120 menit atau 2 jam:
timer_off=120

if waktu_menit < timer_off:
else:
print("pengukuran selesai karena sudah 2 jam")
elif waktu_menit == 60:
print("pengukuran tepat 1 jam")
else:
pengukuran selesai karena sudah 2 jam
4 Loop (perulangan)
Loop digunakan untuk melakukan perulangan proses pada setiap elemen pada data
sequence seperti list dan tuple . Ada dua macam perulangan di Python yaitu for dan
while . Misalkan kita akan mencetak hasil pengukuran suhu dengan for :
In [ ]: suhu_24h
[37.0, 35.0, 34.3, 32.0, 31.1, 35.0]

Out[ ]:
In [ ]: for elemen in suhu_24h:

print("Suhu sekarang adalah:", elemen)
Suhu sekarang adalah: 37.0

Setiap elemen akan dari suhu_24h akan dicetak secara bergantian dan berurutan. Untuk
mempermudah intuisi kita bisa berikan delay 1 detik untuk setiap perintah print agar
terlihat bahwa fungsi print ini dilakukan satu per satu:
In [ ]: import time

for elemen in suhu_24h:
print("Suhu sekarang adalah:", elemen)
time.sleep(1)

In [ ]: for elemen in suhu_24h:

suhu_kelvin=elemen+273
print("Suhu sekarang adalah:", suhu_kelvin)
time.sleep(1)

Sama seperti pada conditional , loop juga dapat kita buat bertingkat (nested), contoh
apabila ingin mencetak waktu dengan perulangan jam dan menit:
In [ ]: menit=[0,10,20,30,40,50]
jam=[1,2,3]
for j in jam:
for m in menit:
print("Pukul: ",j,"lebih: ",m," menit")
Pukul: 1 lebih: 0 menit

5 Fungsi dan Modul

Sebelum melangkah ke penjelasan fungsi kita akan coba mengonversi pengukuran suhu kita
dari celcius ke dalam derajat Fahrenheit dengan rumus:
9
TF = ( ∗ Tc ) + 32
5
dengan pengetahuan kita tentang operasi kita bisa menerapkannya dalam Python:
In [ ]: suhu_pertama_c=suhu_24h[0]
suhu_pertama_F=(9/5*suhu_pertama_c)+32
print("Suhu pertama dalam C: ", suhu_pertama_c)

print("Suhu pertama dalam F: ", suhu_pertama_F)
Suhu pertama dalam C: 37.0

Suhu pertama dalam F: 98.60000000000001
Kita juga bisa melakukan hal yang sama pada pengukuran yang kedua:
In [ ]: suhu_kedua_c=suhu_24h[0]
suhu_kedua_F=(9/5*suhu_kedua_c)+32
print("Suhu kedua dalam C: ", suhu_kedua_c)

print("Suhu kedua dalam F: ", suhu_kedua_F)
Suhu kedua dalam C: 37.0

Suhu kedua dalam F: 98.60000000000001
5.1 Fungsi
Dalam konversi suhu seperti kasus di atas kita perlu menuliskan rumus lengkap dari konversi
setiap akan melakukannya. Hal seperti demikian tidak efektif, rawan terjadi error, dan susah
saat akan maintenance. Suatu operasi yang akan dilakukan berkali-kali dapat kita definisikan
sebagai sebuah fungsi agar bisa kita panggil:
In [ ]: def celcius_to_fahrenheit(suhu_celcius):

suhu_fahrenheit=(9/5*suhu_celcius)+32
return suhu_fahrenheit
Dalam kode di atas dapat kita lihat bahwa sebuah fungsi di awali dengan def diikuti nama
fungsi, nama fungsi kita adalah celcius_to_fahrenheit . Setelah nama fungsi diikuti
parameter dalam tanda kurung (suhu_celcius) ,i baris selanjutnya adalah body dari
fungsi tersebut. Di bagian akhir kita mengembalikan variabel yang menjadi hasil dari fungsi
kita.
Setelah mendefinisikan fungsi celcius_to_fahrenheit seperti di atas kita bisa

memanggilnya:
In [ ]: suhu_celcius=10
suhu_fahrenheit=celcius_to_fahrenheit(suhu_celcius)
print(suhu_fahrenheit)
50.0
In [ ]: celcius_to_fahrenheit(15)
59.0
Out[ ]:
Dalam penulisan sebuah fungsi disarankan kita memberikan petunjuk tentang bagaimana
cara menggunakan fungsi tersebut atau sering disebut sebagai docstring . Petunjuk ini
biasanya ditulis di bawah baris pendefinisian fungsi (yang di awali def ):
In [ ]: def celcius_to_fahrenheit(suhu_celcius):

"""Fungsi konversi suhu Celcius ke Fahrenheit
Argument:
suhu_celcius (float/int): Suhu dalam celcius yang akan dikonversi
Return:
suhu_fahrenheit (float): Hasil konversi berupa suhu dalam Fahrenheit
"""
suhu_fahrenheit=(9/5*suhu_celcius)+32
return suhu_fahrenheit
Petunjuk tersebut dapat kita akses dengan ? atau dengan fungsi help :
In [ ]: celcius_to_fahrenheit?
In [ ]: help(celcius_to_fahrenheit)
Help on function celcius_to_fahrenheit in module __main__:
celcius_to_fahrenheit(suhu_celcius)
Fungsi konversi suhu Celcius ke Fahrenheit
Argument:
suhu_celcius (float/int): Suhu dalam celcius yang akan dikonversi
Return:
suhu_fahrenheit (float): Hasil konversi berupa suhu dalam Fahrenheit
In [ ]: help(fft)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-82-07a23ae56da3> in <module>()
----> 1 help(fft)
NameError: name 'fft' is not defined
In [ ]: import numpy as np
In [ ]: help(np.fft.fft)
Help on function fft in module numpy.fft:
fft(a, n=None, axis=-1, norm=None)

Compute the one-dimensional discrete Fourier Transform.
This function computes the one-dimensional *n*-point discrete Fourier

Transform (DFT) with the efficient Fast Fourier Transform (FFT)
algorithm [CT].
Parameters
----------
a : array_like
Input array, can be complex.
n : int, optional
Length of the transformed axis of the output.
If `n` is smaller than the length of the input, the input is cropped.
If it is larger, the input is padded with zeros. If `n` is not given,
the length of the input along the axis specified by àxis` is used.
axis : int, optional
Axis over which to compute the FFT. If not given, the last axis is
used.
norm : {"backward", "ortho", "forward"}, optional
.. versionadded:: 1.10.0
Normalization mode (see `numpy.fft`). Default is "backward".

Indicates which direction of the forward/backward pair of transforms
is scaled and with what normalization factor.
.. versionadded:: 1.20.0
The "backward", "forward" values were added.
Returns
-------
out : complex ndarray
The truncated or zero-padded input, transformed along the axis
indicated by àxis`, or the last one if àxis` is not specified.
Raises
------
IndexError
If àxis` is not a valid axis of à`.
See Also
--------
numpy.fft : for definition of the DFT and conventions used.
ifft : The inverse of `fft`.
fft2 : The two-dimensional FFT.
fftn : The *n*-dimensional FFT.
rfftn : The *n*-dimensional FFT of real input.
fftfreq : Frequency bins for given FFT parameters.
Notes
-----
FFT (Fast Fourier Transform) refers to a way the discrete Fourier
Transform (DFT) can be calculated efficiently, by using symmetries in the
calculated terms. The symmetry is highest when `n` is a power of 2, and
the transform is therefore most efficient for these sizes.
The DFT is defined, with the conventions used in this implementation, in

the documentation for the `numpy.fft` module.
References
----------
.. [CT] Cooley, James W., and John W. Tukey, 1965, "An algorithm for the
machine calculation of complex Fourier series," *Math. Comput.*
19: 297-301.
Examples
--------
>>> np.fft.fft(np.exp(2j * np.pi * np.arange(8) / 8))
array([-2.33486982e-16+1.14423775e-17j, 8.00000000e+00-1.25557246e-15j,
2.33486982e-16+2.33486982e-16j, 0.00000000e+00+1.22464680e-16j,
-1.14423775e-17+2.33486982e-16j, 0.00000000e+00+5.20784380e-16j,
1.14423775e-17+1.14423775e-17j, 0.00000000e+00+1.22464680e-16j])
In this example, real input has an FFT which is Hermitian, i.e., symmetric
in the real part and anti-symmetric in the imaginary part, as described in
the `numpy.fft` documentation:
>>> import matplotlib.pyplot as plt

>>> t = np.arange(256)
>>> sp = np.fft.fft(np.sin(t))
>>> freq = np.fft.fftfreq(t.shape[-1])
>>> plt.plot(freq, sp.real, freq, sp.imag)
[<matplotlib.lines.Line2D object at 0x...>, <matplotlib.lines.Line2D object at
0x...>]
>>> plt.show()
5.2 Modul
Modul secara sederhananya adalah kumpulan dari fungsi-fungsi yang bisa kita panggil.
Fungsi celcius_to_fahrenheit di atas bisa kita masukkan ke dalam modul
temperature_conversion . Cara membuat modul adalah dengan membuat file dengan
ekstensi .py dengan diberi nama seperti nama modul kita. Jika modul akan kita namai
temperature_conversion maka nama file kita adalah temperature_conversion.py
dan akan kita simpan pada folder utilities , buat file __init__.py juga dalam folder
tersebut dengan isi kosong. Selanjutkan masukkan fungsi kita ke dalam modul tersebut:
Kita bisa panggil modul tersebut dengan perintah import :
In [ ]: import utilities.temperature_conversion as temperature_conversion
Selanjutnya kita bisa mencoba memanggil fungsi celcius_to_fahrenheit :
In [ ]: temperature_conversion.celcius_to_fahrenheit(10)
50.0
Out[ ]:
Modul temperature_conversion bisa kita perkaya lagi misalkan kita tambah fungsi
untuk mengonversi sebaliknya yaitu dari suhu derajat Celcius ke derajat Fahrenheit:
In [ ]: def fahrenheit_to_celcius(suhu_fahrenheit):

"""Fungsi konversi suhu Fahrenheit ke Celcius
Argument:
suhu_fahrenheit (float/int): Suhu dalam Fahrenheit yang akan dikonversi
Return:
suhu_celcius (float): Hasil konversi berupa suhu dalam Fahrenheit
"""
suhu_celcius=(suhu_fahrenheit-32)*5/9
return suhu_celcius
Modul sebelumnya sudah kita impor dengan import temperature_conversion , jika isi
modul tersebut berubah maka kita harus reload dengan memanfaatkan fungsi reload dari
modul imporlib :
In [ ]: from importlib import reload
reload(temperature_conversion)
<module 'utilities.temperature_conversion' from '/content/utilities/temperature_co

Out[ ]:
nversion.py'>
Selanjutnya kita bisa mencoba fungsi yang baru saja ditambahkan:
In [ ]: temperature_conversion.fahrenheit_to_celcius(50)
10.0
Out[ ]:
Modul Built-in (bawaan) Python

Python memiliki beberapa modul bawaan seperti math , cmath , os , atau secara lebih
lengkap: Built-in modules. Seperti modul buatan kita sendiri tadi, kita bisa panggil modul
bawaan Python dengan perintah import :
In [ ]: import math
help(math)
Help on built-in module math:
NAME
math
DESCRIPTION
This module provides access to the mathematical functions
defined by the C standard.
FUNCTIONS
acos(x, /)
Return the arc cosine (measured in radians) of x.
acosh(x, /)
Return the inverse hyperbolic cosine of x.
asin(x, /)
Return the arc sine (measured in radians) of x.
asinh(x, /)
Return the inverse hyperbolic sine of x.
atan(x, /)
Return the arc tangent (measured in radians) of x.
atan2(y, x, /)
Return the arc tangent (measured in radians) of y/x.
Unlike atan(y/x), the signs of both x and y are considered.
atanh(x, /)
Return the inverse hyperbolic tangent of x.
ceil(x, /)
Return the ceiling of x as an Integral.
This is the smallest integer >= x.
copysign(x, y, /)
Return a float with the magnitude (absolute value) of x but the sign of y.
On platforms that support signed zeros, copysign(1.0, -0.0)

returns -1.0.
cos(x, /)
Return the cosine of x (measured in radians).
cosh(x, /)
Return the hyperbolic cosine of x.
degrees(x, /)
Convert angle x from radians to degrees.
erf(x, /)
Error function at x.
erfc(x, /)
Complementary error function at x.
exp(x, /)
Return e raised to the power of x.
expm1(x, /)
Return exp(x)-1.
This function avoids the loss of precision involved in the direct evaluati
on of exp(x)-1 for small x.
fabs(x, /)
Return the absolute value of the float x.
factorial(x, /)
Find x!.
Raise a ValueError if x is negative or non-integral.
floor(x, /)
Return the floor of x as an Integral.
This is the largest integer <= x.
fmod(x, y, /)
Return fmod(x, y), according to platform C.
x % y may differ.
frexp(x, /)
Return the mantissa and exponent of x, as pair (m, e).
m is a float and e is an int, such that x = m * 2.**e.

If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.
fsum(seq, /)
Return an accurate floating point sum of values in the iterable seq.
Assumes IEEE-754 floating point arithmetic.
gamma(x, /)
Gamma function at x.
gcd(x, y, /)
greatest common divisor of x and y
hypot(x, y, /)
Return the Euclidean distance, sqrt(x*x + y*y).
isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

Determine whether two floating point numbers are close in value.
rel_tol
maximum difference for being considered "close", relative to the
magnitude of the input values
abs_tol
maximum difference for being considered "close", regardless of the
magnitude of the input values
Return True if a is close in value to b, and False otherwise.
For the values to be considered close, the difference between them

must be smaller than at least one of the tolerances.
-inf, inf and NaN behave similarly to the IEEE 754 Standard. That
is, NaN is not close to anything, even itself. inf and -inf are
only close to themselves.
isfinite(x, /)
Return True if x is neither an infinity nor a NaN, and False otherwise.
isinf(x, /)
Return True if x is a positive or negative infinity, and False otherwise.
isnan(x, /)
Return True if x is a NaN (not a number), and False otherwise.
ldexp(x, i, /)
Return x * (2**i).
This is essentially the inverse of frexp().
lgamma(x, /)
Natural logarithm of absolute value of Gamma function at x.
log(...)
log(x, [base=math.e])
Return the logarithm of x to the given base.
If the base not specified, returns the natural logarithm (base e) of x.
log10(x, /)
Return the base 10 logarithm of x.
log1p(x, /)
Return the natural logarithm of 1+x (base e).
The result is computed in a way which is accurate for x near zero.
log2(x, /)
Return the base 2 logarithm of x.
modf(x, /)
Return the fractional and integer parts of x.
Both results carry the sign of x and are floats.
pow(x, y, /)
Return x**y (x to the power of y).
radians(x, /)
Convert angle x from degrees to radians.
remainder(x, y, /)
Difference between x and the closest integer multiple of y.
Return x - n*y where n*y is the closest integer multiple of y.

In the case where x is exactly halfway between two multiples of
y, the nearest even value of n is used. The result is always exact.
sin(x, /)
Return the sine of x (measured in radians).
sinh(x, /)
Return the hyperbolic sine of x.
sqrt(x, /)
Return the square root of x.
tan(x, /)
Return the tangent of x (measured in radians).
tanh(x, /)
Return the hyperbolic tangent of x.
trunc(x, /)
Truncates the Real x to the nearest Integral toward 0.
Uses the __trunc__ magic method.
DATA
e = 2.718281828459045
inf = inf
nan = nan
pi = 3.141592653589793
tau = 6.283185307179586
FILE
(built-in)
In [ ]: math.pi
3.141592653589793
Out[ ]:
Modul dapat diberikan nama alias, misalkan kita ganti math dengan matematika :
In [ ]: import math as matematika
matematika.pi
3.141592653589793
Out[ ]:
In [ ]: matematika.log10(1000)
3.0
Out[ ]:
Jika sebelumnya kita langsung mengimpor modul, pada contoh dibawah kita hanya
mengimpor fungsi-fungsi yang kita butuhkan saja:
In [ ]: from math import radians, sin, cos, tan
sudut=60
sudut_radian=radians(sudut)
sin_sudut=sin(sudut_radian)
print(sin_sudut)
0.8660254037844386
Modul External
Modul eksternal adalah modul yang dikembangkan diluar pengembang asli Python. Modul
eksternal memiliki kegunaan yang spesifik dan berisi kumpulan fungsi-fungsi yang
mendukung kegunaan tersebut. Modul-modul eksternal umum yang akan sering kita
gunakan seperti numpy untuk data-data numerik, scipy untuk pengolahan data saintifik,
matplotlib untuk plotting data, dan pandas untuk pengelolaan data. Dalam bidang
yang lebih spesifik seperti pada seismologi kita mengenal modul obspy .
Modul eksternal dapat diinstall menggunakan bantuan package manager, jika kita
menggunakan Google Colab kita dapat menginstall modul dengan perintah standar di
dalam pip :
pip install [nama modul]
seperti:
pip install numpy
Contoh penggunaan modul Numpy dan Matplotlib untuk mengolah data array dan
mengeplot:
In [ ]: import numpy as np
sudut=np.arange(0,360,10)
sudut
array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120,
Out[ ]:
130, 140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250,
260, 270, 280, 290, 300, 310, 320, 330, 340, 350])
In [ ]: sudut_radian=np.radians(sudut)
sudut_radian
array([0. , 0.17453293, 0.34906585, 0.52359878, 0.6981317 ,

Out[ ]:
0.87266463, 1.04719755, 1.22173048, 1.3962634 , 1.57079633,
1.74532925, 1.91986218, 2.0943951 , 2.26892803, 2.44346095,
2.61799388, 2.7925268 , 2.96705973, 3.14159265, 3.31612558,
3.4906585 , 3.66519143, 3.83972435, 4.01425728, 4.1887902 ,
4.36332313, 4.53785606, 4.71238898, 4.88692191, 5.06145483,
5.23598776, 5.41052068, 5.58505361, 5.75958653, 5.93411946,
6.10865238])
In [ ]: sinus=np.sin(sudut_radian)
sinus
array([ 0.00000000e+00, 1.73648178e-01, 3.42020143e-01, 5.00000000e-01,

Out[ ]:
6.42787610e-01, 7.66044443e-01, 8.66025404e-01, 9.39692621e-01,
9.84807753e-01, 1.00000000e+00, 9.84807753e-01, 9.39692621e-01,
8.66025404e-01, 7.66044443e-01, 6.42787610e-01, 5.00000000e-01,
3.42020143e-01, 1.73648178e-01, 1.22464680e-16, -1.73648178e-01,
-3.42020143e-01, -5.00000000e-01, -6.42787610e-01, -7.66044443e-01,
-8.66025404e-01, -9.39692621e-01, -9.84807753e-01, -1.00000000e+00,
-9.84807753e-01, -9.39692621e-01, -8.66025404e-01, -7.66044443e-01,
-6.42787610e-01, -5.00000000e-01, -3.42020143e-01, -1.73648178e-01])
In [ ]: import matplotlib.pyplot as plt
plt.plot(sudut, sinus)
[<matplotlib.lines.Line2D at 0x7fb858597f50>]
Out[ ]:
Lisensi
License CC BY 4.0
Material ini di bawah lisensi Creative Commons Attribution 4.0 International License.
Referensi
Lisa Tauxe, ltauxe@ucsd.edu, Hanna Asefaw, hasefaw@ucs.dedu, & Brendan Cych,
bcych@ucsd.edu, Python Programming for Earth Science Students, Repository:
https://github.com/ltauxe/Python-for-Earth-Science-Students

1 Pengenalan Bahasa Pemograman Python

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

1 Pengenalan Bahasa Pemograman Python

Diunggah oleh

Hak Cipta:

Format Tersedia

12/12/22, 4:35 PM 1_Pengenalan_Bahasa_Pemograman_Python

Tim penyusun modul Dasar-dasar Python:

Dr. rer.nat. Wiwit Suryanto, M.Si.

Memperkenalkan dasar pemrograman Python

Peserta dapat menjalankan Python dan memahami penggunaannya

Jumat, 19 November 2021 / JCB Online Full Day Course

In [ ]: from google.colab import drive

Drive already mounted at /content/drive; to attempt to forcibly remount, call driv

Workshop ini akan menggunakan bahasa pemrograman Python untuk

1 Variabel dan Operasi

Variabel dalam Python sendiri dibedakan menjadi beberapa jenis seperti:

Integer : bilangan bulat

In [ ]: angka=1 #integer

Simbol Operasi Kegunaan

% mengembalikan sisa pembagian (modulo).

+= menambah dan mengganti

-= mengurangkan dan mengganti

Contoh implementasi operasi-operasi di atas:

Bagaimana dengan operasi string ?

TypeError: unsupported operand type(s) for -: 'str' and 'str'

TypeError: can't multiply sequence by non-int of type 'str'

operasi dengan float akan menghasilkan error:

TypeError: can't multiply sequence by non-int of type 'float'

In [ ]: suhu_24h=[34.0, 35.0, 34.3, 32.0, 31.1, 29.0]

[34.0, 35.0, 34.3, 32.0, 31.1, 29.0]

In [ ]: suhu_x=[10, 35.0, "ini komponen list", 32.0, False, 29.0]

[10, 35.0, 'ini komponen list', 32.0, False, 29.0]

TypeError: can't multiply sequence by non-int of type 'list'

[37.0, 35.0, 34.3, 32.0, 31.1, 29.0]

Help on list object:

[37.0, 35.0, 34.3, 32.0, 31.1, 29.0]

In [ ]: suhu_24h[5] = 35.0

[37.0, 35.0, 34.3, 32.0, 31.1, 35.0]

In [ ]: print("list sebelum pop", suhu_24h)

list sebelum pop [37.0, 35.0, 34.3, 32.0, 31.1, 29.0]

In [ ]: suhu_24h_lock=(37.0, 35.0, 34.3, 32.0, 31.1, 29.0)

Pemanggilan element sama dengan list yaitu menggunakan index :

TypeError: 'tuple' object does not support item assignment

In [ ]: Sayur={"seledri", "tomat", "bayam"}

{'bayam', 'seledri', 'tomat'}

elemen sets harus unik dan tidak ada yang duplikat:

In [ ]: Sayur={"seledri", "tomat", "bayam", "tomat"}

{'bayam', 'seledri', 'tomat'}

Walaupun bersifat immutable tapi sets dapat ditambah elemennya:

{'bayam', 'kol', 'seledri', 'tomat'}

sets juga dapat dioperasikan dengan sets yang lain:

{'apel', 'jeruk', 'tomat'}

{'apel', 'bayam', 'jeruk', 'seledri', 'tomat'}

In [ ]: pengukuran_suhu={"waktu_menit":[10,20,30], "suhu":[29,30,27], "operator":"Kaka"}

[10, 20, 30]

3 Conditional (Pembuatan Keputusan)

if waktu_menit > 60:

if waktu_menit > 60:

if waktu_menit > 60:

pengukuran kurang dari 1 jam

if waktu_menit > 60:

pengukuran tepat 1 jam

if waktu_menit > 60:

pengukuran selesai karena sudah 2 jam

[37.0, 35.0, 34.3, 32.0, 31.1, 35.0]

In [ ]: for elemen in suhu_24h:

Suhu sekarang adalah: 37.0

In [ ]: import time

Suhu sekarang adalah: 37.0

Help on function celcius_to_fahrenheit in module main:

This function computes the one-dimensional n-point discrete Fourier

Return x - ny where ny is the closest integer multiple of y.

Uses the trunc magic method.