STMKGxHMGI Long Course
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 $\pi$ (variabel) adalah 3,14. Saat mengingat atau memanggil $\pi$ 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:
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:
pi
3.14
Variabel dalam Python sendiri dibedakan menjadi beberapa jenis seperti:
Integer
: bilangan bulatFloat
: floating point, bilangan dengan desimalString
: teksComplex numbers
: bilangan kompleksBoolean
: benar (True
) atau salah (False
)Python akan menginterpretasikan jenis variabel dari cara kita menulis variabel tersebut:
angka=1 #integer
Angka=1.0 #float
ANGKA="1" #string
ANGKA2='1' #string
bil_kompleks=5-1j #complex
bools=True #boolean
Sama seperti ingatan manusia, jika suatu menyimpan ke memori dengan kata kunci yang sama maka nilai sebelumnya akan dilupakan, contoh:
angka=2
angka
2
Saat kita panggil angka
maka 2
yang akan muncul, bagaimana kalau nilai angka
kita ganti:
angka=3
angka
3
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:
angka1=3
angka2=5
angka3=angka1+angka2
print(angka3)
8
angka4=angka1-angka3
print(angka4)
-5
angka5=angka1**angka2
print(angka5)
243
Jenis variabel yang dioperasikan akan berpengaruh terhadap hasil operasinya, misalkan operasi perkalian antar integer
:
10*10
100
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
:
10*10.0
100.0
Bagaimana dengan operasi string
?
"1"+"3"
'13'
"13"-"3"
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) /tmp/ipykernel_4387/2527148311.py 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:
"1"*"3"
string
bisa dikalikan dengan integer
, hasil perkalian ini berupa penumpukan string sebanyak angka yang dikalikan:
"1"*3
operasi dengan float
akan menghasilkan error:
"1"*3.
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
List
ditulis dalam Python dengan []
yang bisa diisi berbagai macam variable yang sama ataupun berbeda dan masing-masing variabel tersebut dipisahkan dengan tanda koma (,
):
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]
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:
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:
pengukuran_terakhir=suhu_24h[-1]
print(pengukuran_terakhir)
29.0
Dengan index
kita juga bisa mengambil lebih dari 1 elemen dengan tambahan simbol :
:
pengukuran_1dan2=suhu_24h[0:2]
print(pengukuran_1dan2)
[34.0, 35.0]
Element dalam list
dapat diganti/mutable seperti pada contoh dibawah ini:
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
:
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) | Sort the list in ascending order and return None. | | The sort is in-place (i.e. the list itself is modified) and stable (i.e. the | order of two equal elements is maintained). | | If a key function is given, apply it once to each list item and sort them, | ascending or descending, according to their function values. | | The reverse flag can be set to sort in descending order. | | ---------------------------------------------------------------------- | Class methods defined here: | | __class_getitem__(...) from builtins.type | See PEP 585 | | ---------------------------------------------------------------------- | 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
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:
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 dihapus [37.0, 35.0, 34.3, 32.0, 31.1]
Tuple
sangat mirip dengan List
hanya saja Tuple
merupakan sequence yang elemennya tidak bisa diganti (immutable). Penulisan Tuple
dalam Python menggunakan tanda ()
:
suhu_24h_lock=(37.0, 35.0, 34.3, 32.0, 31.1, 29.0)
Pemanggilan element sama dengan list
yaitu menggunakan index
:
pengukuran_1=suhu_24h_lock[0]
print(pengukuran_1)
37.0
Jika kita coba mengedit element dalam tuple
maka akan muncul error:
suhu_24h_lock[0]=29.0
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) /tmp/ipykernel_4387/2770928713.py in <module> ----> 1 suhu_24h_lock[0]=29.0 TypeError: 'tuple' object does not support item assignment
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:
Sayur={"seledri", "tomat", "bayam"}
Sayur
{'bayam', 'seledri', 'tomat'}
elemen sets
harus unik dan tidak ada yang duplikat:
Sayur={"seledri", "tomat", "bayam", "tomat"}
Sayur
{'bayam', 'seledri', 'tomat'}
Walaupun bersifat immutable tapi sets
dapat ditambah elemennya:
Sayur.add("kol")
Sayur
{'bayam', 'kol', 'seledri', 'tomat'}
sets
juga dapat dioperasikan dengan sets
yang lain:
Buah={"tomat","apel","jeruk"}
Buah
{'apel', 'jeruk', 'tomat'}
dalam contoh pertama kita akan melihat elemen dari dua sets
yang sama dengan method intersection
:
Sayur.intersection(Buah)
{'tomat'}
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?
Sayur.difference(Buah)
{'bayam', 'kol', 'seledri'}
Sayur.union(Buah)
{'apel', 'bayam', 'jeruk', 'kol', 'seledri', 'tomat'}
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:
pengukuran_suhu={"waktu_menit":[10,20,30], "suhu":[29,30,27]}
print(pengukuran_suhu)
{'waktu_menit': [10, 20, 30], 'suhu': [29, 30, 27]}
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
:
waktu_pengukuran=pengukuran_suhu['waktu_menit']
waktu_pengukuran
[10, 20, 30]
Dengan memanggil waktu_pengukuran
kita mendapatkan isi dari key
tersebut yang berupa list
, seperti yang kita definisikan di atas.
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
:
waktu_menit=70
if waktu_menit > 60:
print("pengukuran lebih dari 1 jam")
pengukuran lebih dari 1 jam
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:
waktu_menit=10
if waktu_menit > 60:
print("pengukuran lebih dari 1 jam")
Kita bisa menambah percabangan lagi dengan else
apabila waktu_menit
tidak lebih besar dari 60:
waktu_menit=10
if waktu_menit > 60:
print("pengukuran lebih dari 1 jam")
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:
waktu_menit=60
if waktu_menit > 60:
print("pengukuran lebih dari 1 jam")
elif waktu_menit == 60:
print("pengukuran tepat 1 jam")
else:
print("pengukuran kurang dari 1 jam")
pengukuran tepat 1 jam
Conditional
ini dapat bertingkat (nested
), contoh apabila pengukuran selesai setelah 120 menit atau 2 jam:
waktu_menit=130
timer_off=120
if waktu_menit > 60:
if waktu_menit < timer_off:
print("pengukuran lebih dari 1 jam")
else:
print("pengukuran selesai karena sudah 2 jam")
elif waktu_menit == 60:
print("pengukuran tepat 1 jam")
else:
print("pengukuran kurang dari 1 jam")
pengukuran selesai karena sudah 2 jam
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
:
for elemen in suhu_24h:
print("Suhu sekarang adalah:", elemen)
Suhu sekarang adalah: 37.0 Suhu sekarang adalah: 35.0 Suhu sekarang adalah: 34.3 Suhu sekarang adalah: 32.0 Suhu sekarang adalah: 31.1
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:
import time
for elemen in suhu_24h:
print("Suhu sekarang adalah:", elemen)
time.sleep(1)
Suhu sekarang adalah: 37.0 Suhu sekarang adalah: 35.0 Suhu sekarang adalah: 34.3 Suhu sekarang adalah: 32.0 Suhu sekarang adalah: 31.1
for elemen in suhu_24h:
suhu_kelvin=elemen+273
print("Suhu sekarang adalah:", suhu_kelvin)
time.sleep(1)
Suhu sekarang adalah: 310.0 Suhu sekarang adalah: 308.0 Suhu sekarang adalah: 307.3 Suhu sekarang adalah: 305.0 Suhu sekarang adalah: 304.1
Sama seperti pada conditional
, loop
juga dapat kita buat bertingkat (nested), contoh apabila ingin mencetak waktu dengan perulangan jam dan menit:
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 Pukul: 1 lebih: 10 menit Pukul: 1 lebih: 20 menit Pukul: 1 lebih: 30 menit Pukul: 1 lebih: 40 menit Pukul: 1 lebih: 50 menit Pukul: 2 lebih: 0 menit Pukul: 2 lebih: 10 menit Pukul: 2 lebih: 20 menit Pukul: 2 lebih: 30 menit Pukul: 2 lebih: 40 menit Pukul: 2 lebih: 50 menit Pukul: 3 lebih: 0 menit Pukul: 3 lebih: 10 menit Pukul: 3 lebih: 20 menit Pukul: 3 lebih: 30 menit Pukul: 3 lebih: 40 menit Pukul: 3 lebih: 50 menit
Sebelum melangkah ke penjelasan fungsi kita akan coba mengonversi pengukuran suhu kita dari celcius ke dalam derajat Fahrenheit dengan rumus:
$$T_F=(\frac{9}{5} *T_c)+32$$dengan pengetahuan kita tentang operasi kita bisa menerapkannya dalam Python:
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:
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
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:
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:
suhu_celcius=10
suhu_fahrenheit=celcius_to_fahrenheit(suhu_celcius)
print(suhu_fahrenheit)
50.0
celcius_to_fahrenheit(15)
59.0
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
):
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
:
celcius_to_fahrenheit?
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
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
:
import utilities.temperature_conversion as temperature_conversion
Selanjutnya kita bisa mencoba memanggil fungsi celcius_to_fahrenheit
:
temperature_conversion.celcius_to_fahrenheit(10)
50.0
Modul temperature_conversion
bisa kita perkaya lagi misalkan kita tambah fungsi untuk mengonversi sebaliknya yaitu dari suhu derajat Celcius ke derajat Fahrenheit:
def fahrenheit_to_celcius(suhu_celcius):
"""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
:
from importlib import reload
reload(temperature_conversion)
<module 'utilities.temperature_conversion' from '/media/anangsahroni/localdiskD/job/hmgi_course/material/utilities/temperature_conversion.py'>
Selanjutnya kita bisa mencoba fungsi yang baru saja ditambahkan:
temperature_conversion.fahrenheit_to_celcius(50)
10.0
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
:
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. The result is between 0 and pi. acosh(x, /) Return the inverse hyperbolic cosine of x. asin(x, /) Return the arc sine (measured in radians) of x. The result is between -pi/2 and pi/2. asinh(x, /) Return the inverse hyperbolic sine of x. atan(x, /) Return the arc tangent (measured in radians) of x. The result is between -pi/2 and pi/2. 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. comb(n, k, /) Number of ways to choose k items from n items without repetition and without order. Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates to zero when k > n. Also called the binomial coefficient because it is equivalent to the coefficient of k-th term in polynomial expansion of the expression (1 + x)**n. Raises TypeError if either of the arguments are not integers. Raises ValueError if either of the arguments are negative. 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. dist(p, q, /) Return the Euclidean distance between two points p and q. The points should be specified as sequences (or iterables) of coordinates. Both inputs must have the same dimension. Roughly equivalent to: sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q))) 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 evaluation 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(*integers) Greatest Common Divisor. hypot(...) hypot(*coordinates) -> value Multidimensional Euclidean distance from the origin to a point. Roughly equivalent to: sqrt(sum(x**2 for x in coordinates)) For a two dimensional point (x, y), gives the hypotenuse using the Pythagorean theorem: sqrt(x*x + y*y). For example, the hypotenuse of a 3/4/5 right triangle is: >>> hypot(3.0, 4.0) 5.0 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. isqrt(n, /) Return the integer part of the square root of the input. lcm(*integers) Least Common Multiple. 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. nextafter(x, y, /) Return the next floating-point value after x towards y. perm(n, k=None, /) Number of ways to choose k items from n items without repetition and with order. Evaluates to n! / (n - k)! when k <= n and evaluates to zero when k > n. If k is not specified or is None, then k defaults to n and the function returns n!. Raises TypeError if either of the arguments are not integers. Raises ValueError if either of the arguments are negative. pow(x, y, /) Return x**y (x to the power of y). prod(iterable, /, *, start=1) Calculate the product of all the elements in the input iterable. The default start value for the product is 1. When the iterable is empty, return the start value. This function is intended specifically for use with numeric values and may reject non-numeric types. 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. ulp(x, /) Return the value of the least significant bit of the float x. DATA e = 2.718281828459045 inf = inf nan = nan pi = 3.141592653589793 tau = 6.283185307179586 FILE (built-in)
math.pi
3.141592653589793
Modul dapat diberikan nama alias, misalkan kita ganti math
dengan matematika
:
import math as matematika
matematika.pi
3.141592653589793
matematika.log10(1000)
3.0
Jika sebelumnya kita langsung mengimpor modul, pada contoh dibawah kita hanya mengimpor fungsi-fungsi yang kita butuhkan saja:
from math import radians, sin, cos, tan
sudut=60
sudut_radian=radians(sudut)
sin_sudut=sin(sudut_radian)
print(sin_sudut)
0.8660254037844386
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 Anaconda/Miniconda kita dapat menginstall modul dengan perintah standar di dalam Anaconda Prompt:
conda install [nama modul]
seperti:
conda install numpy
Beberapa modul perlu parameter lain seperti lokasi kanal pengunduhan (-c
), seperti saat teman-teman menginstall Jupyter Notebook ini kemarin melalui kanal conda-forge
:
conda install -c conda-forge notebook
Contoh penggunaan modul Numpy dan Matplotlib untuk mengolah data array dan mengeplot:
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, 130, 140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310, 320, 330, 340, 350])
sudut_radian=np.radians(sudut)
sudut_radian
array([0. , 0.17453293, 0.34906585, 0.52359878, 0.6981317 , 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])
sinus=np.sin(sudut_radian)
sinus
array([ 0.00000000e+00, 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, 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])
import matplotlib.pyplot as plt
plt.plot(sudut, sinus)
[<matplotlib.lines.Line2D at 0x7fcc62532220>]