STMKGxHMGI Long Course

Pre-Sesi: Instalasi Miniconda dan Modul-modul yang Dipakai

  • Tujuan: Memperkenalkan cara instalasi Miniconda serta menggunakannya untuk manajemen paket termasuk Jupyter Notebook
  • Keluaran: Peserta dapat menjalankan Python, Miniconda, dan Jupyter Notebook dan memahami penggunaannya
  • Sesi Persiapan
  • Waktu/Tempat: Jumat, 17 September 2021/ Mandiri

Instalasi Miniconda pada Windows

Python merupakan bahasa pemrograman yang akan kita pelajari, lantas mengapa kita harus menginstall Miniconda? Miniconda adalah versi ringan dari Anaconda yang dikembangkan oleh Anaconda Distribution. Miniconda (atau lebih umum disebut conda) merupakan perangkat lunak untuk manajemen paket-paket (packages) dalam Python. Apakah yang dimaksud paket (package) dalam Python? Mari kita install terlebih dahulu Miniconda untuk mempelajarinya.

Instalasi Miniconda diawali dengan mengunduh installer Miniconda pada link berikut ini, pilih untuk versi Python 3.8 baik untuk Windows, MacOS, maupun Linux. Contoh dalam gambar di bawah ini adalah untuk Windows 64bit.

download miniconda

Setelah installer berhasil diunduh maka langkah selanjutnya adalah menjalankan installer Miniconda3-latest-Windows-x86_64.exe. Jendela installer akan muncul, ikuti petunjuknya dengan menekan Next sampai instalasi berhasil, seperti perangkat lunak pada umumnya.

conda install

Menjalankan Python pada Anaconda Prompt

Setelah Miniconda berhasil diinstall pada perangkat kita maka akan muncul beberapa aplikasi baru, salah satunya adalah Anaconda Prompt. Anaconda Prompt ini adalah aplikasi utama yang akan sering kita gunakan. Tampilan pada Anaconda Prompt ini tidak ada bedanya dengan Command Prompt pada Windows atau Terminal pada MacOS dan Linux. Hal paling utama yang membedakan adalah pada Anaconda Prompt ini Python sudah terintegrasi dan bisa kita jalankan. Buka Anaconda Prompt melalui menu:

open anaconda

Untuk menjalankan Python maka kita dapat mengetikkan python dan menekan tombol enter pada Anaconda Prompt sehingga akan muncul antarmuka untuk Python. Antarmuka ini adalah tampilan paling sederhana dari Python, dapat kita sebut sebagai Python Console, kok tampilannya rumit ya? Tenang, nanti kita akan bermain kode dengan tampilan yang lebih friendly 😄 tapi sekarang kita coba dulu dari yang paling sederhana.

python console

Apa yang terjadi ketika kita mengetikkan 1+1 pada tampilan tersebut? Akan muncul hasil dari penjumlahan kedua angka tersebut yaitu 2. Selamat anda sudah berhasil menjalankan Python! Kita bisa mencoba bermacam-macam ekspresi matematik yang sederhana sekadar untuk belajar. Bagaimana kalau yang diketik adalah print("Hello World")?

Oke mari kita naik level, setelah menjalankan kode langsung melalui Python Console sekarang kita akan menuliskan kode di editor teks dan menjalankannya di Anaconda Prompt. Teman-teman dapat membuka editor teks masing-masing (seperti Notepad) dan coba ketikkan kode berikut:

print("Mencoba menjalankan kode yang diketik di editor")
print("Berhasil!")

save local file

kemudian simpan sebagai file dengan nama mencoba_python.py di lokasi yang teman-teman inginkan, misalnya disini saya simpan di D:\workshop, jangan lupa pilih All files pada pilihan Save as type. Setelah berhasil disimpan saatnya kita menjalankan kode Python yang sudah kita tuliskan di editor kode di dalam Anaconda Prompt. Saat kita membuka tampilan Anaconda Prompt maka biasanya kita akan berada di drive C, karena file saya simpan di D maka saya akan mengetikkan:

