Python Essentials 2 - Module 4.ipynb

{
 "metadata": {
  "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.8.2-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.8.2 64-bit",
   "metadata": {
    "interpreter": {
     "hash": "965ba1120b0c101b3f715b6e258a73742ec1cf86f2c8b04492724c87d9f112c3"
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# <center> Miscellaneous </center>\n",
    "\n",
    "## OA-DTS Python 2021\n",
    "##### oleh:\n",
    "- Dr. Syukron Abu Ishaq Alfarozi\n",
    "- Wisang Jati Anggoro, S.T.\n",
    "- Netacad\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Materi Modul\n",
    "\n",
    "- Generators, iterators and closures\n",
    "- Working with file-system, directory tree and files\n",
    "- Selected Python Standard Library modules (os, datetime, time, and calendar.)\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## 4.1 Generators, Iterators, Closures\n",
    "- Generator : sepotong kode khusus yang mampu menghasilkan serangkaian nilai, dan untuk mengontrol proses iterasi \n",
    "- Iterator : cara di mana suatu objek harus berperilaku agar sesuai dengan aturan yang diberlakukan oleh konteks pernyataan for dan in (seringkali disamaartikan dengan generator, namun dalam konteks lebih sempit)\n",
    "- closures : membuat fungsi dari fungsi dengan beberapa nilai tersimpan dalam fungsi baru"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### Generator & Iterator"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Fib:\n",
    "\tdef __init__(self, nn):\n",
    "\t\tself.__n = nn\n",
    "\t\tself.__i = 0\n",
    "\t\tself.__p1 = self.__p2 = 1\n",
    "\n",
    "\tdef __iter__(self):\n",
    "\t\tprint(\"Fib iter\")\n",
    "\t\treturn self\n",
    "\n",
    "\tdef __next__(self):\n",
    "\t\tself.__i += 1\n",
    "\t\tif self.__i > self.__n:\n",
    "\t\t\traise StopIteration\n",
    "\t\tif self.__i in [1, 2]:\n",
    "\t\t\treturn 1\n",
    "\t\tret = self.__p1 + self.__p2\n",
    "\t\tself.__p1, self.__p2 = self.__p2, ret\n",
    "\t\treturn ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in Fib(10):\n",
    "\tprint(i)\n",
    "    "
   ]
  },
  {
   "source": [
    "### <code>yield</code> Statement\n",
    "\n",
    "Penggunaan <code>yield</code> menggantikan return pada function mengubah function menjadi generator "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def fun(n):\n",
    "    for i in range(n):\n",
    "        yield i\n",
    "\n",
    "# Lambda\n",
    "# lambda parameters : expression\n",
    "\n",
    "two = lambda : 2\n",
    "sqr = lambda x : x * x\n",
    "pwr = lambda x, y : x ** y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in fun(5):\n",
    "    print(i)\n",
    "\n",
    "for a in range(-2, 3):\n",
    "    print(sqr(a), end=\" \")\n",
    "    print(pwr(a, two()))"
   ]
  },
  {
   "source": [
    "### Build your own generator"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def powers_of_2(n):\n",
    "    power = 1\n",
    "    for i in range(n):\n",
    "        yield power\n",
    "        power *= 2\n",
    "\n",
    "\n",
    "for v in powers_of_2(8):\n",
    "    print(v)"
   ]
  },
  {
   "source": [
    "### List comprehensions"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def powers_of_2(n):\n",
    "    power = 1\n",
    "    for i in range(n):\n",
    "        yield power\n",
    "        power *= 2\n",
    "\n",
    "\n",
    "t = [x for x in powers_of_2(5)]\n",
    "print(t)"
   ]
  },
  {
   "source": [
    "### <code>list()</code> function"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def powers_of_2(n):\n",
    "    power = 1\n",
    "    for i in range(n):\n",
    "        yield power\n",
    "        power *= 2\n",
    "\n",
    "\n",
    "t = list(powers_of_2(3))\n",
    "print(t)"
   ]
  },
  {
   "source": [
    "### The <code>in</code> operator"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def powers_of_2(n):\n",
    "    power = 1\n",
    "    for i in range(n):\n",
    "        yield power\n",
    "        power *= 2\n",
    "\n",
    "\n",
    "for i in range(20):\n",
    "    if i in powers_of_2(4):\n",
    "        print(i)"
   ]
  },
  {
   "source": [
    "### The Fibanacci number generator"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    p = pp = 1\n",
    "    for i in range(n):\n",
    "        if i in [0, 1]:\n",
    "            yield 1\n",
    "        else:\n",
    "            n = p + pp\n",
    "            pp, p = p, n\n",
    "            yield n\n",
    "\n",
    "fibs = list(fibonacci(10))\n",
    "print(fibs)"
   ]
  },
  {
   "source": [
    "### More about list comprehensions\n",
    "\n",
    "a simple and very impressive way of creating lists and their contents."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_1 = []\n",
    "\n",
    "for ex in range(6):\n",
    "    list_1.append(10 ** ex)\n",
    "\n",
    "list_2 = [10 ** ex for ex in range(6)]\n",
    "\n",
    "print(list_1)\n",
    "print(list_2)\n"
   ]
  },
  {
   "source": [
    "### list comprehention with conditional expression"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "the_list = []\n",
    "\n",
    "for x in range(10):\n",
    "    the_list.append(1 if x % 2 == 0 else 0)\n",
    "\n",
    "print(the_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "the_list = [1 if x % 2 == 0 else 0 for x in range(10)]\n",
    "\n",
    "print(the_list)"
   ]
  },
  {
   "source": [
    "### lambda function"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "two = lambda: 2\n",
    "sqr = lambda x: x * x\n",
    "pwr = lambda x, y: x ** y\n",
    "\n",
    "for a in range(-2, 3):\n",
    "    print(sqr(a), end=\" \")\n",
    "    print(pwr(a, two()))"
   ]
  },
  {
   "source": [
    "### Penggunaan lambda function\n",
    "Penggunaan lambda muncul saat Anda dapat menggunakannya dalam bentuk pure - sebagai bagian kode anonim yang dimaksudkan untuk mengevaluasi hasil. "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "def print_function(args, fun):\n",
    "    for x in args:\n",
    "        print('f(', x,')=', fun(x), sep='')\n",
    "\n",
    "\n",
    "def poly(x):\n",
    "    return 2 * x**2 - 4 * x + 2\n",
    "\n",
    "\n",
    "print_function([x for x in range(-2, 3)], poly)"
   ],
   "cell_type": "code",
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "source": [
    "### map & filter"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import seed, randint\n",
    "\n",
    "#map\n",
    "list1 = [x for x in range(5)]\n",
    "list2 = list(map(lambda x: 2 ** x, list1))\n",
    "\n",
    "#filter\n",
    "seed(0)\n",
    "data = [ randint(-10,10) for x in range(5) ]\n",
    "filtered = list(filter(lambda x: x > 0 and x % 2 == 0, data))\n",
    "\n",
    "print(list1)\n",
    "print(list2)\n",
    "print(data)\n",
    "print(filtered)"
   ]
  },
  {
   "source": [
    "### Closure\n",
    "closure adalah teknik yang memungkinkan penyimpanan nilai meskipun pada kenyataannya konteks di mana nilai tersebut dibuat sudah tidak ada lagi.  "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer(par):\r\n",
    "\tloc = par\r\n",
    "\tdef inner():\r\n",
    "\t\treturn loc\r\n",
    "\treturn inner\r\n",
    "\r\n",
    "var = 1\r\n",
    "fun = outer(var)\r\n",
    "print(fun())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_closure(par):\n",
    "    loc = par\n",
    "\n",
    "    def power(p):\n",
    "        return p ** loc\n",
    "    return power\n",
    "\n",
    "\n",
    "fsqr = make_closure(2)\n",
    "fcub = make_closure(3)\n",
    "\n",
    "for i in range(5):\n",
    "    print(i, fsqr(i), fcub(i))"
   ]
  },
  {
   "source": [
    "## 4.2. Files (file streams, file processing, diagnosing stream problems) "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### Accessing files from Python code\n",
    "![files](./asets/files.png)\n",
    "\n",
    "Salah satu masalah paling umum dalam pekerjaan pengembang adalah memproses data yang disimpan dalam file sementara file tersebut biasanya disimpan secara fisik menggunakan perangkat penyimpanan - hard disk, optik, jaringan, atau solid-state.\n",
    "\n",
    "Sangat mudah untuk membayangkan program yang mengurutkan 20 angka, dan sama mudahnya untuk membayangkan pengguna program ini memasukkan dua puluh angka ini langsung dari keyboard.\n",
    "\n",
    "Jauh lebih sulit membayangkan tugas yang sama ketika ada 20.000 nomor yang harus diurutkan, dan tidak ada satu pengguna pun yang dapat memasukkan nomor-nomor ini tanpa membuat kesalahan.\n",
    "\n",
    "Jauh lebih mudah untuk membayangkan bahwa angka-angka ini disimpan dalam file disk yang dibaca oleh program. Program ini mengurutkan nomor dan tidak mengirimkannya ke layar, melainkan membuat file baru dan menyimpan urutan nomor yang diurutkan di sana.\n",
    "\n",
    "Jika kita ingin mengimplementasikan database sederhana, satu-satunya cara untuk menyimpan informasi antar program berjalan adalah dengan menyimpannya ke dalam file (atau banyak file jika database Anda lebih kompleks). \n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "#### Perhatikan filename sesuai dengan OS yang digunkaan\n",
    "![filename](./asets/filename.png)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### FileStream\n",
    "![filestream](./asets/filestream.png)\n",
    "Ada dua operasi dasar yang dilakukan di stream:\n",
    "\n",
    "- membaca dari stream: bagian data diambil dari file dan ditempatkan di area memori yang dikelola oleh program (misalnya, variabel);\n",
    "- menulis/write ke stream: bagian data dari memori (misalnya, variabel) ditransfer ke file.\n",
    "\n",
    "Ada tiga mode dasar yang digunakan untuk membuka stream:\n",
    "\n",
    "- mode baca: stream yang dibuka dalam mode ini memungkinkan operasi baca saja; mencoba menulis ke stream akan menyebabkan pengecualian (pengecualian bernama UnsupportedOperation, yang mewarisi OSError dan ValueError, dan berasal dari modul io);\n",
    "- mode tulis: stream yang dibuka dalam mode ini memungkinkan operasi tulis saja; mencoba membaca stream akan menyebabkan pengecualian yang disebutkan di atas;\n",
    "- mode update: stream yang dibuka dalam mode ini memungkinkan penulisan dan pembacaan. "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### File handles\n",
    "Python mengasumsikan bahwa setiap file tersembunyi di balik objek dengan kelas yang memadai. \n",
    "\n",
    "![iobase](./asets/iobase.png)\n",
    "\n",
    "Untuk tujuan pembelajaran, kita hanya akan memperhatikan stream yang diwakili oleh objek BufferIOBase dan TextIOBase\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### text & biner\n",
    "\n",
    "Aliran teks yang terstruktur dalam baris; artinya, file berisi karakter tipografi (huruf, angka, tanda baca, dll.) yang disusun dalam baris (garis), seperti yang terlihat dengan mata telanjang saat Anda melihat konten file di editor.\n",
    "\n",
    "File ini ditulis (atau dibaca) sebagian besar karakter demi karakter, atau baris demi baris.\n",
    "\n",
    "Aliran biner tidak berisi teks tetapi urutan byte dari nilai apa pun. Urutan ini dapat berupa, misalnya, program yang dapat dijalankan, gambar, audio atau klip video, file database, dll. \n",
    "\n",
    "![filehandle](./asets/filehandle.png)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### open() dan close()"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#buat file pada desktop dengan nama file.txt\n",
    "try:\n",
    "    #sesuaikan dengan direktori dekstop\n",
    "    stream = open(\"C:\\Users\\User\\Desktop\\file.txt\", \"rt\") \n",
    "    # Processing goes here.\n",
    "    stream.close()\n",
    "except Exception as exc:\n",
    "    print(\"Cannot open the file:\", exc)"
   ]
  },
  {
   "source": [
    "\n",
    "### Pre-opened streams\n",
    "\n",
    "Kami mengatakan sebelumnya bahwa operasi aliran apa pun harus didahului oleh pemanggilan fungsi open (). Ada tiga pengecualian yang ditentukan dengan baik untuk aturan tersebut.\n",
    "\n",
    "Saat program kami dimulai, ketiga aliran sudah dibuka dan tidak memerlukan persiapan tambahan. Terlebih lagi, program Anda dapat menggunakan aliran ini secara eksplisit jika Anda berhati-hati dalam mengimpor modul sys: \n",
    "\n",
    "<code> import sys </code>\n",
    "\n",
    "karena di situlah deklarasi tiga aliran ditempatkan.\n",
    "\n",
    "Nama aliran ini adalah: <code>sys.stdin</code>, <code>sys.stdout</code>, dan <code>sys.stderr</code>.\n",
    "\n",
    "Mari kita analisis mereka:\n",
    "\n",
    "- sys.stdin\n",
    "  - stdin (sebagai input standar)\n",
    "  - aliran stdin biasanya dikaitkan dengan keyboard, pra-buka untuk membaca dan dianggap sebagai sumber data utama untuk program yang sedang berjalan;\n",
    "  - fungsi input () yang terkenal membaca data dari stdin secara default.\n",
    "\n",
    "- sys.stdout\n",
    "  - stdout (sebagai keluaran standar)\n",
    "  - aliran stdout biasanya dikaitkan dengan layar, pre-open untuk menulis, dianggap sebagai target utama untuk mengeluarkan data oleh program yang sedang berjalan;\n",
    "  - fungsi print () yang terkenal mengeluarkan data ke stream stdout.\n",
    "\n",
    "- sys.stderr\n",
    "  - stderr (sebagai keluaran kesalahan standar)\n",
    "  - stream stderr biasanya dikaitkan dengan layar, pra-buka untuk menulis, dianggap sebagai tempat utama di mana program yang sedang berjalan harus mengirimkan informasi tentang kesalahan yang ditemui selama bekerja;\n",
    "  - pemisahan stdout (hasil berguna yang dihasilkan oleh program) dari stderr (pesan kesalahan, tidak dapat disangkal berguna tetapi tidak memberikan hasil) memberikan kemungkinan untuk mengarahkan kedua jenis informasi ini ke target yang berbeda. Diskusi yang lebih luas tentang masalah ini berada di luar cakupan kursus. Buku pegangan sistem operasi akan memberikan lebih banyak informasi tentang masalah ini. \n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### Diagnosing stream problems\n",
    "\n",
    "Objek IOError dilengkapi dengan properti bernama errno (nama berasal dari nomor kesalahan frase) dan Anda dapat mengaksesnya sebagai berikut: \n",
    "\n",
    "- errno.EACCES → Permission denied\n",
    "- errno.EBADF → Bad file number\n",
    "- errno.EEXIST → File exists\n",
    "- errno.EFBIG → File too large\n",
    "- errno.EISDIR → Is a directory\n",
    "- errno.EMFILE → Too many open files\n",
    "- errno.ENOENT → No such file or directory\n",
    "- errno.ENOSPC → No space left on device"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    # Some stream operations.\n",
    "    s = open(\"c:/users/user/Desktop/file.txt\", \"rt\")\n",
    "except IOError as exc:\n",
    "    print(exc.errno)"
   ]
  },
  {
   "source": [
    "#### strerror()"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import errno\n",
    "\n",
    "try:\n",
    "    s = open(\"c:/users/user/Desktop/file.txt\", \"rt\")\n",
    "    # Actual processing goes here.\n",
    "    s.close()\n",
    "except Exception as exc:\n",
    "    if exc.errno == errno.ENOENT:\n",
    "        print(\"The file doesn't exist.\")\n",
    "    elif exc.errno == errno.EMFILE:\n",
    "        print(\"You've opened too many files.\")\n",
    "    else:\n",
    "        print(\"The error number is:\", exc.errno)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from os import strerror\n",
    "\n",
    "try:\n",
    "    s = open(\"c:/users/user/Desktop/file.txt\", \"rt\")\n",
    "    # Actual processing goes here.\n",
    "    s.close()\n",
    "except Exception as exc:\n",
    "    print(\"The file could not be opened:\", strerror(exc.errno))"
   ]
  },
  {
   "source": [
    "## 4.3 Working with Real files\n",
    "\n",
    "file mode:\n",
    "\n",
    "\n",
    "\n",
    "|Text mode |\tBinary mode |\tDescription|\n",
    "|-----------|-----------------|-------------|\n",
    "|rt|\trb|\tread|\n",
    "|wt|\twb|\twrite|\n",
    "|at\t|ab\t|append|\n",
    "|r+t|\tr+b|\tread and update|\n",
    "|w+t\t|w+b|\twrite and update|"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### File Methods\n",
    "* Read methods\n",
    "\n",
    "```python\n",
    "stream.read(idx)\n",
    "stream.readline()\n",
    "stream.readlines(n) #multiple lines\n",
    "\n",
    "```\n",
    "\n",
    "* write methods\n",
    "\n",
    "```python\n",
    "stream.write(str)\n",
    "```"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget https://raw.githubusercontent.com/sykrn/py-dts/master/asets/cth.txt\n",
    "\n",
    "# bila tidak bisa, maka gunakan code berikut:\n",
    "# !pip install wget"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stream = open(\"./asets/cth.txt\", \"rt\", encoding = \"utf-8\") # opening tzop.txt in read mode, returning it as a file object\n",
    "print(stream.read())\n",
    "stream.close()"
   ]
  },
  {
   "source": [
    "### read()"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from os import strerror\n",
    "\n",
    "try:\n",
    "    cnt = 0\n",
    "    s = open('./asets/cth.txt', \"rt\")\n",
    "    ch = s.read(1)\n",
    "    while ch != '':\n",
    "        print(ch, end='')\n",
    "        cnt += 1\n",
    "        ch = s.read(1)\n",
    "    s.close()\n",
    "    print(\"\\n\\nCharacters in file:\", cnt)\n",
    "except IOError as e:\n",
    "    print(\"I/O error occurred: \", strerr(e.errno))"
   ]
  },
  {
   "source": [
    "### readline()"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from os import strerror\n",
    "\n",
    "try:\n",
    "    ccnt = lcnt = 0\n",
    "    s = open('./asets/cth.txt', 'rt')\n",
    "    line = s.readline()\n",
    "    while line != '':\n",
    "        lcnt += 1\n",
    "        for ch in line:\n",
    "            print(ch, end='')\n",
    "            ccnt += 1\n",
    "        line = s.readline()\n",
    "    s.close()\n",
    "    print(\"\\n\\nCharacters in file:\", ccnt)\n",
    "    print(\"Lines in file:     \", lcnt)\n",
    "except IOError as e:\n",
    "    print(\"I/O error occurred:\", strerror(e.errno))"
   ]
  },
  {
   "source": [
    "### readlines()"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from os import strerror\n",
    "\n",
    "try:\n",
    "    ccnt = lcnt = 0\n",
    "    s = open('./asets/cth.txt', 'rt')\n",
    "    lines = s.readlines(20)\n",
    "    while len(lines) != 0:\n",
    "        for line in lines:\n",
    "            lcnt += 1\n",
    "            for ch in line:\n",
    "                print(ch, end='')\n",
    "                ccnt += 1\n",
    "        lines = s.readlines(10)\n",
    "    s.close()\n",
    "    print(\"\\n\\nCharacters in file:\", ccnt)\n",
    "    print(\"Lines in file:     \", lcnt)\n",
    "except IOError as e:\n",
    "    print(\"I/O error occurred:\", strerror(e.errno))\n"
   ]
  },
  {
   "source": [
    "### Write"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from os import strerror\n",
    "\n",
    "try:\n",
    "\tfo = open('newtext.txt', 'wt')\n",
    "\tfor i in range(10):\n",
    "\t\tfo.write(\"line #\" + str(i+1) + \"\\n\")\n",
    "\tfo.close()\n",
    "except IOError as e:\n",
    "\tprint(\"I/O error occurred: \", strerr(e.errno))"
   ]
  },
  {
   "source": [
    "### bytesarray"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = bytearray(10)\n",
    "\n",
    "for i in range(len(data)):\n",
    "    data[i] = 10 - i\n",
    "\n",
    "for b in data:\n",
    "    print(hex(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write\n",
    "from os import strerror\n",
    "\n",
    "data = bytearray(10)\n",
    "\n",
    "for i in range(len(data)):\n",
    "    data[i] = 10 + i\n",
    "\n",
    "try:\n",
    "    bf = open('file.bin', 'wb')\n",
    "    bf.write(data)\n",
    "    bf.close()\n",
    "except IOError as e:\n",
    "    print(\"I/O error occurred:\", strerr(e.errno))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#read and write / copy paste script\n",
    "from os import strerror\n",
    "\n",
    "srcname = input(\"Source file name?: \")\n",
    "try:\n",
    "    src = open(srcname, 'rb')\n",
    "except IOError as e:\n",
    "    print(\"Cannot open source file: \", strerror(e.errno))\n",
    "    exit(e.errno)\t\n",
    "dstname = input(\"Destination file name?: \")\n",
    "try:\n",
    "    dst = open(dstname, 'wb')\n",
    "except Exception as e:\n",
    "    print(\"Cannot create destination file: \", strerr(e.errno))\n",
    "    src.close()\n",
    "    exit(e.errno)\t\n",
    "\n",
    "buffer = bytearray(65536)\n",
    "total  = 0\n",
    "try:\n",
    "    readin = src.readinto(buffer)\n",
    "    while readin > 0:\n",
    "        written = dst.write(buffer[:readin])\n",
    "        total += written\n",
    "        readin = src.readinto(buffer)\n",
    "except IOError as e:\n",
    "    print(\"Cannot create destination file: \", strerr(e.errno))\n",
    "    exit(e.errno)\t\n",
    "    \n",
    "print(total,'byte(s) succesfully written')\n",
    "src.close()\n",
    "dst.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "source": [
    "##  4.4 The <code>os</code> module\n",
    "![osmodule](./asets/osmodule.png)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### osname"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "print(os.name)"
   ]
  },
  {
   "source": [
    "### mkdir\n",
    "make directory - create folder"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "os.makedirs(\"my_first_directory/my_second_directory\")\n",
    "os.chdir(\"my_first_directory\")\n",
    "print(os.listdir())"
   ]
  },
  {
   "source": [
    "### pwd\n",
    "where am I now? - get current directory"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "os.makedirs(\"my_first_directory/my_second_directory\")\n",
    "os.chdir(\"my_first_directory\")\n",
    "print(os.getcwd())\n",
    "os.chdir(\"my_second_directory\")\n",
    "print(os.getcwd())"
   ]
  },
  {
   "source": [
    "### rmdir\n",
    "remove directory - delete folder"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "os.mkdir(\"my_first_directory\")\n",
    "print(os.listdir())\n",
    "os.rmdir(\"my_first_directory\")\n",
    "print(os.listdir())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "returned_value = os.system(\"mkdir my_first_directory\")\n",
    "print(returned_value)"
   ]
  },
  {
   "source": [
    "## 4.5 <code>datetime</code> and <code>time</code> Module\n",
    "![datetime](./asets/pydatetime.png)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date, time as dtime, datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "today = date.today()\n",
    "\n",
    "print(\"Today:\", today)\n",
    "print(\"Year:\", today.year)\n",
    "print(\"Month:\", today.month)\n",
    "print(\"Day:\", today.day)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timestamp = time.time()\n",
    "print(\"Timestamp:\", timestamp)\n",
    "\n",
    "d = date.fromtimestamp(timestamp)\n",
    "print(\"Date:\", d)\n"
   ]
  },
  {
   "source": [
    "### ISO format"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = date.fromisoformat('2019-11-04')\n",
    "print(d)\n"
   ]
  },
  {
   "source": [
    "### Replace Method"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = date(1991, 2, 5)\n",
    "print(d)\n",
    "\n",
    "d = d.replace(year=1992, month=1, day=16)\n",
    "print(d)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = date(2019, 11, 4)\n",
    "print(d.weekday())"
   ]
  },
  {
   "source": [
    "### Creating time object"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "t = dtime(14, 53, 20, 1)\n",
    "\n",
    "print(\"Time:\", t)\n",
    "print(\"Hour:\", t.hour)\n",
    "print(\"Minute:\", t.minute)\n",
    "print(\"Second:\", t.second)\n",
    "print(\"Microsecond:\", t.microsecond)\n"
   ]
  },
  {
   "source": [
    "### Time Module"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "class Student:\n",
    "    def take_nap(self, seconds):\n",
    "        print(\"I'm very tired. I have to take a nap. See you later.\")\n",
    "        time.sleep(seconds)\n",
    "        print(\"I slept well! I feel great!\")\n",
    "\n",
    "student = Student()\n",
    "student.take_nap(5)\n"
   ]
  },
  {
   "source": [
    "### ctime() function"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timestamp = 1572879180\n",
    "print(time.ctime(timestamp))"
   ]
  },
  {
   "source": [
    "### gmtime() and localtime()"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "timestamp = 1572879180\n",
    "print(time.gmtime(timestamp))\n",
    "print(time.localtime(timestamp))\n"
   ]
  },
  {
   "source": [
    "### asctime() and mktime()"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "timestamp = 1572879180\n",
    "st = time.gmtime(timestamp)\n",
    "\n",
    "print(time.asctime(st))\n",
    "print(time.mktime((2019, 11, 4, 14, 53, 0, 0, 308, 0)))\n"
   ]
  },
  {
   "source": [
    "### Creating datetime objects"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt = datetime(2019, 11, 4, 14, 53)\n",
    "\n",
    "print(\"Datetime:\", dt)\n",
    "print(\"Date:\", dt.date())\n",
    "print(\"Time:\", dt.time())"
   ]
  },
  {
   "source": [
    "### Methods that return the current date and time"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"today:\", datetime.today())\n",
    "print(\"now:\", datetime.now())\n",
    "print(\"utcnow:\", datetime.utcnow())"
   ]
  },
  {
   "source": [
    "### Getting a timestamp"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt = datetime(2020, 10, 4, 14, 55)\n",
    "print(\"Timestamp:\", dt.timestamp())"
   ]
  },
  {
   "source": [
    "### datetime formatting"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "d = date(2020, 1, 4)\n",
    "print(d.strftime('%Y/%m/%d'))\n",
    "\n",
    "t = dtime(14, 53)\n",
    "print(t.strftime(\"%H:%M:%S\"))\n",
    "\n",
    "dt = datetime(2020, 11, 4, 14, 53)\n",
    "print(dt.strftime(\"%y/%B/%d %H:%M:%S\"))\n"
   ]
  },
  {
   "source": [
    "### strftime() function"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timestamp = 1572879180\n",
    "st = time.gmtime(timestamp)\n",
    "\n",
    "print(time.strftime(\"%Y/%m/%d %H:%M:%S\", st))\n",
    "print(time.strftime(\"%Y/%m/%d %H:%M:%S\"))"
   ]
  },
  {
   "source": [
    "### The strptime() method"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "print(datetime.strptime(\"2019/11/04 14:53:00\", \"%Y/%m/%d %H:%M:%S\"))"
   ]
  },
  {
   "source": [
    "### Date and time operations"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "d1 = date(2020, 11, 4)\n",
    "d2 = date(2019, 11, 4)\n",
    "\n",
    "print(d1 - d2)\n",
    "\n",
    "dt1 = datetime(2020, 11, 4, 0, 0, 0)\n",
    "dt2 = datetime(2019, 11, 4, 14, 53, 0)\n",
    "\n",
    "print(dt1 - dt2)"
   ]
  },
  {
   "source": [
    "### Creating timedelta objects"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import timedelta\n",
    "\n",
    "delta = timedelta(weeks=2, days=2, hours=3)\n",
    "print(delta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = timedelta(weeks=2, days=2, hours=2)\n",
    "print(delta)\n",
    "\n",
    "delta2 = delta * 2\n",
    "print(delta2)\n",
    "\n",
    "d = date(2019, 10, 4) + delta2\n",
    "print(d)\n",
    "\n",
    "dt = datetime(2019, 10, 4, 14, 53) + delta2\n",
    "print(dt)"
   ]
  },
  {
   "source": [
    "## 2.6 <code>calendar</code> module\n",
    "![pycalendar](./asets/pycalendar.png)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import calendar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(calendar.calendar(2020))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(calendar.month(2020, 11))"
   ]
  },
  {
   "source": [
    "### setfirstweekday function"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "calendar.setfirstweekday(calendar.SUNDAY)\n",
    "calendar.prmonth(2020, 12)"
   ]
  },
  {
   "source": [
    "### The weekday() function\n",
    "![day](./asets/pycalendar2.png)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(calendar.weekday(2020, 12, 24))"
   ]
  },
  {
   "source": [
    "### The weekheader function"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(calendar.weekheader(2))\n",
    "print(calendar.weekheader(3))"
   ]
  },
  {
   "source": [
    "### leapday / leapyear - kabisat\n",
    "leapday = 29 Feb (pada tahun kabisat)\n",
    "\n",
    "![leap](./asets/leapyear.png)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(calendar.isleap(2020))\n",
    "print(calendar.leapdays(2010, 2021))  # Up to but not including 2021."
   ]
  },
  {
   "source": [
    "### Creating calendar object"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = calendar.Calendar(calendar.SUNDAY)\n",
    "\n",
    "for weekday in c.iterweekdays():\n",
    "    print(weekday, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = calendar.Calendar()\n",
    "\n",
    "for date in c.itermonthdates(2019, 11):\n",
    "    print(date, end=\" \")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = calendar.Calendar()\n",
    "\n",
    "for iter in c.itermonthdays(2019, 11):\n",
    "    print(iter, end=\" \")"
   ]
  },
  {
   "source": [
    "### The monthdays2calendar() method"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = calendar.Calendar()\n",
    "\n",
    "for data in c.monthdays2calendar(2020, 12):\n",
    "    print(data)"
   ]
  }
 ]
}