7-modules-packages-pip.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modules, Packages and PIP\n",
    "\n",
    "module = file python berisi definisi dan statemen yang bisa diimport dan dipakai kemudian jika membutuhkan.\n",
    "\n",
    "module dikenali dr namanya. jika kamu ingin menggunakan modul, perlu diketahui namanya. sejumlah module biasanya sudah sepaket dengan python itu sendiri. hal tsb biasa disebut \"peralatan ekstra python\"\n",
    "\n",
    "beberapa module, bersama-sama dengan fungsi built-in, membentuk librari standar python (kumpulan librari spesial dimana modules berperan sebagai buku). untuk melihat daftar lengkap semua koleksi librari, dapat mengakses disini : https://docs.python.org/3/library/index.html\n",
    "\n",
    "setiap modul terdiri dari entiti layaknya buku berisi beberapa bab. entiti bs terdiri dari fungsi, variabel, konstanta, klas atau objek. jika mengetahui cara mengakses module yang diinginkan, kita dapat menggunakan semua entiti yang disimpan."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mengimport Module\n",
    "\n",
    "untuk membuat module dapat digunakan, kita harus melakukan import pada module tsb. Mengimport module menggunakan instruksi(keyword) bernama \"import\".\n",
    "\n",
    "contoh cara mengimport module bernama math :\n",
    "\n",
    "```\n",
    "import math\n",
    "```\n",
    "atau mengimport beberapa module :\n",
    "\n",
    "```\n",
    "import math\n",
    "import sys\n",
    "```\n",
    "atau :\n",
    "```\n",
    "import math, sys\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Namespace\n",
    "\n",
    "adalah space yang berisi nama serta tidak konflik satu sama lain. namespace adalah unik, dan keunikan tsb bisa berasal dari nickname yang diambil dari nama pertama atau dari spesial identitas. contoh namespace seperti saat melakukan import module math yang berisi entiti pi\n",
    "\n",
    "import math pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "print(math.sin(math.pi/2))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import Module (2)\n",
    "\n",
    "cara kedua adalah dengan mengimport secara tepat entiti dari suatu module menggunakan keyword \"from\" dan \"import\"\n",
    "\n",
    "```\n",
    "from math import pi\n",
    "```\n",
    "\n",
    "contoh import lainnya:\n",
    "\n",
    "```\n",
    "\n",
    "from math import sin, pi\n",
    "\n",
    "print(sin(pi/2))\n",
    "```\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import Module (3)\n",
    "\n",
    "cara ketiga adalah dengan metode brutal yaitu:\n",
    "\n",
    "from math import *\n",
    "\n",
    "\"*\" dikenal dengan istilah wild card, digunakan utk mengimport semua entiti pada module"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Membuat Alias\n",
    "\n",
    "kita juga dapat mengganti nama sementara dari module agar dapat digunakan lebih ringkas yaitu menggunakan keyword \"as\".  contoh :\n",
    "\n",
    "```\n",
    "import math as ma\n",
    "print(ma.sin(ma.pi/2))\n",
    "```\n",
    "\n",
    "atau juga kita bs melakukan alias pada entiti. contoh :\n",
    "\n",
    "```\n",
    "from math import pi as phi, sin as s1n\n",
    "\n",
    "print(s1n(phi/2)\n",
    "```\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "fungsi dir()\n",
    "\n",
    "dir() digunakan utk melihat nama entiti di dalam sebuah modul.\n",
    "cara mengecek isian module dengan dir() adalah sbb:\n",
    "\n",
    "import math\n",
    "for entiti in dir(math):\n",
    "    print(entiti, end=\"\\t\")\n",
    "\n",
    "\n",
    "output :\n",
    "\n",
    "__doc__\t__file__\t__loader__\t__name__\t__package__\t__spec__\tacos\tacosh\tasin\tasinh\tatan\tatan2\tatanh\tceil\tcomb\tcopysign\tcos\tcosh\tdegrees\tdist\te\terf\terfc\texp\texpm1\tfabs\tfactorial\tfloor\tfmod\tfrexp\tfsum\tgamma\tgcd\thypot\tinf\tisclose\tisfinite\tisinf\tisnan\tisqrt\tldexp\tlgamma\tlog\tlog10\tlog1p\tlog2\tmodf\tnan\tperm\tpi\tpow\tprod\tradians\tremainder\tsin\tsinh\tsqrt\ttan\ttanh\ttau\ttrunc\t\n",
    "\n",
    "\n",
    "atau kita juga bisa langsung melakukan dir (module) di IDLE python secara langsung utk melihat entiti pada module tsb. tetapi jangan lupa module nya diimport dulu\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "module yang cukup penting yaitu modul bernama random. modul ini memungkinkan untuk mengoperasikan nomor (pseudo) random. Makna pseudo bermakna bahwa modul ini sekilas terlihat menghasilkan keacakan sehingga anda tidak dapat memprediksinya. Faktanya, modul ini melakukan perhitungan dengan algoritma yang sangat halus.\n",
    "\n",
    "generator angka acak menggunakan nilai yang disebut seed, lalu menjadikannya sbg inputan lalu memproses angka \"acak\" berdasarkan algoritma halus tersebut lalu menghasilkan seed yang baru.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7837985890347726\n",
      "0.30331272607892745\n",
      "0.4765969541523558\n",
      "0.5833820394550312\n",
      "0.9081128851953352\n",
      " --------------\n",
      "0.8444218515250481\n",
      "0.7579544029403025\n",
      "0.420571580830845\n",
      "0.25891675029296335\n",
      "0.5112747213686085\n"
     ]
    }
   ],
   "source": [
    "# menghasilkan angka random\n",
    "\n",
    "from random import random\n",
    "for i in range(5):\n",
    "    print(random()) # sintak sama dijalankan di client yang berbeda hasilnya pasti beda\n",
    "    \n",
    "# atau menggunakan entiti seed()\n",
    "print(\" --------------\")\n",
    "from random import seed\n",
    "\n",
    "seed(0)\n",
    "\n",
    "for i in range(5):\n",
    "    print(random()) # sintak sama dijalankan di client yang berbeda hasilnya SAMA !\n",
    "    \n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lingkungan Komputer kita\n",
    "\n",
    "berikut laayer dari pemrograman :\n",
    "\n",
    "kode\n",
    "-\n",
    "python\n",
    "-\n",
    "Operating System(linux)\n",
    "-\n",
    "hardware\n",
    "\n",
    "\n",
    "Module \"platform\"\n",
    "\n",
    "- modul ini memungkinkan kita utk akses data yang mendasari platform kita seperti OS, atau interpreter version.\n",
    "\n",
    "silahkan run snippet berikut:\n",
    "\n",
    "from platform import platform\n",
    "print(platform())\n",
    "print(platform(1))\n",
    "print(platform(0,1))\n",
    "\n",
    "- gunakan fungsi machine utk melihat nama prosesor kita\n",
    "\n",
    "from platform import machine\n",
    "print(machine())\n",
    "\n",
    "- gunakan fungsi processor() utk cek nama prosesor\n",
    "\n",
    "from platform import processor as proc\n",
    "\n",
    "print(proc())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linux-6.1.0-8-amd64-x86_64-with-glibc2.36\n",
      "Linux-6.1.0-8-amd64-x86_64-with-glibc2.36\n",
      "Linux-6.1.0-8-amd64-x86_64-with-glibc2.36\n",
      "---------------\n",
      "x86_64\n",
      "-------\n",
      "\n",
      "Linux\n",
      "-------  ---------\n",
      "#1 SMP PREEMPT_DYNAMIC Debian 6.1.25-1 (2023-04-22)\n",
      "versi\n",
      "CPython\n",
      "('3', '11', '2')\n"
     ]
    }
   ],
   "source": [
    "from platform import platform\n",
    "\n",
    "print(platform())\n",
    "print(platform(1))\n",
    "print(platform(0,1))\n",
    "\n",
    "print(\"---------------\")\n",
    "\n",
    "from platform import machine #cek jenis proc\n",
    "\n",
    "print(machine())\n",
    "\n",
    "print(\"-------\")\n",
    "\n",
    "from platform import processor\n",
    "print(processor()) # cek nama asli prosesor jika available\n",
    "\n",
    "from platform import system\n",
    "\n",
    "print(system()) # jenis sistem generik nya\n",
    "\n",
    "print(\"-------  ---------\")\n",
    "\n",
    "from platform import version #cek versi OS\n",
    "\n",
    "print(version())\n",
    "print(\"versi\")\n",
    "\n",
    "# cek implementasi python (dalam hal ini kita pake CPython)\n",
    "from platform import python_implementation\n",
    "print(python_implementation())\n",
    "\n",
    "# cek versi python yang sedang digunakan\n",
    "from platform import python_version_tuple\n",
    "print(python_version_tuple()) #3.11.2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "untuk melihat betapa bejibunnya modul python, cek link berikut:\n",
    "\n",
    "https://docs.python.org/3/py-modindex.html\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Package (Paket)\n",
    "\n",
    "package berisi module, module berisi kumpulan fungsi"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bikin module\n",
    "\n",
    "1. buat file misal dengan nama moodol.py\n",
    "2. isikan berikut :\n",
    "\n",
    "print(\"saya adalah module sederhana\")\n",
    "\n",
    "3. buatkan main.py lalu import moodol diatas dengan snipet berikut:\n",
    "\n",
    "```\n",
    "import moodol.py\n",
    "\n",
    "```\n",
    "\n",
    "4. jalankan main.py lewat terminal dg cara:\n",
    "\n",
    "python3 main.py\n",
    "\n",
    "yang terjadi, setelah berhasil run hasil import, di folder yang sama dg projek, terdapat folder yang otomatis dibuat oleh python bernama _pycache_ berisi file moodol.cpython-311.pyc\n",
    "\n",
    "file ini adalah file hasil kompile yg siap dijalankan komputer.\n",
    "\n",
    "5. Python dapat melakukan lebih. Python juga membuat var yang disebut __name__ . Tiap file source menggunakan var diatas masing-masing. file tsb tidak dishare diantara modul2 lainnya. coba modif file moodol.py seperti berikut:\n",
    "\n",
    "``` \n",
    "print(\" I like to be a module\")\n",
    "print(__name__)\n",
    "```\n",
    "\n",
    "lalu jalankan main.py\n",
    "\n",
    "hasilnya :\n",
    "\n",
    "- kalau jalankan langsung dari moodol.py,  __name__ tercetak menjadi __main__\n",
    "\n",
    "- kalau jalankan via main.py, variabel __name__ akan mencetak nama modulnya dalam hal ini adalah moodol"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "misalkan kita meletakkan counter = 0 di dalam moodol.py\n",
    "\n",
    "``` \n",
    "counter = 0\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    print(\"I prefer to be a module.\")\n",
    "else:\n",
    "    print(\"I like to be a module.\")\n",
    "    \n",
    "```\n",
    "\n",
    "lalu kita akses melalui main.py dengan menambahkan snipet berikut:\n",
    "\n",
    "```\n",
    "print(modool.counter) #akses variable counter di moodol\n",
    "```\n",
    "output : 0\n",
    "\n",
    "main.py dapat mengakses variabel didalam moodol. maka dari itu, hal ini akan terselesaikan jika kita menamai var kita dengan\n",
    "\n",
    "__namaVar__ agar menjadi var private alias tidak bs diakses oleh file lainnya. namun harap diingat, ini hanya sebuah kesepakatan bersama, bisa saja tidak dipatuhi oleh si pembuat modul.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "mari kita tulis lagi sebuah kode di dalam moodol.py\n",
    "\n",
    "```\n",
    "#!/usr/bin/env python3 \n",
    "\n",
    "\"\"\" module.py - an example of a Python module \"\"\"\n",
    "\n",
    "__counter = 0\n",
    "\n",
    "\n",
    "def suml(the_list):\n",
    "    global __counter\n",
    "    __counter += 1\n",
    "    the_sum = 0\n",
    "    for element in the_list:\n",
    "        the_sum += element\n",
    "    return the_sum\n",
    "\n",
    "\n",
    "def prodl(the_list):\n",
    "    global __counter    \n",
    "    __counter += 1\n",
    "    prod = 1\n",
    "    for element in the_list:\n",
    "        prod *= element\n",
    "    return prod\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    print(\"I prefer to be a module, but I can do some tests for you.\")\n",
    "    my_list = [i+1 for i in range(5)]\n",
    "    print(suml(my_list) == 15)\n",
    "    print(prodl(my_list) == 120)\n",
    "\n",
    "\n",
    "```\n",
    "\n",
    "penjelasan kode diatas :\n",
    "\n",
    "- awal kode dimulai dengan #!, disebut sebagai hashbang, shebang. kode ini sebenarnya tidak berpengaruh apa apa. namun dibeberapa environment web server, tidak adanya kode ini akan menyebabkan masalah\n",
    "\n",
    "- baris komen selanjutnya sebelum _counter adalah doc-string. berfungsi sebagai penjelas maksud dan isian dari module\n",
    "- menggunakan __name__ utk mendeteksi kapan file dijalankan sendiri\n",
    "\n",
    "lalu, import module serta fungsi2 lainnya ke main.py"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Selama ini, dibahasan sebelumnya Kita asumsikan bahwa main.py file ada di lokasi yang sama dengan direktori folder module yang terimpor di main.py\n",
    "\n",
    "mari kita coba sesuatu yang lebih sulit. \n",
    "\n",
    "asumsinya, kita menggunakan windows, lalu script main.py ada di c:\\Users\\user\\py\\progs dan module ada di C:\\Users\\user\\py\\modules\n",
    "\n",
    "bagaimana cara python mencari modul tsb ?\n",
    "\n",
    "Ada variabel spesial yang menyimpan semua lokasifolder dan direktori untuk mencari dimana modul yang diminta.\n",
    "\n",
    "Python mencari folder tsb yang ter-list di dalam sebuah daftar. Jika modul tsb tidak bs ditemukan, maka import nya gagal.\n",
    "\n",
    "variabel bernama pathm dapat diakses dari modul sys. ini adalah cara anda dapat mengecek nilai regulernya.\n",
    "\n",
    "```\n",
    "import sys\n",
    "for p in sys.path:\n",
    "print(p)\n",
    "\n",
    "```\n",
    "nb : kita berhasil me-run kode di dalam folder usr/lib, usr/local dan home\n",
    "\n",
    "file zip yang ada di dalam elemen,  itu bukan sebuah error. python memperlakukan file zip seperti folder biasa. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/x260/Documents/belajarpython-cisco\n",
      "/usr/lib/python311.zip\n",
      "/usr/lib/python3.11\n",
      "/usr/lib/python3.11/lib-dynload\n",
      "\n",
      "/usr/local/lib/python3.11/dist-packages\n",
      "/usr/lib/python3/dist-packages\n",
      "/usr/lib/python3.11/dist-packages\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "for p in sys.path:\n",
    "    print(p)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Untuk menambah folder ke dalam path variabel, kita dapat melakukan cara sbb:\n",
    "\n",
    "```\n",
    "from sys import path\n",
    "\n",
    "path.append('..\\\\modules')\n",
    "\n",
    "import module\n",
    "\n",
    "zeroes = [0 for i in range(5)]\n",
    "ones = [1 for i in range(5)]\n",
    "print(module.suml(zeroes))\n",
    "print(module.prodl(ones))\n",
    "\n",
    "```\n",
    "nb : teknik path diatas menggunakan cara relative path. lebih amannya dapat menggunakan absolute path seperti C:\\\\Users\\\\user\\\\py\\\\modules\n",
    "\n",
    "append adalah metode utk menambah path yang akan ditambah di akhir list. jika kita tidak mau menambah path di dalam list dalam urutan terakhir, maka gunakan metod insert()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "bayangkan anda dan tim membuat kumpulan fungsi. Tim memutuskan utk memisahkan fungsi per module seperti ini\n",
    "\n",
    "- alpha.py\n",
    "- beta.py\n",
    "- iota.py\n",
    "- sigma.py\n",
    "- tau.py\n",
    "- psi.py\n",
    "- omega.py\n",
    "\n",
    "dengan isi modul alpa.py :\n",
    "\n",
    "```\n",
    "#! /usr/bin/env python3\n",
    "\n",
    "\"\"\" module : alpha \"\"\"\n",
    "\n",
    "def funA():\n",
    "    return \"Alpha\"\n",
    "\n",
    "    if __name__ == \" __main__\":\n",
    "        print (\"i prefer to be a module\")\n",
    "```\n",
    "\n",
    "isi beta.py :\n",
    "\n",
    "```\n",
    "def funB(): ...\n",
    "```\n",
    "dsb...\n",
    "\n",
    "meletakkan kumpulan module pada struktur yang flat adalah bukan ide yang baik. Tim akhirnya setuju dengan ide bahwa seharusnya mereka membuat struktur fungsi dan module dengan hubungan relasi (directory structure). misalkan sbb :\n",
    "\n",
    "misal fungsi2 dan module tsb ada di 1 folder besar bernama ekstra\n",
    "\n",
    "lalu berisi file dengan rincian:\n",
    "\n",
    "1. file iota.py\n",
    "2. 1 folder bernama good berisi alpha.py, beta.py, dan 1 folder bernama best. folder best berisi sigma.py dan tau.py\n",
    "3. folder ugly berisi omega.py dan psi.py\n",
    "\n",
    "sturktur ini diterapkan di sebagian besar paket yang ada.\n",
    "\n",
    "\n",
    "misalkan, kita ingin mengakses fungsi bernama funT(), dari package bernama tau. lokasi file tsb adalah sbb:\n",
    "\n",
    "```\n",
    "extra.good.best.tau.funT()\n",
    "\n",
    "```\n",
    "atau coba memanggil fungsi funP() dr modul psi.py\n",
    "\n",
    "```\n",
    "extra.ugly.psi.funP()\n",
    "\n",
    "```\n",
    "\n",
    "lokasi path tree tsb agar dikenali oleh python sebagai package, harus diinisialisasi terlebih dahulu. python expect jika ada file yang unik didalam package tsb, yaitu __init__.py\n",
    "\n",
    "nb : kehadiran file __init__.py menyebabkan package dikenali."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "misalkan, kita ingin mengakses funI() dari iota module. cara memanggilnya adalah :\n",
    "\n",
    "```\n",
    "from sys import path\n",
    "\n",
    "path.append('..\\\\packages')\n",
    "\n",
    "import extra.iota\n",
    "\n",
    "print(extra.iota.funI())\n",
    "\n",
    "```\n",
    "nb: kita sudah memodif path variable agar dapat diakses python\n",
    "import tidak langsung merujuk ke module, tetapi merujuk ke path dari atas package\n",
    "\n",
    "mengganti import extra.iota dengan import iota akan menyebabkan error\n",
    "\n",
    "atau dengan cara lainnya yaitu :\n",
    "\n",
    "```\n",
    "from sys import path\n",
    "\n",
    "path.append('..\\\\packages')\n",
    "\n",
    "from extra.iota import funI\n",
    "print(funI())\n",
    "\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "begini cara kita akses sigma dan tau modules\n",
    "\n",
    "```\n",
    "from sys import path\n",
    "\n",
    "path.append('..\\\\packages')\n",
    "\n",
    "import extra.good.best.sigma\n",
    "from extra.good.best.tau import funT\n",
    "\n",
    "print(extra.good.best.sigma.funS())\n",
    "print(funT())\n",
    "\n",
    "```\n",
    "atau anda bisa pake aliasing\n",
    "\n",
    "```\n",
    "from sys import path\n",
    "path.append('..\\\\packages')\n",
    "\n",
    "import extra.good.best.sigma as sig\n",
    "import extra.good.alpha as alp\n",
    "\n",
    "print(sig.funS())\n",
    "print(alp.funA())\n",
    "\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "asumsikan bahwa kita men-zip semua subdirektori dari ekstra folder. mari kita namakan extrapack.zip\n",
    "\n",
    "sekarang kita masukkan file didalam folder packages\n",
    "\n",
    "```\n",
    "from sys import path\n",
    "\n",
    "path.append('..\\\\packages\\\\extrapack.zip')\n",
    "\n",
    "import extra.good.best.sigma as sig\n",
    "import extra.good.alpha as alp\n",
    "from extra.iota import funI\n",
    "from extra.good.beta import funB\n",
    "\n",
    "print(sig.funS())\n",
    "print(alp.fungA())\n",
    "print(funI())\n",
    "print(funB())\n",
    "\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "beberapa tambahan :\n",
    "\n",
    "- jika kamu ingin mencegah modul menjalankan kodemu , lakukan berikut:\n",
    "```\n",
    "  import sys\n",
    "  if __name__ == \"__main__\":\n",
    "    print \"dont do that!\"\n",
    "    sys.exit()\n",
    "```\n",
    "\n",
    "- misalkan beberapa tambahan package disimpan di D:\\Python\\Project\\Modules \n",
    "tuliskan kode agar python dapat mencari semua module tsb\n",
    "\n",
    "```\n",
    "import sys\n",
    "\n",
    "sys.path.append(\"D:\\\\Python\\\\Project\\\\Modules\")\n",
    "\n",
    "```\n",
    "misalkan direktori terdiri dari 3 sub struktur seperti ini\n",
    "\n",
    "abc\n",
    "    |- def\n",
    "        |- mymodule.py\n",
    "\n",
    "asumsi misal D:\\Python\\Project\\Modules ditambahkan ke sys.path\n",
    "menulis snippet import ke mymodule.py adalah dengan cara\n",
    "\n",
    "```\n",
    "import abc.def.mymodule\n",
    "\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ekosistem package Python dan cara menggunakannya\n",
    "\n",
    "repository untuk python yang berisi kumpulan module adalah PyPI (python package index).\n",
    "utk alamat sitenya di :\n",
    "\n",
    "https://pypi.org/\n",
    "\n",
    "PyPI bukanlah satu satunya repo yang ada. meskipun begitu, PyPI adalah repo terpenting yang ada di dunia saat ini."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dependencies\n",
    "\n",
    "dependencies adalah isu terpenting.\n",
    "dependencies adalah fenomena ketika sebuah software bergantung pada software yang lain.\n",
    "perlu diingat bahwa, dependensi mungkin saja berisi lebih dari 1 level pengembangan software.\n",
    "\n",
    "apakah artinya bahwa calon pengguna package xxx wajib utk melacak semua dependensi dan secara manual menginstal semua package? seremm\n",
    "\n",
    "dan hal seperti ini disebut sebagai dependency hell\n",
    "\n",
    "untungnya kita sangat terbantu dengan -pip. pip akan menyelesaikan pekerjaan tsb untuk kita, dari melacak, mencari dan memasang dependensi. selain itu, pip dapat menghindari penginstalan yang ganda dan tidak perlu terhadap package tersebut."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PIP\n",
    "\n",
    "saatnya menggunakan pip, namun kita perlu tau command apa saja yang dimiliki oleh pip\n",
    "\n",
    "~~~\n",
    "pip help\n",
    "~~~\n",
    "1. command diatas akan mencetak semua command yang bisa dipakai dalam pip\n",
    "\n",
    "\n",
    "~~~\n",
    "pip list\n",
    "~~~\n",
    "2. command tsb mencetak package apa saja yang sudah terinstal di hardware kita.\n",
    "\n",
    "\n",
    "~~~\n",
    "pip show (nama-package)\n",
    "~~~\n",
    "3. command utk melihat informasi paket, seperti versi, summary, pembuatna, alamat web dan dependensinya\n",
    "\n",
    "\n",
    "dan masih banyak lagi command yng dapat digunakan.\n",
    "utk melihat informasi lebih lengkap tentang package tertentu, cek disini:\n",
    "\n",
    "https://pypi.org/search/\n",
    "\n",
    "\n",
    "~~~\n",
    "pip install -U (package-name)\n",
    "~~~\n",
    "4. utk menginstal update package ke versi terbaru. atau kita juga bs meng-install ke versi tertentu\n",
    "   ~~~\n",
    "    pip install (package-name)==versi\n",
    "\n",
    "    contoh:\n",
    "\n",
    "    pip install pygame==1.9.2\n",
    "   ~~~"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.11.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}