D:
cd workshop

maka kita akan masuk ke dalam folder tersebut, langkah ini bisa disesuaikan tergantung lokasi tempat teman-teman menyimpan file mencoba_python.py yang sebelumnya telah kita buat. Setelah masuk ke dalam folder tempat kita menyimpan maka selanjutnya kita dapat menjalankan kode kita dengan:

python mencoba_python.py

runpython file

Apakah yang terjadi?

Setelah sampai di level ini teman-teman sudah berhasil naik ke Level 2. Mari kita lanjutkan ke level berikutnya :D

Pengenalan IDE (Integrated Development Environment) dan Beberapa Contohnya

Dimana biasanya kita menuliskan kode kita sebelum kita jalankan? Ada banyak alternatif tempat kita menuliskan kode, salah satu yang paling sederhana adalah menuliskan kode kita di editor teks seperti Notepad apabila di Windows. Ada banyak aplikasi yang memang dikhususkan untuk menuliskan kode dimana terdapat berbagai macam fitur untuk mendukung produktivitas seperti pewarnaan kode (syntax highlighting), indentasi otomatis, dan debugging. Aplikasi-aplikasi tersebut bisa kita sebut sebagai IDE, beberapa IDE yang cukup umum digunakan untuk Python adalah:

  1. PyCharm
  2. Spyder
  3. Visual Studio Code

Mana yang akan kita gunakan? Jawabannya adalah tidak ketiganya

Kita pakai apa dong? Kita akan menggunakan Jupyter Notebook, aplikasi ini hampir mendekati IDE tetapi tidak memiliki fitur yang lengkap untuk disebut sebagai IDE,

Mengapa kita memakai Jupyter Notebook? Aplikasi ini memungkinkan kita mencatat sekaligus menuliskan kode dan menjalankannya. Hal ini mempermudah dalam rangka belajar karena penjelasan akan mempermudah dalam memahami kode.

Agar tidak penasaran kita dapat menginstall Jupyter Notebook beserta modul-modul eksternal yang digunakan sekarang :D

Menginstall Jupyter Notebook dan Modul Eksternal yang di Butuhkan

Anaconda mempermudah kita dalam menginstall sebuah paket atau modul tertentu, dalam materi ini kita akan membutuhkan notebook: Jupyter Notebook, numpy: olah data numerik, scipy: olah data saintifik, pandas: olah data, matplotlib: plotting, cartopy: plotting peta, dan obspy: olah data seismologi.

Sebelum menginstall modul terlebih dahulu kita membuat environment virtual untuk mengisolasi paket-paket yang akan kita gunakan, cara membuat environment virtual:

conda create -n envcourse

create env

Selanjutnya kita mengaktifkan dengan conda activate envcourse kemudian menginstall paket-paket di atas dengan perintah sebagai berikut di Anaconda Prompt:

conda install -c conda-forge obspy pandas matplotlib cartopy notebook

module_instal

Akan muncul konfirmasi setelah beberapa saat, tekan y dan enter untuk melanjutkan:

confirmation

Instalasi membutuhkan waktu yang tidak sebentar jadi bisa ditunggu atau mengerjakan pekerjaan lain. Proses ini cukup dilakukan 1x.

Menjalankan Jupyter Notebook

Jupyter Notebook merupakan salah satu paket (package) yang dapat diinstall dan memiliki fungsi untuk memberikan antarmuka pengguna grafis dalam penulisan kode dan membuat catatan bersama dengan kode tersebut. Sebuah paket bisa kita bayangkan sebagai kumpulan kode Python yang memiliki fungsi yang spesifik. Karena sudah dikemas dalam sebuah paket, maka kita hanya perlu memanggil paket tersebut saat akan menggunakannya, salah satunya Jupyter Notebook ini.

Setelah proses instalasi di atas selesai kita dapat pindah ke folder tempat kita akan menyimpan notebook kemudian menjalankan Jupyter Notebook dengan mengetikkan perintah di Anaconda Prompt kemudian tekan enter:

