Modul_6_OOP_and_file_operation.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "celltoolbar": "Slideshow",
    "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.7.4"
    },
    "rise": {
      "auto_select": "none",
      "auto_select_fragment": false,
      "scroll": true,
      "theme": "serif",
      "width": "90%"
    },
    "colab": {
      "name": "Python OOP .ipynb",
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/sykrn/py-dts/blob/master/Modul_6_OOP_and_file_operation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v1glAk2VJek9",
        "colab_type": "text"
      },
      "source": [
        "# <center> Pemrograman Berbasis Obyek </center>\n",
        "\n",
        "<br/>\n",
        "<br/>\n",
        "<br/>\n",
        "\n",
        "\n",
        "\n",
        "## OA-DTS Python 2020\n",
        "#### Dr. Syukron Abu Ishaq Alfarozi\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8b2SFmZUJek_",
        "colab_type": "text"
      },
      "source": [
        "# Pemrograman Berbasis Obyek (PBO) a.k.a. OOP\n",
        "\n",
        "Konsep dari OOP dalam python ini berfokus dalam pembuatan kode yang reusable (dapat digunakan kembali). Konsep ini juga dikenal dengan DRY (Don't Repeat Yourself).\n",
        "\n",
        "Dalam python, konsep OOP memiliki beberapa prinsip dasar:\n",
        "\n",
        "| Sifat   | Deskripsi   |\n",
        "|---------------|---------------------------------------------------------------------------------|\n",
        "| Inheritance   | Proses dalam menggunakan atribut dan behaviour dari class yang telah ada sebelumnya.   |\n",
        "| Encapsulation* | Menyembunyikan atribut dan behavior yang bersifat private dari kelas lainnya.                  |\n",
        "| Polymorphism*  | Sebuah konsep untuk menggunakan operasi yang sama dengan cara yang berbeda pada kelas lain. |\n",
        "\n",
        "Konsep ini akan terlihat lebih mudah dalam prakteknya nanti"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZbSOm3mhJelB",
        "colab_type": "text"
      },
      "source": [
        "## Function vs Method\n",
        "\n",
        "* Fungsi : Sebuah prosedur untuk mengolah masukan menjadi keluaran.\n",
        "* Method : Sebuah fungsi yang menempel di suatu Object yang bisa (tidak harus) merubah object tersebut.\n",
        "\n",
        "### Coba perhatikan contoh di bawah ini:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WXJXNTWkJelC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ls = [3,2,1,4,5,7,8,0]\n",
        "print('ls terurut\\t:',sorted(ls))\n",
        "print('ls tidak urut\\t:', ls)\n",
        "\n",
        "ls2 = [3,2,1,4,5,7,8,0]\n",
        "ls2.sort()\n",
        "print('ls2 terutut\\t:',ls2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Re058XbIJelH",
        "colab_type": "text"
      },
      "source": [
        "## Class and Inheritance\n",
        "\n",
        "Class adalah sebuah blueprint/konsep dari suatu objek.\n",
        "![class1.JPG](https://github.com/sykrn/py-dts/blob/master/class1.JPG?raw=1)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "cell_style": "split",
        "id": "q6LFiqjqJelJ",
        "colab_type": "text"
      },
      "source": [
        "### Inheritance (Pewarisan sifat)\n",
        "\n",
        "* `superclass/Parent` lebih bersifat umum dari pada `subclass`.\n",
        "* `subclass` mewarisi sifat dari `superclass/Parent` \n",
        "\n",
        "![class2.JPG](https://github.com/sykrn/py-dts/blob/master/class2.JPG?raw=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "cell_style": "split",
        "id": "fu9rAwT-JelK",
        "colab_type": "text"
      },
      "source": [
        "<br/>\n",
        "<br/>\n",
        "<br/>\n",
        "\n",
        "\n",
        "![inheritance.JPG](https://github.com/sykrn/py-dts/blob/master/inheritance.JPG?raw=1)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "5gmFkM38JelL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Contoh pendifinisian class\n",
        "\n",
        "class Hewan:\n",
        "    def __init__(self,nama):\n",
        "        self.nama = nama\n",
        "    def gerak(self):\n",
        "        print('gerak-gerak!!!')\n",
        "\n",
        "class HewanDarat(Hewan):\n",
        "    def __init__(self,nama,kaki=0):\n",
        "        super().__init__(nama)     # Inheritence\n",
        "        self.kaki = kaki         # properti/sifat baru\n",
        "        \n",
        "    def gerak(self):             # Polymorphism\n",
        "        print(self.nama,'gerak di darat dengan kaki',self.kaki)\n",
        "\n",
        "class HewanAir(Hewan):\n",
        "    def __init__(self,nama,sirip='kecil'):\n",
        "        super().__init__(nama)     # Inheritence\n",
        "        self.sirip = sirip       # properti/sifat baru\n",
        "        \n",
        "    def gerak(self):             # Polymorphism\n",
        "        print(self.nama,'gerak di air dengan sirip', self.sirip)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "9NembN9UJelP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "hewan = Hewan('pokoknya hewan')\n",
        "kambing = HewanDarat('kambing',kaki=4)\n",
        "hiu = HewanAir('hiu',sirip='lebar')\n",
        "\n",
        "hewan.gerak()\n",
        "kambing.gerak()\n",
        "hiu.gerak()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y2P7fZUyJelS",
        "colab_type": "text"
      },
      "source": [
        "## Enkapsulasi\n",
        "\n",
        "Menyembunyikan atribut dan behavior yang bersifat private dari kelas lainnya.\n",
        "Enkapsulasi di python sangat sederhana, menyembunyikan atribut (tidak sepenuhnya) yaitu dengan menggunakan `__` (dua garis bawah) di awal penamaan atribut.\n",
        "\n",
        "> Di bahasa pemrograman yang lain mungkin anda akan menemukan hal yang lebih kompleks, cth: `public`,`virtual`, `private`, `protected`.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "B0e6TwquJelT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "stack = []\n",
        "\n",
        "def push(val):\n",
        "    stack.append(val)\n",
        "\n",
        "\n",
        "def pop():\n",
        "    val = stack[-1]\n",
        "    del stack[-1]\n",
        "    return val\n",
        "\n",
        "push(3)\n",
        "push(2)\n",
        "push(1)\n",
        "\n",
        "print(pop())\n",
        "print(pop())\n",
        "print(pop())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "hxevKJydJelW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Stack:\n",
        "    def __init__(self):\n",
        "        self.stackList = []\n",
        "\n",
        "stackObject = Stack()\n",
        "print(len(stackObject.stackList))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "N0IggmFVJela",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Stack:\n",
        "    def __init__(self):\n",
        "        self.__stackList = [] # __ membuat private\n",
        "\n",
        "stackObject = Stack()\n",
        "print(len(stackObject.__stackList))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "_2AIqa50Jele",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Stack:\n",
        "    def __init__(self):\n",
        "        self.__stackList = []\n",
        "\n",
        "    def push(self, val):\n",
        "        self.__stackList.append(val)\n",
        "\n",
        "    def pop(self):\n",
        "        val = self.__stackList[-1]\n",
        "        del self.__stackList[-1]\n",
        "        return val\n",
        "\n",
        "littleStack = Stack()\n",
        "anotherStack = Stack()\n",
        "funnyStack = Stack()\n",
        "\n",
        "littleStack.push(1)\n",
        "anotherStack.push(littleStack.pop() + 1)\n",
        "funnyStack.push(anotherStack.pop() - 2)\n",
        "\n",
        "print(funnyStack.pop()) "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "XrDxE2ZeJelh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class AddingStack(Stack):\n",
        "    def __init__(self):\n",
        "        Stack.__init__(self)\n",
        "        self.__sum = 0\n",
        "\n",
        "    def getSum(self):\n",
        "        return self.__sum\n",
        "\n",
        "    def push(self, val):\n",
        "        self.__sum += val\n",
        "        Stack.push(self, val)\n",
        "\n",
        "    def pop(self):\n",
        "        val = Stack.pop(self)\n",
        "        self.__sum -= val\n",
        "        return val\n",
        "\n",
        "\n",
        "stackObject = AddingStack()\n",
        "\n",
        "for i in range(5):\n",
        "    stackObject.push(i)\n",
        "print(stackObject.getSum())\n",
        "\n",
        "for i in range(5):\n",
        "    print(stackObject.pop())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "cell_style": "split",
        "id": "q9ij6A4oJelj",
        "colab_type": "text"
      },
      "source": [
        "### Properties and method:\n",
        "```python\n",
        "cls.__dict__\n",
        "cls.__name__\n",
        "cls.__module__\n",
        "hasattr(cls,'str')\n",
        "getattr(cls, 'str')\n",
        "setattr(cls,'str')\n",
        "cls is cls\n",
        "issubclass(ClassOne, ClassTwo)\n",
        "isinstance(objectName, ClassName)\n",
        "cls.__str__() \n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "2vgeLlOFJelj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Let's code\n",
        "# Python is hackable"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vhc4wBzAJelm",
        "colab_type": "text"
      },
      "source": [
        "## Multiple Inheritance"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lz1Hso6hJelm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Left:\n",
        "    var = \"L\"\n",
        "    varLeft = \"LL\"\n",
        "    def fun(self):\n",
        "        return \"Left\"\n",
        "\n",
        "\n",
        "class Right:\n",
        "    var = \"R\"\n",
        "    varRight = \"RR\"\n",
        "    def fun(self):\n",
        "        return \"Right\"\n",
        "\n",
        "class Sub(Left, Right):\n",
        "    pass\n",
        "\n",
        "\n",
        "obj = Sub()\n",
        "\n",
        "print(obj.var, obj.varLeft, obj.varRight, obj.fun())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "plh19QJ3Jelo",
        "colab_type": "text"
      },
      "source": [
        "## Exception again"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "fNu-nWx4Jelp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def reciprocal(n):\n",
        "    try:\n",
        "        n = 1 / n\n",
        "    except ZeroDivisionError:\n",
        "        print(\"Division failed\")\n",
        "        n = None\n",
        "    else:\n",
        "        print(\"Everything went fine\")\n",
        "    finally:\n",
        "        print(\"It's time to say goodbye\")\n",
        "        return n\n",
        "\n",
        "print(reciprocal(2))\n",
        "print(reciprocal(0))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "XgkMMSnpJelr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "try:\n",
        "    i = int(\"Hello!\")\n",
        "except Exception as e:\n",
        "    print(e)\n",
        "    print(e.__str__())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_mJWYItaJelt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def printExcTree(thisclass, nest = 0):\n",
        "    if nest > 1:\n",
        "        print(\"   |\" * (nest - 1), end=\"\")\n",
        "    if nest > 0:\n",
        "        print(\"   +---\", end=\"\")\n",
        "\n",
        "    print(thisclass.__name__)\n",
        "\n",
        "    for subclass in thisclass.__subclasses__():\n",
        "        printExcTree(subclass, nest + 1)\n",
        "\n",
        "printExcTree(BaseException)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ix4CfK2AJelv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "try:\n",
        "\traise Exception(\"my exception\")\n",
        "except Exception as e:\n",
        "\tprint(e, e.__str__(), sep=' : ', end=' : ')\n",
        "\tprint(e.args)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-wrpvpD4Jely",
        "colab_type": "text"
      },
      "source": [
        "## Generator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "wminT93KJely",
        "colab_type": "code",
        "colab": {}
      },
      "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\n",
        "\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "XClbZp4UJel0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "for i in Fib(10):\n",
        "\tprint(i)\n",
        "    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "XYrIC3TVJel4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Yield\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"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "QRHB3hidJel7",
        "colab_type": "code",
        "colab": {}
      },
      "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()))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "sfe_C8VnJel-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Map and filter\n",
        "\n",
        "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"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "split",
        "id": "WTLbsO9zJemA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(list1)\n",
        "print(list2)\n",
        "print(data)\n",
        "print(filtered)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8hJwC66nJemC",
        "colab_type": "text"
      },
      "source": [
        "## Closure\n",
        "Let's start with a definition: closure is a technique which allows the storing of values in spite of the fact that the context in which they have been created does not exist anymore. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PacwmzpFJemD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def outer(par):\n",
        "\tloc = par\n",
        "\tdef inner():\n",
        "\t\treturn loc\n",
        "\treturn inner\n",
        "\n",
        "var = 1\n",
        "fun = outer(var)\n",
        "print(fun())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O-iSAmWFJemG",
        "colab_type": "text"
      },
      "source": [
        "## Partial functional tools"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qQ9qrrM5JemG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from functools import partial \n",
        "\n",
        "# A normal function \n",
        "def f(a, b, c, x): \n",
        "    return 1000*a + 100*b + 10*c + x \n",
        "  \n",
        "# A partial function that calls f with \n",
        "# a as 3, b as 1 and c as 4. \n",
        "g = partial(f, 3, 1, 4) \n",
        "  \n",
        "# Calling g() \n",
        "print(g(5)) "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "cell_style": "split",
        "id": "5n2YcXh4JemJ",
        "colab_type": "text"
      },
      "source": [
        "## Working with 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": {
        "cell_style": "split",
        "id": "fmu_f6WlJemJ",
        "colab_type": "text"
      },
      "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": "code",
      "metadata": {
        "id": "8nDtGUlkLICa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!wget  https://raw.githubusercontent.com/sykrn/py-dts/master/asets/cth.txt"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cell_style": "center",
        "id": "84MLw5XpJemK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "stream = open(\"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()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rkoRstgPJemO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Read\n",
        "from os import strerror\n",
        "\n",
        "try:\n",
        "    cnt = 0\n",
        "    s = open('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))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uJ4zN-d4JemS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Write\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))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dyDIw_j8JemU",
        "colab_type": "text"
      },
      "source": [
        "### bytesarray\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pgoCtQ5jJemV",
        "colab_type": "code",
        "colab": {}
      },
      "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))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UZNZ94_XJemZ",
        "colab_type": "code",
        "colab": {}
      },
      "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"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DXEzFsRvJemc",
        "colab_type": "code",
        "colab": {}
      },
      "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()"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}