Pre-Sesi: Instalasi Miniconda dan Modul-modul yang Dipakai
\n",
"
\n",
"
\n",
"
\n",
"
Tujuan: Memperkenalkan cara instalasi Miniconda serta menggunakannya untuk manajemen paket termasuk Jupyter Notebook
\n",
"
Keluaran: Peserta dapat menjalankan Python, Miniconda, dan Jupyter Notebook dan memahami penggunaannya
\n",
"
Sesi Persiapan
\n",
"
Waktu/Tempat: Jumat, 17 September 2021/ Mandiri
\n",
"
\n",
"
"
]
},
{
"cell_type": "markdown",
"id": "invisible-fraud",
"metadata": {},
"source": [
"## Instalasi Miniconda pada Windows\n",
"\n",
"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.\n",
"\n",
"Instalasi Miniconda diawali dengan mengunduh installer Miniconda pada [link](https://docs.conda.io/en/latest/miniconda.html) berikut ini, pilih untuk versi Python 3.8 baik untuk Windows, MacOS, maupun Linux. Contoh dalam gambar di bawah ini adalah untuk Windows 64bit.\n",
"\n",
"\n",
"\n",
"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.\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"id": "above-permit",
"metadata": {},
"source": [
"## Menjalankan Python pada Anaconda Prompt\n",
"\n",
"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:\n",
"\n",
"\n",
"\n",
"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.\n",
"\n",
"\n",
"\n",
"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\")`?\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "sixth-funds",
"metadata": {},
"source": [
"## Menuliskan Kode dalam Editor Teks dan Menjalankan Kode tersebut di Anaconda Prompt\n",
"\n",
"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:\n",
"\n",
"```python\n",
"print(\"Mencoba menjalankan kode yang diketik di editor\")\n",
"print(\"Berhasil!\")\n",
"```\n",
"\n",
"\n",
"\n",
"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:\n",
"\n",
"```\n",
"D:\n",
"cd workshop\n",
"```\n",
"\n",
"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:\n",
"\n",
"```\n",
"python mencoba_python.py\n",
"```\n",
"\n",
"\n",
"\n",
"\n",
"Apakah yang terjadi?\n",
"\n",
"Setelah sampai di level ini teman-teman sudah berhasil naik ke Level 2. Mari kita lanjutkan ke level berikutnya :D"
]
},
{
"cell_type": "markdown",
"id": "incomplete-diversity",
"metadata": {},
"source": [
"## Pengenalan IDE (*Integrated Development Environment*) dan Beberapa Contohnya\n",
"\n",
"Dimana biasanya kita menuliskan kode kita sebelum kita jalankan?\n",
"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:\n",
"1. PyCharm\n",
"2. Spyder\n",
"3. Visual Studio Code\n",
"\n",
"Mana yang akan kita gunakan?\n",
"Jawabannya adalah tidak ketiganya\n",
"\n",
"Kita pakai apa dong?\n",
"Kita akan menggunakan **Jupyter Notebook**, aplikasi ini hampir mendekati IDE tetapi tidak memiliki fitur yang lengkap untuk disebut sebagai IDE,\n",
"\n",
"Mengapa kita memakai **Jupyter Notebook**?\n",
"Aplikasi ini memungkinkan kita mencatat sekaligus menuliskan kode dan menjalankannya. Hal ini mempermudah dalam rangka belajar karena penjelasan akan mempermudah dalam memahami kode.\n",
"\n",
"Agar tidak penasaran kita dapat menginstall **Jupyter Notebook** beserta modul-modul eksternal yang digunakan sekarang :D\n"
]
},
{
"cell_type": "markdown",
"id": "f3c047e8",
"metadata": {},
"source": [
"## Menginstall Jupyter Notebook dan Modul Eksternal yang di Butuhkan\n",
"\n",
"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. \n",
"\n",
"Sebelum menginstall modul terlebih dahulu kita membuat environment virtual untuk mengisolasi paket-paket yang akan kita gunakan, cara membuat environment virtual:\n",
"\n",
"```\n",
"conda create -n envcourse\n",
"```\n",
"\n",
"\n",
"\n",
"Selanjutnya kita mengaktifkan dengan `conda activate envcourse` kemudian menginstall paket-paket di atas dengan perintah sebagai berikut di **Anaconda Prompt**:\n",
"\n",
"```\n",
"conda install -c conda-forge obspy pandas matplotlib cartopy notebook\n",
"```\n",
"\n",
"\n",
"Akan muncul konfirmasi setelah beberapa saat, tekan `y` dan `enter` untuk melanjutkan:\n",
"\n",
"\n",
"\n",
"Instalasi membutuhkan waktu yang tidak sebentar jadi bisa ditunggu atau mengerjakan pekerjaan lain. Proses ini cukup dilakukan 1x."
]
},
{
"cell_type": "markdown",
"id": "plastic-moore",
"metadata": {},
"source": [
"## Menjalankan Jupyter Notebook\n",
"\n",
"**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.\n",
"\n",
"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:\n",
"\n",
"```\n",
"conda activate envcourse\n",
"D:\n",
"cd workshop\n",
"jupyter-notebook\n",
"```\n",
"\n",
"\n",
"\n",
"Selanjutnya antarmuka **Jupyter Notebook** akan muncul pada browser seperti Chrome, Firefox, atau Safari seperti pada gambar di bawah ini:\n",
"\n",
"\n",
"\n",
"Untuk memulai membuat *notebook* baru kita dapat menekan tombol `New` kemudian pilih `Python` maka *notebook* akan muncul sebagai tab baru:\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"id": "demanding-wheel",
"metadata": {},
"source": [
"## Menjalankan kode sederhana di Jupyter Notebook\n",
"\n",
"Kita dapat mengetikkan kode pada setiap `cell` yang ada di notebook, jenis `cell` dapat dibagi menjadi:\n",
"1. `Code`, jenis *cell* ini berguna untuk menuliskan kode Python yang akan kita eksekusi\n",
"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\n",
"\n",
"\n",
"\n",
"Karena kita akan menuliskan kode Python maka kita akan memilih jenis *cell* `Code` dan coba kita ketikkan kode berikut:\n",
"\n",
"```python\n",
"print(\"Mencoba menulis kode di Jupyter Notebook\")\n",
"print(\"Sukses~\")\n",
"```\n",
"\n",
"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:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "familiar-heart",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hari ini kita akan menjumlahkan dua bilangan\n",
"Hasil penjumlahan 10 dan 30 adalah 40\n"
]
}
],
"source": [
"print(\"Hari ini kita akan menjumlahkan dua bilangan\")\n",
"bilangan1 = 10\n",
"bilangan2 = 30\n",
"jumlah = bilangan1 + bilangan2\n",
"print(\"Hasil penjumlahan\", bilangan1, \"dan\", bilangan2, \"adalah\", jumlah)"
]
},
{
"cell_type": "markdown",
"id": "blond-yukon",
"metadata": {},
"source": [
"Bagaimana jika bilangan yang akan dijumlahkan kita ketikkan sendiri?"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "dirty-alfred",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hari ini kita akan menjumlahkan dua bilangan\n",
"Masukkan bilangan pertama9\n",
"masukkan bilangan kedua9\n",
"Hasil penjumlahan 9 dan 9 adalah 99\n"
]
}
],
"source": [
"print(\"Hari ini kita akan menjumlahkan dua bilangan\")\n",
"bilangan1 = input(\"Masukkan bilangan pertama\")\n",
"bilangan2 = input(\"masukkan bilangan kedua\")\n",
"jumlah = bilangan1 + bilangan2\n",
"print(\"Hasil penjumlahan\", bilangan1, \"dan\", bilangan2, \"adalah\", jumlah)"
]
},
{
"cell_type": "markdown",
"id": "fifth-depression",
"metadata": {},
"source": [
"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`?"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "boxed-eagle",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Pada cell ini kita akan menjumlahkan dua buah\n",
"Hasil penjumlahan string adalah 120\n"
]
}
],
"source": [
"print(\"Pada cell ini kita akan menjumlahkan dua buah\")\n",
"bilangan1 = \"1\"\n",
"bilangan2 = \"20\"\n",
"jumlah = bilangan1 + bilangan2\n",
"print(\"Hasil penjumlahan string adalah\", jumlah)"
]
},
{
"cell_type": "markdown",
"id": "electric-collins",
"metadata": {},
"source": [
"Hasilnya sama seperti saat menjumlahkan hasil dari fungsi `input` bukan? Lalu bagaimana cara agar hasil `input` merupakan angka dan bukan `String`?"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "fluid-imperial",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hari ini kita akan menjumlahkan dua bilangan bulat\n",
"Masukkan bilangan pertama9\n",
"masukkan bilangan kedua9\n",
"Hasil penjumlahan bilangan bulat 9 dan 9 adalah 18\n"
]
}
],
"source": [
"print(\"Hari ini kita akan menjumlahkan dua bilangan bulat\")\n",
"bilangan1 = input(\"Masukkan bilangan pertama\")\n",
"bilangan2 = input(\"masukkan bilangan kedua\")\n",
"jumlah = int(bilangan1) + int(bilangan2)\n",
"print(\"Hasil penjumlahan bilangan bulat\", bilangan1, \"dan\", bilangan2, \"adalah\", jumlah)"
]
},
{
"cell_type": "markdown",
"id": "becoming-dryer",
"metadata": {},
"source": [
"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:\n",
"\n",
"```python\n",
"jumlah = int(bilangan1) + int(bilangan2)\n",
"```\n",
"\n",
"Karena fungsi yang digunakan adalah `int` yang mengubah ke bilangan bulat maka ketika bilangan yang kita masukkan adalah bilangan desimal hasilnya akan error"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "regulation-baseball",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hari ini kita akan menjumlahkan dua bilangan bulat\n",
"Masukkan bilangan pertama9\n",
"masukkan bilangan kedua9\n",
"Hasil penjumlahan bilangan bulat 9 dan 9 adalah 18\n"
]
}
],
"source": [
"print(\"Hari ini kita akan menjumlahkan dua bilangan bulat\")\n",
"bilangan1 = input(\"Masukkan bilangan pertama\")\n",
"bilangan2 = input(\"masukkan bilangan kedua\")\n",
"jumlah = int(bilangan1) + int(bilangan2)\n",
"print(\"Hasil penjumlahan bilangan bulat\", bilangan1, \"dan\", bilangan2, \"adalah\", jumlah)"
]
},
{
"cell_type": "markdown",
"id": "advanced-layout",
"metadata": {},
"source": [
"Oleh karena itu kita harus ubah menjadi bilangan desimal terlebih dahulu menggunakan fungsi `float`:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "sunset-payday",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hari ini kita akan menjumlahkan dua bilangan\n",
"Masukkan bilangan pertama9\n",
"masukkan bilangan kedua9\n",
"Hasil penjumlahan bilangan bulat 9 dan 9 adalah 18.0\n"
]
}
],
"source": [
"print(\"Hari ini kita akan menjumlahkan dua bilangan\")\n",
"bilangan1 = input(\"Masukkan bilangan pertama\")\n",
"bilangan2 = input(\"masukkan bilangan kedua\")\n",
"jumlah = float(bilangan1) + float(bilangan2)\n",
"print(\"Hasil penjumlahan bilangan bulat\", bilangan1, \"dan\", bilangan2, \"adalah\", jumlah)"
]
},
{
"cell_type": "markdown",
"id": "standing-catalog",
"metadata": {},
"source": [
"Dari contoh-contoh di atas kita sudah mempelajari tiga macam tipe data yaitu `String`, `Integer`, dan `Float`."
]
},
{
"cell_type": "markdown",
"id": "inner-aquatic",
"metadata": {},
"source": [
"## Memanggil Paket/Modul Bawaan Python (seperti `math`), Mencoba, dan Memanggil bantuan (`help`) untuk Masing-Masing Fungsi\n",
"\n",
"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?\n",
"\n",
"Untuk memanggil model `math` kita dapat menggunakan sintaks `import` seperti di bawah ini."
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "wound-housing",
"metadata": {},
"outputs": [],
"source": [
"import math"
]
},
{
"cell_type": "markdown",
"id": "equivalent-olympus",
"metadata": {},
"source": [
"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"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "european-evolution",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Help on built-in module math:\n",
"\n",
"NAME\n",
" math\n",
"\n",
"DESCRIPTION\n",
" This module provides access to the mathematical functions\n",
" defined by the C standard.\n",
"\n",
"FUNCTIONS\n",
" acos(x, /)\n",
" Return the arc cosine (measured in radians) of x.\n",
" \n",
" The result is between 0 and pi.\n",
" \n",
" acosh(x, /)\n",
" Return the inverse hyperbolic cosine of x.\n",
" \n",
" asin(x, /)\n",
" Return the arc sine (measured in radians) of x.\n",
" \n",
" The result is between -pi/2 and pi/2.\n",
" \n",
" asinh(x, /)\n",
" Return the inverse hyperbolic sine of x.\n",
" \n",
" atan(x, /)\n",
" Return the arc tangent (measured in radians) of x.\n",
" \n",
" The result is between -pi/2 and pi/2.\n",
" \n",
" atan2(y, x, /)\n",
" Return the arc tangent (measured in radians) of y/x.\n",
" \n",
" Unlike atan(y/x), the signs of both x and y are considered.\n",
" \n",
" atanh(x, /)\n",
" Return the inverse hyperbolic tangent of x.\n",
" \n",
" ceil(x, /)\n",
" Return the ceiling of x as an Integral.\n",
" \n",
" This is the smallest integer >= x.\n",
" \n",
" comb(n, k, /)\n",
" Number of ways to choose k items from n items without repetition and without order.\n",
" \n",
" Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates\n",
" to zero when k > n.\n",
" \n",
" Also called the binomial coefficient because it is equivalent\n",
" to the coefficient of k-th term in polynomial expansion of the\n",
" expression (1 + x)**n.\n",
" \n",
" Raises TypeError if either of the arguments are not integers.\n",
" Raises ValueError if either of the arguments are negative.\n",
" \n",
" copysign(x, y, /)\n",
" Return a float with the magnitude (absolute value) of x but the sign of y.\n",
" \n",
" On platforms that support signed zeros, copysign(1.0, -0.0)\n",
" returns -1.0.\n",
" \n",
" cos(x, /)\n",
" Return the cosine of x (measured in radians).\n",
" \n",
" cosh(x, /)\n",
" Return the hyperbolic cosine of x.\n",
" \n",
" degrees(x, /)\n",
" Convert angle x from radians to degrees.\n",
" \n",
" dist(p, q, /)\n",
" Return the Euclidean distance between two points p and q.\n",
" \n",
" The points should be specified as sequences (or iterables) of\n",
" coordinates. Both inputs must have the same dimension.\n",
" \n",
" Roughly equivalent to:\n",
" sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))\n",
" \n",
" erf(x, /)\n",
" Error function at x.\n",
" \n",
" erfc(x, /)\n",
" Complementary error function at x.\n",
" \n",
" exp(x, /)\n",
" Return e raised to the power of x.\n",
" \n",
" expm1(x, /)\n",
" Return exp(x)-1.\n",
" \n",
" This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.\n",
" \n",
" fabs(x, /)\n",
" Return the absolute value of the float x.\n",
" \n",
" factorial(x, /)\n",
" Find x!.\n",
" \n",
" Raise a ValueError if x is negative or non-integral.\n",
" \n",
" floor(x, /)\n",
" Return the floor of x as an Integral.\n",
" \n",
" This is the largest integer <= x.\n",
" \n",
" fmod(x, y, /)\n",
" Return fmod(x, y), according to platform C.\n",
" \n",
" x % y may differ.\n",
" \n",
" frexp(x, /)\n",
" Return the mantissa and exponent of x, as pair (m, e).\n",
" \n",
" m is a float and e is an int, such that x = m * 2.**e.\n",
" If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.\n",
" \n",
" fsum(seq, /)\n",
" Return an accurate floating point sum of values in the iterable seq.\n",
" \n",
" Assumes IEEE-754 floating point arithmetic.\n",
" \n",
" gamma(x, /)\n",
" Gamma function at x.\n",
" \n",
" gcd(*integers)\n",
" Greatest Common Divisor.\n",
" \n",
" hypot(...)\n",
" hypot(*coordinates) -> value\n",
" \n",
" Multidimensional Euclidean distance from the origin to a point.\n",
" \n",
" Roughly equivalent to:\n",
" sqrt(sum(x**2 for x in coordinates))\n",
" \n",
" For a two dimensional point (x, y), gives the hypotenuse\n",
" using the Pythagorean theorem: sqrt(x*x + y*y).\n",
" \n",
" For example, the hypotenuse of a 3/4/5 right triangle is:\n",
" \n",
" >>> hypot(3.0, 4.0)\n",
" 5.0\n",
" \n",
" isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)\n",
" Determine whether two floating point numbers are close in value.\n",
" \n",
" rel_tol\n",
" maximum difference for being considered \"close\", relative to the\n",
" magnitude of the input values\n",
" abs_tol\n",
" maximum difference for being considered \"close\", regardless of the\n",
" magnitude of the input values\n",
" \n",
" Return True if a is close in value to b, and False otherwise.\n",
" \n",
" For the values to be considered close, the difference between them\n",
" must be smaller than at least one of the tolerances.\n",
" \n",
" -inf, inf and NaN behave similarly to the IEEE 754 Standard. That\n",
" is, NaN is not close to anything, even itself. inf and -inf are\n",
" only close to themselves.\n",
" \n",
" isfinite(x, /)\n",
" Return True if x is neither an infinity nor a NaN, and False otherwise.\n",
" \n",
" isinf(x, /)\n",
" Return True if x is a positive or negative infinity, and False otherwise.\n",
" \n",
" isnan(x, /)\n",
" Return True if x is a NaN (not a number), and False otherwise.\n",
" \n",
" isqrt(n, /)\n",
" Return the integer part of the square root of the input.\n",
" \n",
" lcm(*integers)\n",
" Least Common Multiple.\n",
" \n",
" ldexp(x, i, /)\n",
" Return x * (2**i).\n",
" \n",
" This is essentially the inverse of frexp().\n",
" \n",
" lgamma(x, /)\n",
" Natural logarithm of absolute value of Gamma function at x.\n",
" \n",
" log(...)\n",
" log(x, [base=math.e])\n",
" Return the logarithm of x to the given base.\n",
" \n",
" If the base not specified, returns the natural logarithm (base e) of x.\n",
" \n",
" log10(x, /)\n",
" Return the base 10 logarithm of x.\n",
" \n",
" log1p(x, /)\n",
" Return the natural logarithm of 1+x (base e).\n",
" \n",
" The result is computed in a way which is accurate for x near zero.\n",
" \n",
" log2(x, /)\n",
" Return the base 2 logarithm of x.\n",
" \n",
" modf(x, /)\n",
" Return the fractional and integer parts of x.\n",
" \n",
" Both results carry the sign of x and are floats.\n",
" \n",
" nextafter(x, y, /)\n",
" Return the next floating-point value after x towards y.\n",
" \n",
" perm(n, k=None, /)\n",
" Number of ways to choose k items from n items without repetition and with order.\n",
" \n",
" Evaluates to n! / (n - k)! when k <= n and evaluates\n",
" to zero when k > n.\n",
" \n",
" If k is not specified or is None, then k defaults to n\n",
" and the function returns n!.\n",
" \n",
" Raises TypeError if either of the arguments are not integers.\n",
" Raises ValueError if either of the arguments are negative.\n",
" \n",
" pow(x, y, /)\n",
" Return x**y (x to the power of y).\n",
" \n",
" prod(iterable, /, *, start=1)\n",
" Calculate the product of all the elements in the input iterable.\n",
" \n",
" The default start value for the product is 1.\n",
" \n",
" When the iterable is empty, return the start value. This function is\n",
" intended specifically for use with numeric values and may reject\n",
" non-numeric types.\n",
" \n",
" radians(x, /)\n",
" Convert angle x from degrees to radians.\n",
" \n",
" remainder(x, y, /)\n",
" Difference between x and the closest integer multiple of y.\n",
" \n",
" Return x - n*y where n*y is the closest integer multiple of y.\n",
" In the case where x is exactly halfway between two multiples of\n",
" y, the nearest even value of n is used. The result is always exact.\n",
" \n",
" sin(x, /)\n",
" Return the sine of x (measured in radians).\n",
" \n",
" sinh(x, /)\n",
" Return the hyperbolic sine of x.\n",
" \n",
" sqrt(x, /)\n",
" Return the square root of x.\n",
" \n",
" tan(x, /)\n",
" Return the tangent of x (measured in radians).\n",
" \n",
" tanh(x, /)\n",
" Return the hyperbolic tangent of x.\n",
" \n",
" trunc(x, /)\n",
" Truncates the Real x to the nearest Integral toward 0.\n",
" \n",
" Uses the __trunc__ magic method.\n",
" \n",
" ulp(x, /)\n",
" Return the value of the least significant bit of the float x.\n",
"\n",
"DATA\n",
" e = 2.718281828459045\n",
" inf = inf\n",
" nan = nan\n",
" pi = 3.141592653589793\n",
" tau = 6.283185307179586\n",
"\n",
"FILE\n",
" (built-in)\n",
"\n",
"\n"
]
}
],
"source": [
"help(math)"
]
},
{
"cell_type": "markdown",
"id": "ecological-sally",
"metadata": {},
"source": [
"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`:"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "foreign-prisoner",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2.718281828459045"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"math.e"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "raised-venture",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4.605170185988092"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"math.log(100)"
]
},
{
"cell_type": "markdown",
"id": "spanish-anthropology",
"metadata": {},
"source": [
"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`:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "considerable-enhancement",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Help on built-in function log in module math:\n",
"\n",
"log(...)\n",
" log(x, [base=math.e])\n",
" Return the logarithm of x to the given base.\n",
" \n",
" If the base not specified, returns the natural logarithm (base e) of x.\n",
"\n"
]
}
],
"source": [
"help(math.log)"
]
},
{
"cell_type": "markdown",
"id": "composite-cooper",
"metadata": {},
"source": [
"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:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "documentary-delta",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2.0"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"math.log(100,10)"
]
},
{
"cell_type": "markdown",
"id": "widespread-wireless",
"metadata": {},
"source": [
"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`:"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "trained-country",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2.0"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"math.log10(100)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "north-medicine",
"metadata": {},
"outputs": [],
"source": [
"angka_saya = 1000"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "demographic-lottery",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3.0"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"math.log10(angka_saya)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "recovered-hacker",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"25.0"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"nilai = 5\n",
"nilai_kuadrat = math.pow(nilai,2)\n",
"nilai_kuadrat"
]
},
{
"cell_type": "markdown",
"id": "welcome-string",
"metadata": {},
"source": [
"Pada fungsi `math.sin` kita dapat memasukkan nilai sudut dalam **radian** seperti pada petunjuk ini:"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "known-vancouver",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Help on built-in function sin in module math:\n",
"\n",
"sin(x, /)\n",
" Return the sine of x (measured in radians).\n",
"\n"
]
}
],
"source": [
"help(math.sin)"
]
},
{
"cell_type": "markdown",
"id": "bibliographic-stone",
"metadata": {},
"source": [
"Nilai $\\sin(\\pi/2)$ adalah:"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "judicial-nurse",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.0"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"math.sin(math.pi/2)"
]
},
{
"cell_type": "markdown",
"id": "romantic-application",
"metadata": {},
"source": [
"Berapakah nilai $\\pi/2$ dalam derajat?"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "fourth-agreement",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"90.0"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"math.degrees(math.pi/2)"
]
},
{
"cell_type": "markdown",
"id": "protecting-rebecca",
"metadata": {},
"source": [
"Berapakah nilai 90 derajat dalam radian?"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "cordless-piano",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.5707963267948966"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"math.radians(90)"
]
},
{
"cell_type": "markdown",
"id": "reduced-buying",
"metadata": {},
"source": [
"atau $\\pi/2$."
]
},
{
"cell_type": "markdown",
"id": "understanding-april",
"metadata": {},
"source": [
"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"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "auburn-westminster",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.0\n"
]
}
],
"source": [
"sudut_derajat = 90\n",
"sudut_radian = math.radians(sudut_derajat)\n",
"nilai_sinus = math.sin(sudut_radian)\n",
"print(nilai_sinus)"
]
},
{
"cell_type": "markdown",
"id": "professional-genesis",
"metadata": {},
"source": [
"Contoh-contoh di atas hanya membahas beberapa fungsi dari modul `math`, teman-teman bisa mencoba berbagai macam fungsi seperti yang tertulis di `help(math)`."
]
},
{
"cell_type": "markdown",
"id": "wrapped-honduras",
"metadata": {},
"source": [
"## Memberikan Catatan dan Gambar dalam Bentuk Markdown di Jupyter Notebook\n",
"\n",
"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.\n",
"\n",
"### Menambah *heading* atau judul bab/subbab\n",
"\n",
"Menambah *heading* pada `cell` dengan jenis `markdown` dapat dilakukan dengan menggunakan simbol `#` sebelum nama judul, jumlah tanda `#` menunjukkan tingkat dari subbab.\n",
"\n",
"```markdown\n",
"# Merupakan heading level 1\n",
"## Merupakan heading level 2\n",
"### Merupakan heading level 3\n",
"```\n",
"akan menjadi:\n",
"\n",
"# Merupakan heading level 1\n",
"## Merupakan heading level 2\n",
"### Merupakan heading level 3"
]
},
{
"cell_type": "markdown",
"id": "nominated-interpretation",
"metadata": {},
"source": [
"### Menambahkan huruf **tebal** ataupun *miring*\n",
"\n",
"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*."
]
},
{
"cell_type": "markdown",
"id": "european-namibia",
"metadata": {},
"source": [
"### Membuat List\n",
"\n",
"List baik yang berurutan atau tidak dapat ditulis menggunakan markdown, contohnya adalah:\n",
"\n",
"```markdown\n",
"* Pepaya\n",
"* Jambu\n",
"* Apel\n",
"```\n",
"\n",
"akan menjadi:\n",
"\n",
"* Pepaya\n",
"* Jambu\n",
"* Apel\n",
"\n",
"Apabila pada list berurutan maka penulisan didahului angka yang menunjukkan urutan dari komponen list:\n",
"\n",
"```markdown\n",
"1. Menginstall Python\n",
"2. Menginstall Anaconda\n",
"3. Menjalankan Notebook\n",
"```\n",
"\n",
"akan menjadi:\n",
"\n",
"1. Menginstall Python\n",
"2. Menginstall Anaconda\n",
"3. Menjalankan Notebook"
]
},
{
"cell_type": "markdown",
"id": "upset-knife",
"metadata": {},
"source": [
"### Menambah Tabel\n",
"\n",
"```markdown\n",
"Kolom 1 | Kolom 2\n",
"------------ | -------------\n",
"Konten 1 Kolom 1 | Konten 1 Kolom 2\n",
"Konten 2 Kolom 1 | Konten 2 Kolom 2\n",
"```\n",
"\n",
"akan menjadi:\n",
"\n",
"Kolom 1 | Kolom 2\n",
"------------ | -------------\n",
"Konten 1 Kolom 1 | Konten 1 Kolom 2\n",
"Konten 2 Kolom 1 | Konten 2 Kolom 2"
]
},
{
"cell_type": "markdown",
"id": "frank-gates",
"metadata": {},
"source": [
"### Menambahkan Gambar\n",
"\n",
"Menambahkan gambar dapat dilakukan dengan sintaks ``, seperti contoh dibawah ini:\n",
"\n",
"```markdown\n",
"\n",
"```\n",
"\n",
"akan menjadi:\n",
"\n",
"\n",
"\n",
"\n",
"sekarang kita menaruh gambar di dalam folder `figures`, cara memanggil gambar tersebut adalah:\n",
"\n",
"```markdown\n",
"\n",
"```\n",
"\n",
"akan menjadi:\n",
"\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"id": "virgin-technique",
"metadata": {},
"source": [
"### Menambahkan Link\n",
"\n",
"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](https://github.com/anangsahroni/geoscope-geohazard-workshop)."
]
},
{
"cell_type": "markdown",
"id": "binding-calvin",
"metadata": {},
"source": [
"### Menambahkan Kode\n",
"\n",
"Kita juga dapat menambahkan kode sebagai tulisan dalam markdown, contohnya adalah kode Python berikut ini:\n",
"\n",
"\n",
"\n",
"akan menjadi:\n",
"\n",
"```python\n",
"def pangkat(angka,pangkat):\n",
" hasil = angka**pangkat\n",
" return hasil\n",
"```\n",
"\n",
"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.\n",
"\n",
"\n",
"\n",
"akan menjadi:\n",
"\n",
"```javascript\n",
"document.getElementById(\"logo\").style.display=\"block\";\n",
"```\n"
]
},
{
"cell_type": "markdown",
"id": "numeric-cameroon",
"metadata": {},
"source": [
"### Menambahkan Rumus Matematika\n",
"\n",
"Yang menarik dari `cell` bertipe `Markdown` adalah kita juga dapat menuliskan perumusan matematika menggunakan sintaks dari `MathJax`, contohnya adalah untuk:\n",
"\n",
"```markdown\n",
"$$\n",
"e^{i \\pi} + 1 = 0 \n",
"$$\n",
"```\n",
"\n",
"yang akan menjadi:\n",
"\n",
"$$\n",
"e^{i \\pi} + 1 = 0 \n",
"$$\n",
"\n",
"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:\n",
"\n",
"```mathjax\n",
"$$\n",
" \\begin{matrix}\n",
" 1 & x & x^2 \\\\\n",
" 1 & y & y^2 \\\\\n",
" 1 & z & z^2 \\\\\n",
" \\end{matrix}\n",
"$$\n",
"```\n",
"\n",
"$$\n",
" \\begin{matrix}\n",
" 1 & x & x^2 \\\\\n",
" 1 & y & y^2 \\\\\n",
" 1 & z & z^2 \\\\\n",
" \\end{matrix}\n",
"$$\n",
"\n",
"Lebih kompleks lagi:\n",
"\n",
"```mathjax\n",
"$$ \\bbox[5px,border:2px solid red]\n",
"{\n",
"e^x=\\lim_{n\\to\\infty} \\left( 1+\\frac{x}{n} \\right)^n\n",
"\\qquad (2) \n",
"}\n",
"$$\n",
"```\n",
"\n",
"akan menjadi:\n",
"\n",
"$$ \\bbox[5px,border:2px solid red]\n",
"{\n",
"e^x=\\lim_{n\\to\\infty} \\left( 1+\\frac{x}{n} \\right)^n\n",
"\\qquad (2) \n",
"}\n",
"$$\n",
"\n",
"Referensi secara lebih lengkap dapat dibuka di [sini](https://math.meta.stackexchange.com/questions/5020/mathjax-basic-tutorial-and-quick-reference) atau dengan kata kunci \"MathJax Tutorial\"."
]
},
{
"cell_type": "markdown",
"id": "loose-anatomy",
"metadata": {},
"source": [
"### Membuat Check List\n",
"\n",
"Berikut ini adalah contoh sintaks untuk membuat *checklist*:\n",
"```\n",
"- [x] Menginstall Jupyter Notebook\n",
"- [ ] Menjalankan Jupyter Notebook\n",
"- [ ] Mempelajari sintaks markdown\n",
"```\n",
"\n",
"yang akan menjadi:\n",
"\n",
"- [x] Menginstall Jupyter Notebook\n",
"- [ ] Menjalankan Jupyter Notebook\n",
"- [ ] Mempelajari sintaks markdown\n"
]
},
{
"cell_type": "markdown",
"id": "opposite-priority",
"metadata": {},
"source": [
"### Membuat `quote`\n",
"\n",
"Bagi yang suka sastra dan ingin mengutip sastrawan atau ilmuan, sintaksnya adalah seperti ini\n",
"\n",
"```markdown\n",
"> Ini adalah quote yang bagus\n",
"> - Oleh: Saya sendiri\n",
"```\n",
"\n",
"> Ini adalah quote yang bagus\n",
"> - Oleh: Saya sendiri"
]
},
{
"cell_type": "markdown",
"id": "ruled-fusion",
"metadata": {},
"source": [
"## Menyimpan notebook pada repositori Github dan menambahkan ke Binder\n",
"\n",
"*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](http://github.com).\n",
"\n",
"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 `[]`).\n",
"\n",
"\n",
"\n",
"Kita selanjutnya diharuskan mengisi informasi repositori yang akan kita buat sebelum menekan tombol `Create repository`, seperti ini contohnya:\n",
"\n",
"\n",
"\n",
"Setelah repositori dibuat kita dapat mengunggah *notebook* yang sudah kita ke buat dengan memilih opsi `Upload files` seperti pada gambar di bawah ini.\n",
"\n",
"\n",
"\n",
"*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.\n",
"\n",
"\n",
"\n",
"Untuk menyimpan perubahan kita dapat menekan tombol `Commit`.\n"
]
},
{
"cell_type": "markdown",
"id": "green-rochester",
"metadata": {},
"source": [
"## Mengupdate Notebook di Github dan Melihat *History* Perubahannya\n",
"\n",
"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]\".\n",
"\n",
"\n",
"\n",
"Kita dapat melihat riwayat perubahan dari notebook kita dengan memilih notebook kita pada tampilan repositori:\n",
"\n",
"\n",
"\n",
"\n",
"Selanjutnya kita dapat menekan tombol `History`:\n",
"\n",
"\n",
"\n",
"\n",
"Pilih salah satu perubahan yang dapat kita lihat, berdasarkan pesan *commit*, inilah alasan mengapa kita harus menuliskan pesan *commit* yang jelas:\n",
"\n",
"\n",
"\n",
"\n",
"Disini dapat dilihat bahwa terdapat perubahan dimana kita menambah beberapa baris yang isinya untuk menambah gambar:\n",
""
]
},
{
"cell_type": "markdown",
"id": "unlike-flashing",
"metadata": {},
"source": [
"## Menambah Notebook ke Binder\n",
"\n",
"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](http://mybinder.org). Salin URL repositori teman-teman, seperti pada gambar di bawah ini:\n",
"\n",
"\n",
"\n",
"Kemudian tempel salinan tadi ke form isian dari MyBinder kemudian tekan `Launch`.\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "cardiovascular-romantic",
"metadata": {},
"source": [
"## Selesai"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.5"
}
},
"nbformat": 4,
"nbformat_minor": 5
}