conda activate envcourse
D:
cd workshop
jupyter-notebook

jupyter notebook command

Selanjutnya antarmuka Jupyter Notebook akan muncul pada browser seperti Chrome, Firefox, atau Safari seperti pada gambar di bawah ini:

jupyter notebook

Untuk memulai membuat notebook baru kita dapat menekan tombol New kemudian pilih Python maka notebook akan muncul sebagai tab baru:

new notebook

Menjalankan kode sederhana di Jupyter Notebook

Kita dapat mengetikkan kode pada setiap cell yang ada di notebook, jenis cell dapat dibagi menjadi:

  1. Code, jenis cell ini berguna untuk menuliskan kode Python yang akan kita eksekusi
  2. Markdown, markdown berguna untuk menambahkan berbagai macam catatan pada notebook, markdown memiliki banyak fitur dan formatting yang dapat kita sesuaikan sesuai dengan kebutuhan catatan kita seperti tabel, gambar, list, dsb

cell_type

Karena kita akan menuliskan kode Python maka kita akan memilih jenis cell Code dan coba kita ketikkan kode berikut:

print("Mencoba menulis kode di Jupyter Notebook")
print("Sukses~")

Kita dapat menjalankan kode tersebut dengan menekan tombol segitiga atau tombol play (▶️) di bagian atas. Kode akan berjalan dan keluaran output akan keluar, setelah ini berhasil berarti teman-teman telah naik ke level 3 😄. Untuk penulisan kode pada materi-materi selanjutnya akan menggunakan Jupyter Notebook ini, sekaligus agar teman-teman bisa sambil mencatat materi yang diberikan. Beberapa percobaan lain:

In [1]:
print("Hari ini kita akan menjumlahkan dua bilangan")
bilangan1 = 10
bilangan2 = 30
jumlah = bilangan1 + bilangan2
print("Hasil penjumlahan", bilangan1, "dan", bilangan2, "adalah", jumlah)
Hari ini kita akan menjumlahkan dua bilangan
Hasil penjumlahan 10 dan 30 adalah 40

Bagaimana jika bilangan yang akan dijumlahkan kita ketikkan sendiri?

In [2]:
print("Hari ini kita akan menjumlahkan dua bilangan")
bilangan1 = input("Masukkan bilangan pertama")
bilangan2 = input("masukkan bilangan kedua")
jumlah = bilangan1 + bilangan2
print("Hasil penjumlahan", bilangan1, "dan", bilangan2, "adalah", jumlah)
Hari ini kita akan menjumlahkan dua bilangan
Masukkan bilangan pertama9
masukkan bilangan kedua9
Hasil penjumlahan 9 dan 9 adalah 99

Jika hasilnya aneh dan tidak sesuai dengan yang teman-teman harapkan berarti Pythonnya bekerja dengan baik. Hasil dari fungsi input adalah data dengan format String atau sederhananya kita sebut sebagai bukan angka, sedangkan yang akan kita jumlahkan seharusnya adalah angka, bisa berupa bilangan bulat atau Integer atau bilangan desimal atau Float. Apa yang terjadi ketika kita menjumlahkan dua String?

In [3]:
print("Pada cell ini kita akan menjumlahkan dua buah")
bilangan1 = "1"
bilangan2 = "20"
jumlah = bilangan1 + bilangan2
print("Hasil penjumlahan string adalah", jumlah)
Pada cell ini kita akan menjumlahkan dua buah
Hasil penjumlahan string adalah 120

Hasilnya sama seperti saat menjumlahkan hasil dari fungsi input bukan? Lalu bagaimana cara agar hasil input merupakan angka dan bukan String?

In [4]:
print("Hari ini kita akan menjumlahkan dua bilangan bulat")
bilangan1 = input("Masukkan bilangan pertama")
bilangan2 = input("masukkan bilangan kedua")
jumlah = int(bilangan1) + int(bilangan2)
print("Hasil penjumlahan bilangan bulat", bilangan1, "dan", bilangan2, "adalah", jumlah)
Hari ini kita akan menjumlahkan dua bilangan bulat
Masukkan bilangan pertama9
masukkan bilangan kedua9
Hasil penjumlahan bilangan bulat 9 dan 9 adalah 18

Hasilnya sudah seperti yang kita harapkan, ini karena hasil input atau yang kita masukkan sudah diubah menjadi bilangan bulat Integer saat kita memberikan fungsi int pada:

jumlah = int(bilangan1) + int(bilangan2)

Karena fungsi yang digunakan adalah int yang mengubah ke bilangan bulat maka ketika bilangan yang kita masukkan adalah bilangan desimal hasilnya akan error

In [5]:
print("Hari ini kita akan menjumlahkan dua bilangan bulat")
bilangan1 = input("Masukkan bilangan pertama")
bilangan2 = input("masukkan bilangan kedua")
jumlah = int(bilangan1) + int(bilangan2)
print("Hasil penjumlahan bilangan bulat", bilangan1, "dan", bilangan2, "adalah", jumlah)
Hari ini kita akan menjumlahkan dua bilangan bulat
Masukkan bilangan pertama9
masukkan bilangan kedua9
Hasil penjumlahan bilangan bulat 9 dan 9 adalah 18

Oleh karena itu kita harus ubah menjadi bilangan desimal terlebih dahulu menggunakan fungsi float:

In [6]:
print("Hari ini kita akan menjumlahkan dua bilangan")
bilangan1 = input("Masukkan bilangan pertama")
bilangan2 = input("masukkan bilangan kedua")
jumlah = float(bilangan1) + float(bilangan2)
print("Hasil penjumlahan bilangan bulat", bilangan1, "dan", bilangan2, "adalah", jumlah)
Hari ini kita akan menjumlahkan dua bilangan
Masukkan bilangan pertama9
masukkan bilangan kedua9
Hasil penjumlahan bilangan bulat 9 dan 9 adalah 18.0

Dari contoh-contoh di atas kita sudah mempelajari tiga macam tipe data yaitu String, Integer, dan Float.

Memanggil Paket/Modul Bawaan Python (seperti math), Mencoba, dan Memanggil bantuan (help) untuk Masing-Masing Fungsi

Pada saat akan menginstall Jupyter Notebook kita sudah sempat membahas bahwa terdapat berbagai macam paket atau modul Python yang berisi kumpulan kode untuk fungsi yang spesifik dimana kita tinggal memanggil modul tersebut. Sebagai contoh kita akan memanggil modul bawaan yang sudah terinstall bersamaan dengan Python yaitu paket math. Seperti namanya, paket ini berfungsi untuk melakukan berbagai macam operasi matematika. Bagaimana cara memanggil modul ini?

Untuk memanggil model math kita dapat menggunakan sintaks import seperti di bawah ini.

In [7]:
import math

Setelah kita jalankan kodenya kita tidak mendapat keluaran atau output apapun, karena proses ini hanya memanggil saja, untuk menggunakannya kita dapat memanggil fungsi-fungsi spesifik dari modul math ini. Apa saja fungsi yang dapat kita panggil? Kita dapat melihat apa saja yang tersedia dengan menggunakan fungsi help, mari kita coba

In [8]:
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)


Seperti yang kita lihat di atas, fungsi help akan menampilkan petunjuk untuk paket, modul, atau fungsi yang kita masukkan ke dalam fungsi help tersebut. Pada modul math ditampikan fungsi-fungsi yang dapat dipanggil, selain fungsi juga terdapat DATA yang berupa nilai-nilai konstanta seperti e, inf, pi. Mari kita coba panggil beberapa fungsi dan konstanta dari modul math:

In [9]:
math.e
Out[9]:
2.718281828459045
In [10]:
math.log(100)
Out[10]:
4.605170185988092

Mengapa nilai dari fungsi $\log(100)$ dari modul math tidak menunjukkan angka 2? Jadi apa yang dilakukan oleh fungsi log tersebut? Kita bisa mencari tau dengan memanfaatkan fungsi help lagi tetapi lebih spesifik untuk fungsi log:

In [11]:
help(math.log)
Help on built-in function log in module math:

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.

Menurut petunjuk di atas, ternyata fungsi log dapat diisi dengan berapapun basis yang kita inginkan ditandai dengan tulisan Return the logarithm of x to the given base.. Nah apabila tidak diketikkan basisnya di dalam fungsi tersebut maka basis akan secara default terisi sebagai bilangan natural (If the base not specified, returns the natural logarithm (base e) of x) atau $\ln$. Jika kita ingin menggunakan $\log$ dengan basis 10 maka kita dapat mengetikkan:

In [12]:
math.log(100,10)
Out[12]:
2.0

Hasilnya adalah nilai $\log(100)$ dengan basis 10, seperti yang kita inginkan. Selain fungsi log yang lebih umum dimana kita bisa memasukkan berapapun nilai basis yang kita inginkan, ternyata di modul math sudah disediakan $log$ khusus dengan basis 10 yaitu log10:

In [13]:
math.log10(100)
Out[13]:
2.0
In [14]:
angka_saya = 1000
In [15]:
math.log10(angka_saya)
Out[15]:
3.0
In [16]:
nilai = 5
nilai_kuadrat = math.pow(nilai,2)
nilai_kuadrat
Out[16]:
25.0

Pada fungsi math.sin kita dapat memasukkan nilai sudut dalam radian seperti pada petunjuk ini:

In [17]:
help(math.sin)
Help on built-in function sin in module math:

sin(x, /)
    Return the sine of x (measured in radians).

Nilai $\sin(\pi/2)$ adalah:

In [18]:
math.sin(math.pi/2)
Out[18]:
1.0

Berapakah nilai $\pi/2$ dalam derajat?

In [19]:
math.degrees(math.pi/2)
Out[19]:
90.0

Berapakah nilai 90 derajat dalam radian?

In [20]:
math.radians(90)
Out[20]:
1.5707963267948966

atau $\pi/2$.

Pada contoh di atas kita dapat mengubah sudut dari derajat ke radian menggunakan fungsi math.radians, dengan fungsi ini kita dapat langsung menghitung nilai $\sin(90)$ dengan 90 dalam derajat

In [21]:
sudut_derajat = 90
sudut_radian = math.radians(sudut_derajat)
nilai_sinus = math.sin(sudut_radian)
print(nilai_sinus)
1.0

Contoh-contoh di atas hanya membahas beberapa fungsi dari modul math, teman-teman bisa mencoba berbagai macam fungsi seperti yang tertulis di help(math).

Memberikan Catatan dan Gambar dalam Bentuk Markdown di Jupyter Notebook

Hal yang spesial dari Jupyter Notebook seperti yang sudah kita sempat singgung di awal yaitu kita bisa menambahkan catatan sekaligus menjalankan kode. Di bawah ini merupakan petunjuk-petunjuk untuk menambahkan berbagai macam jenis catatan.

Menambah heading atau judul bab/subbab

Menambah heading pada cell dengan jenis markdown dapat dilakukan dengan menggunakan simbol # sebelum nama judul, jumlah tanda # menunjukkan tingkat dari subbab.

markdown
# Merupakan heading level 1
## Merupakan heading level 2
### Merupakan heading level 3

akan menjadi:

Merupakan heading level 1

Merupakan heading level 2

Merupakan heading level 3

Menambahkan huruf tebal ataupun miring

Untuk menambahkan huruf tebal kita dapat menambah tanda asteriks (**) sebelum dan sesudah kata atau kalimat yang akan dicetak tebal, **contoh** akan menjadi contoh. Apabila kita mengurangi jumlah tanda asteriks menjadi hanya satu maka huruf akan tercetak miring, *contoh* akan menjadi contoh.

Membuat List

List baik yang berurutan atau tidak dapat ditulis menggunakan markdown, contohnya adalah:

markdown
* Pepaya
* Jambu
* Apel

akan menjadi:

  • Pepaya
  • Jambu
  • Apel

Apabila pada list berurutan maka penulisan didahului angka yang menunjukkan urutan dari komponen list:

markdown
1. Menginstall Python
2. Menginstall Anaconda
3. Menjalankan Notebook

akan menjadi:

  1. Menginstall Python
  2. Menginstall Anaconda
  3. Menjalankan Notebook

Menambah Tabel

markdown
Kolom 1 | Kolom 2
------------ | -------------
Konten 1 Kolom 1 | Konten 1 Kolom 2
Konten 2 Kolom 1 | Konten 2 Kolom 2

akan menjadi:

Kolom 1 Kolom 2
Konten 1 Kolom 1 Konten 1 Kolom 2
Konten 2 Kolom 1 Konten 2 Kolom 2

Menambahkan Gambar

Menambahkan gambar dapat dilakukan dengan sintaks ![keterangan](link/lokasi gambar), seperti contoh dibawah ini:

markdown
![GithubOctocat](https://github.githubassets.com/images/modules/logos_page/Octocat.png)

akan menjadi:

GithubOctocat

sekarang kita menaruh gambar di dalam folder figures, cara memanggil gambar tersebut adalah:

markdown
![GithubMark](figures/Github-Mark.png)

akan menjadi:

GithubMark

Link menuju suatu halaman web atau file dapat ditambahkan pada catatan di notebook kita dengan menggunakan sintaks [Tulisan Link](lokasi link). Contoh, sintaks berikut ini [Modul Workshop](https://github.com/anangsahroni/geoscope-geohazard-workshop) akan menjadi link Modul Workshop.

Menambahkan Kode

Kita juga dapat menambahkan kode sebagai tulisan dalam markdown, contohnya adalah kode Python berikut ini:

syntax md code

akan menjadi:

def pangkat(angka,pangkat):
    hasil = angka**pangkat
    return hasil

Dengan menulis di cell bertipe Markdown dan ditulis seperti di atas maka kode tidak tereksekusi melainkan menjadi sebuah catatan. Banyak bahasa pemrograman lain, kita tinggal mengganti tulisan python dengan bahasa pemrograman yang kita inginkan.

syntax md code_js

akan menjadi:

document.getElementById("logo").style.display="block";

Menambahkan Rumus Matematika

Yang menarik dari cell bertipe Markdown adalah kita juga dapat menuliskan perumusan matematika menggunakan sintaks dari MathJax, contohnya adalah untuk:

markdown
$$
e^{i \pi} + 1 = 0 
$$

yang akan menjadi:

$$ e^{i \pi} + 1 = 0 $$

Untuk menulis secara inline atau berada di dalam baris kita dapat menggunakan sintaks $ e^{i \pi} + 1 = 0 $ yang akan menjadi $ e^{i \pi} + 1 = 0 $. Contoh-contoh lain:

mathjax
$$
    \begin{matrix}
    1 & x & x^2 \\
    1 & y & y^2 \\
    1 & z & z^2 \\
    \end{matrix}
$$
$$ \begin{matrix} 1 & x & x^2 \\ 1 & y & y^2 \\ 1 & z & z^2 \\ \end{matrix} $$

Lebih kompleks lagi:

mathjax
$$ \bbox[5px,border:2px solid red]
{
e^x=\lim_{n\to\infty} \left( 1+\frac{x}{n} \right)^n
\qquad (2) 
}
$$

akan menjadi:

$$ \bbox[5px,border:2px solid red] { e^x=\lim_{n\to\infty} \left( 1+\frac{x}{n} \right)^n \qquad (2) } $$

Referensi secara lebih lengkap dapat dibuka di sini atau dengan kata kunci "MathJax Tutorial".

Membuat Check List

Berikut ini adalah contoh sintaks untuk membuat checklist:

- [x] Menginstall Jupyter Notebook
- [ ] Menjalankan Jupyter Notebook
- [ ] Mempelajari sintaks markdown

yang akan menjadi:

  • [x] Menginstall Jupyter Notebook
  • [ ] Menjalankan Jupyter Notebook
  • [ ] Mempelajari sintaks markdown

Membuat quote

Bagi yang suka sastra dan ingin mengutip sastrawan atau ilmuan, sintaksnya adalah seperti ini

markdown
> Ini adalah quote yang bagus
> - Oleh: Saya sendiri

Ini adalah quote yang bagus

  • Oleh: Saya sendiri

Menyimpan notebook pada repositori Github dan menambahkan ke Binder

Notebook dapat kita simpan melalui menu File-Save notebook atau mengganti nama di bagian atas kemudian menekan Enter, kemudian file dengan ekstensi .ipynb akan muncul di lokasi tempat kita pertama kali menjalankan jupyter-notebook. File tersebut dapat dibuka lagi dengan menggunakan jupyter-notebook lagi suatu saat. Selain menyimpan secara lokal di komputer, kita juga akan menyimpan notebook kita secara daring di sarana repositori GitHub. Github adalah sarana daring untuk pengembangan software dan pengontrol versi (version control). Kita akan coba melakukan kontrol versi paling sederhana pada notebook kita, tapi sebelumnya kita harus membuat akun lebih dahulu melalui GitHub.com.

Setelah membuat akun kita mulai dapat membuat repositori pertama kita dengan menekan tombol New pada halaman https://github.com/[namauser]?tab=repositories (namauser dapat diisi username teman-teman, tanpa tanda []).

gambar repositori baru

Kita selanjutnya diharuskan mengisi informasi repositori yang akan kita buat sebelum menekan tombol Create repository, seperti ini contohnya:

isi_info repositori baru

Setelah repositori dibuat kita dapat mengunggah notebook yang sudah kita ke buat dengan memilih opsi Upload files seperti pada gambar di bawah ini.

upload_notebook

Notebook dapat kita tarik atau drag ke tempat upload seperti pada gambar di bawah ini, untuk setiap file yang ditambahkan, diedit, ataupun dihapus kita harus menambhakan pesan commit. Pesan ini yang menjelaskan perubahan apa yang kita lakukan dan menjadi penanda untuk history file.

memulai_commit

Untuk menyimpan perubahan kita dapat menekan tombol Commit.

Mengupdate Notebook di Github dan Melihat History Perubahannya

Apabila kita mengubah notebook kita dan ingin mengupdate notebook di repositori, kita dapat mengulang proses upload notebook. Contoh pada kasus ini saya menambahkankan 4 gambar di notebook. Untuk mengupdate kita dapat mengupload lagi dan memberikan pesan untuk Commit kita, pada kasus ini pesan commit adalah "Mengupdate notebook sesi 1". Pesan commit tersebut bukan contoh yang baik sebenarnya, karena tidak jelas, lebih baik kita dapat menuliskan "Menambah gambar [nam gambar1], [nama gambar2], [nama gambar3], dan [nama gambar4]".

update_notebook

Kita dapat melihat riwayat perubahan dari notebook kita dengan memilih notebook kita pada tampilan repositori:

click_updated

Selanjutnya kita dapat menekan tombol History:

get_history

Pilih salah satu perubahan yang dapat kita lihat, berdasarkan pesan commit, inilah alasan mengapa kita harus menuliskan pesan commit yang jelas:

view_history

Disini dapat dilihat bahwa terdapat perubahan dimana kita menambah beberapa baris yang isinya untuk menambah gambar: view_changes

Menambah Notebook ke Binder

Seperti untuk modul kuliah ini yang dapat diakses secara daring, teman-teman juga bisa mengunggah notebook yang teman-teman gunakan. Langkah setelah membuat repositori di GitHub adalah mengunjungi laman web MyBinder. Salin URL repositori teman-teman, seperti pada gambar di bawah ini:

copy url

Kemudian tempel salinan tadi ke form isian dari MyBinder kemudian tekan Launch.

binder

Selesai