phisan_sookkhee_python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMceTvUxgrvXEyKne4FRte7",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/numvarn/PythonProgramming/blob/master/phisan_sookkhee_python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# การเขียนโปรแกรมด้วยภาษาไพธอน 3\n",
        "\n",
        "<pre>โดย\n",
        "ผู้ช่วยศาสตาราจารย์พิศาล สุขขี\n",
        "สาขาวิทยาการคอมพิวเตอร์,\n",
        "มหาวิทยาลัยราชภัฏศรีสะเกษ\n",
        "\n",
        "E-mail : phisan.s@sskru.ac.th, phisan.shukkhi@gmail.com\n",
        "Website : http://phisan.sskru.ac.th\n",
        "Facebook : www.facebook/numvarn\n",
        "Skype : phisan.shukkhi\n",
        "Mobile Phone: 084-915-2456\n",
        "</pre>"
      ],
      "metadata": {
        "id": "CK-tiyEIioU9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# พื้นฐานโปรแกรมภาษาไพธอน\n"
      ],
      "metadata": {
        "id": "VC8fQCvhYJKb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>\n",
        "บทเรียนนี้จะอธิบายถึงพื้นฐานของโปรแกรมภาษาไพธอน ซึ่งประกอบไปด้วยไวยากรณ์โครงสร้างของโปรแกรม ข้อควรจำที่สำคัญในการใช้ไวยากรณ์ของภาษาไพธอน คำสั่งในการรับข้อมูลเข้าและการแสดผล\n",
        "\n",
        "เนื้อหาในบทเรียนนี้จะเป็นส่วนความรู้เบื้องต้นที่ทำให้สามารถเขียนโปรแกรมภาษาไพธอนอย่างง่ายได้ ตลอดจนวิธีการรันโปรแกรมที่เขียนด้วยภาษาไพธอน โดยใช้โปรแกรมแปลภาษาไพธอนทั้งในโหมดโต้ตอบและโหมดสคริปต์"
      ],
      "metadata": {
        "id": "84H7iC6wY19q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Identifiers\n"
      ],
      "metadata": {
        "id": "pYB7Sz85ZTdG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# ชื่อคลาส\n",
        "class GetData:\n",
        "    pass\n",
        "\n",
        "# ชื่อฟังก์ชัน\n",
        "def getData():\n",
        "    pass\n",
        "\n",
        "def studentName():\n",
        "    pass\n",
        "\n",
        "# ชื่อตัวแปร\n",
        "data = 1\n",
        "student_name = \"Phisan Sookkhee\"\n",
        "my_input = 0\n",
        "my_input_number = 0"
      ],
      "metadata": {
        "id": "15vVDNhEYP7Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<pre>\n",
        "#ตัวแปร\n",
        "my_student\n",
        "\n",
        "#ฟังก์ชัน\n",
        "myStudent\n",
        "\n",
        "#คลาส\n",
        "MyStudent</pre>"
      ],
      "metadata": {
        "id": "olBwXtHTZzHM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<pre>\n",
        "#คลาส\n",
        "PrintHelloWorld()\n",
        "\n",
        "#ฟังก์ชัน\n",
        "printHelloWorld()\n",
        "\n",
        "#ตัวแปร\n",
        "print_hello_world</pre>"
      ],
      "metadata": {
        "id": "SXb-T_KNZ_dS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "yqCGRV2yh94V"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## บรรทัดและการเยื้องหน้า (Lines and Indentation)\n",
        "\n",
        "ไพธอนไม่ใช้วงเล็บการเพื่อบ่งบอกถึงบล็อกของโค้ดสำหรับนิยามคลาส และฟังก์ชัน\n",
        "\n",
        "หรือคำสั่งโครงสร้างควบคุม บล็อกของโค้ดจะแสดงด้วยการเว้นบรรทัดพร้อมเยื้องหน้า ซึ่งในภาษาไพธอนมีการบังคับใช้อย่างเข้มงวด\n",
        "\n",
        "จำนวนของการเว้นวรรคในการเยื้องหน้าสำหรับคำสั่งทั้งหมดภายในบล็อกจะต้องทำการเว้นวรรคด้วยจำนวนหรือขนาดที่เท่ากันทั้งหมด ตัวอย่างเช่น"
      ],
      "metadata": {
        "id": "rhyHdmipbKiv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "if(True) {\n",
        "    i = 1; x = 2;\n",
        "} else {\n",
        "    statement\n",
        "}\n",
        "'''\n",
        "\n",
        "if True:\n",
        "    print(\"Answer\")\n",
        "    print(\"True\")\n",
        "else:\n",
        "    print(\"Answer\")\n",
        "    print(\"False\")"
      ],
      "metadata": {
        "id": "BEmuKvdRay4l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "while True:\n",
        "    value = input(\"Please enter a value: \")\n",
        "    if value == \"quit\":\n",
        "        break\n",
        "    elif int(value) < 10:\n",
        "        print(\"Small\")\n",
        "    else:\n",
        "        print(value)"
      ],
      "metadata": {
        "id": "gBga7TIcZ0CT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "AavrQSaNiAnr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##การแสดงคําสั่งหลายบรรทัด (Multi-Line Statements)"
      ],
      "metadata": {
        "id": "cLFVGVh8cGrD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "total = 1 + 2 + 3\n",
        "\n",
        "print(total)"
      ],
      "metadata": {
        "id": "M5_QbjqKcCDv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "total = 1 + \\\n",
        "        2 + \\\n",
        "        3\n",
        "\n",
        "print(total)"
      ],
      "metadata": {
        "id": "XE5YOA0mcNVK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "UeL2KfIEiEzU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## การใช้เครื่องหมายคําพูดในภาษาไพธอน (Quotation in Python)"
      ],
      "metadata": {
        "id": "PGWpbdFGcQtg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "word = 'word'"
      ],
      "metadata": {
        "id": "cygHJjakcPvu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sentence = \"This is a sentence.\""
      ],
      "metadata": {
        "id": "OZG6mjNNcX8I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "paragraph = \"\"\"This is a paragraph.\n",
        "\n",
        "It is made up of multiple lines and sentences.\"\"\""
      ],
      "metadata": {
        "id": "tWoNvek5cZag"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(paragraph)"
      ],
      "metadata": {
        "id": "Ys_4I2NVca6D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "T4Kqc5dziLIH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## คําอธิบายโปรแกรม (Comment)"
      ],
      "metadata": {
        "id": "jFGxDojzcq05"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "name = '''Phisan\n",
        "Sookkhee\n",
        "'''\n",
        "\n",
        "print(name)"
      ],
      "metadata": {
        "id": "rFH9ZgGUcsWr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# This is line comment\n",
        "a = 10 # This is line comment"
      ],
      "metadata": {
        "id": "OLUGkJHqcuS6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "This is block comment that\n",
        "Convers two lines.\n",
        "'''\n",
        "\n",
        "a = 10\n",
        "print(a)"
      ],
      "metadata": {
        "id": "qBycc4mvcvzn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "qlCsHSraiNR2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## หลายคําสั่งภายในบรรทัดเดียว (Multiple Statements on a Single Line)\n",
        "\n",
        "ผู้เขียนโปรแกรมสามารถใชBเครื่องหมายเซมิโคลอน (“ ; ”) เพื่อคัดระหว่างคําสั่งที่อยู่ภายใน บรรทัดเดียวกันได้ ดังแสดงในตัวอย่าง"
      ],
      "metadata": {
        "id": "kSRvDQXcc0AL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import sys; x = 'Python'; print(\"{} \\n\".format(x))"
      ],
      "metadata": {
        "id": "TqFJIb2Vcx5F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import sys\n",
        "\n",
        "x = 'Python'\n",
        "\n",
        "print(\"{} \\n\".format(x))"
      ],
      "metadata": {
        "id": "DmfePbX5c558"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "w2HgLKSmiQ8s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## บรรทัดว่าง (Blank lines)\n",
        "บรรทัดที่มีเพียงแค่ช่องว่างเพียงอย่างเดียว หรืออาจมีเพียงคำอธิบายโปรแกรม จะถูกเรียกว่าเป็นบรรทัดว่าง (Blank lines) และตัวแปลภาษาไพธอนจะไม่สนใจบรรทัดว่างเหล่านี้\n",
        "\n",
        "ในการเขียนโปรแกรมภายในโค้ดที่เราสร้างขึ้นจะสังเกตุเห็นว่า สามารถมีบรรทัดว่างได้ทั่วไปตลอดทั้งโค้ดโปรแกรม และในการแปลภาษาตัวแปรภาษาจะไม่นำบรรทัดว่างเหล่านี้ไปตีความ"
      ],
      "metadata": {
        "id": "f-DMxKLvc82X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Hello world\")\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "print(\"Hello, Phisan Sookkhee\")"
      ],
      "metadata": {
        "id": "tVJIGRpzddlN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "qxuMn_59iSfd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## การรับข้อมูลเข้าและการแสดงผล\n",
        "\n",
        "การรับข้อมูลจาก keyboard ด้วยฟังก์ชัน input()"
      ],
      "metadata": {
        "id": "Q0ckW2BvdTa2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "name = input(\"What's your name? \")\n",
        "\n",
        "print(\"Nice to meet you \" + name + \"!\")"
      ],
      "metadata": {
        "id": "tz2NoMzOc7fJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "age = input(\"Your age? \")\n",
        "\n",
        "print(\"So, you are already \" + age +\" years old, \" + name + \"!\")"
      ],
      "metadata": {
        "id": "wt6sWv40d7jY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "number = input(\"Enter your number : \")\n",
        "\n",
        "result = int(number) - 2\n",
        "\n",
        "print(result)"
      ],
      "metadata": {
        "id": "U9ThH6l_dszB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "3NESkZjkiT61"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## การแสดงผล\n",
        "\n",
        "การใช้ Formatters Formatters ทำงานโดยการใส่ฟิลด์ที่ใช้แทนข้อมูล หรือตัวยึดตำแหน่ง (Placeholder)\n",
        "\n",
        "อย่างน้อยหนึ่งฟิลด์ซึ่งถูกกำหนดโดยใช้วงเล็บปีกกา (“ { } ”) ลงในสตริงและเรียกใช้เมธอด format() ซึ่งทำการนำค่าที่เราต้องการไปทำการใส่เข้าไปในสตริง\n",
        "\n",
        "ค่านี้จะถูกส่งผ่านไปในตำแหน่งเดียวกับที่ตัวยึดตำแหน่งอยู่ในตำแหน่งที่กำหนดไว้เมื่อมีการเรียกใช้โปรแกรม ดังตัวอย่างด้านล่างนี้"
      ],
      "metadata": {
        "id": "BI0FlVhIeVWx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "msg = \"Phisan \" + \"Sookkhee \" + str(5)\n",
        "print(msg)"
      ],
      "metadata": {
        "id": "968PUkBneXmk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "number = 5\n",
        "\n",
        "msg = \"Sammy has \"+ str(number) +\" dogs\"\n",
        "print(msg)"
      ],
      "metadata": {
        "id": "uMCi6_naecka"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "number = 5\n",
        "\n",
        "msg = \"Sammy has {} dogs\".format(number)\n",
        "print(msg)"
      ],
      "metadata": {
        "id": "-98iokraee3A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "cat = 10\n",
        "dog = 5\n",
        "\n",
        "msg = \"Sammy has {} dogs and {} cats\".format(dog, cat)\n",
        "print(msg)"
      ],
      "metadata": {
        "id": "qdWxKdZXeil1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "open_string = \"Sammy loves {}.\"\n",
        "print(open_string.format(\"open source\"))"
      ],
      "metadata": {
        "id": "4i5dSooeey76"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "msg = \"Hello, my name is {} {}\"\n",
        "\n",
        "name = input(\"Enter name : \")\n",
        "lastname = input(\"Enter lastname : \")\n",
        "\n",
        "print(msg.format(name, lastname))"
      ],
      "metadata": {
        "id": "Taq6Uym0ey66"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "msg = \"Sammy loves {}\".format(\"open source\")\n",
        "print(msg)"
      ],
      "metadata": {
        "id": "dNqbAKEbe4Fm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "การใช้ Formatters กับตัวยึดตำแหน่งหลายตัว\n",
        "เราสามารถใช้เครื่องหมายวงเล็บปีกกาหลายคู่เมื่อใช้ formatters ถ้าเราต้องการเพิ่มการแทนที่ตัวแปรอื่นในสตริง\n",
        "เราสามารถทำได้โดยการเพิ่มคู่วงเล็บปีกกาที่สอง และส่งค่าที่สองเข้าไปใน เมธอดโดยการคั่นด้วยเครื่องหมายจุลภาค (“ , ”)\n",
        "\"\"\"\n",
        "\n",
        "new_open_string = \"Sammy loves {} {}.\"\n",
        "print(new_open_string.format(\"open-source\", \"software\"))"
      ],
      "metadata": {
        "id": "NPF7fK-Ae46M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "จัดลำดับการแสดงผลด้วยอาร์กิวเมนต์ตำแหน่งและคำหลัก\n",
        "เมื่อเราใช้เครื่องหมายวงเล็บปีกกาโดยไม่มีพารามิเตอร์ใด ๆ ภายใน\n",
        "ไพธอนจะแทนที่ค่าที่โดยส่งผ่านเมธอด format() ตามลำดับ ตามที่เราได้เห็นแล้วจากตัวอย่างข้างต้นที่ผ่านมา โดยการสร้างแบบฟอร์มที่มีวงเล็บปีกกาสองวงที่ว่างเปล่ามีสองค่าที่ผ่านมาจะมีลักษณะดังนี้\n",
        "\"\"\"\n",
        "\n",
        "print(\"Sammy the {} has a pet {}!\".format(\"shark\", \"pilot fish\"))\n",
        "\n",
        "# หรือ\n",
        "print(\"Sammy the {1} has a pet {0}!\".format(\"shark\", \"pilot fish\"))\n",
        "\n",
        "\n",
        "# หรือ\n",
        "print(\"Sammy is a {3}, {2}, and {1} {0}!\".format(\"happy\",\n",
        "                                                 \"smiling\",\n",
        "                                                 \"blue\",\n",
        "                                                 \"shark\"))\n",
        "\n",
        "# หรือ\n",
        "print(\"Sammy the {s} {m} a {pr}.\".format(s=\"shark\",\n",
        "                                         m=\"made\",\n",
        "                                         pr=\"pull request\"))"
      ],
      "metadata": {
        "id": "rsza9rSqe7zC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "usdjmGIiiWzV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## การแสดงผลโดยใช้ตัวแปลงข้อมูล\n",
        "\n",
        "ภายในวงเล็บปีกกาที่เราใช้เป็นตัวยึดตำแหน่งภายในสตริงนั้น สามารถมีพารามิเตอร์ ได้มากกว่า 1 ตัว โดยเราจะใช้ไวยากรณ์แบบ {field_name:conversion} โดยที่ field_name จะระบุหมายเลขดัชนีของอาร์กิวเมนต์จากเมธอด format() ที่เราดำเนินการในส่วนการจัดเรียงลำดับ และ conversion หมายถึงรหัสการแปลงรูปแบบของข้อมูลที่เราใช้กับตัวจัดรูปแบบ\n",
        "\n",
        "ประเภทการแปลงรูปแบบหมายถึงรหัสอักขระเดี่ยวที่ภาษาไพธอนใช้ โดยจะใช้ s เป็นรหัสสำหรับสตริง และ d เพื่อแสดงจำนวนเต็มทศนิยม (10 ฐาน) และ f ซึ่งเราจะใช้เพื่อแสดงทศนิยมที่มีจุดทศนิยม เป็นต้น โดยตัวอย่างต่อไปนี้เป็นตัวอย่างที่เราจะทำการส่งค่าจำนวนเต็มผ่านเมธอด เพื่อต้องการแสดงผลเป็นจำนวนจริง หรือ float ซึ่งทำได้โดยการเพิ่มอาร์กิวเมนต์ประเภท Conversion f เข้าไปในตัวยึดตำแหน่งภายในสตริง"
      ],
      "metadata": {
        "id": "RElWvFQEfKrz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pi = 3.145456678893837\n",
        "print(\"pi : {0:.3f}\".format(pi))"
      ],
      "metadata": {
        "id": "P6dz86oVe-Ii"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Sammy ate {0:f} percent of a {1}!\".format(75, \"pizza\"))\n",
        "\n",
        "print(\"Sammy ate {0:.2f} percent of a {1}!\".format(75, \"pizza\"))\n",
        "\n",
        "print(\"Sammy ate {0:.0f} percent of a {1}!\".format(75.0789, \"pizza\"))"
      ],
      "metadata": {
        "id": "rpPi2X_nfRPL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "JoX8AUg1iZVg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## การกำหนดขนาดของฟิลด์"
      ],
      "metadata": {
        "id": "NFSeD-ihfb8R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Sammy has {0:8} red {1:16}!\".format(5, \"balloons\"))"
      ],
      "metadata": {
        "id": "O0BpDJmlfTad"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Sammy has {0:^8.2f} red {1:>16}!\".format(5, \"balloons\"))"
      ],
      "metadata": {
        "id": "YQueHCwefha7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# < ชิดซ้าย\n",
        "# > ชิดขวา\n",
        "# ^ กึ่งกลาง\n",
        "print(\"Sammy has {0:<4} red {1:>16}!\".format(5, \"balloons\"))"
      ],
      "metadata": {
        "id": "CXGIlJsAfjN6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "โดยค่าเริ่มต้นเมื่อเราสร้างฟิลด์ขนาดใหญ่ขึ้นด้วย formatters ไพธอนจะเติมฟิลด์ด้วยอักขระเว้นวรรค\n",
        "แต่เราสามารถปรับเปลี่ยนจากอักขระเว้นวรรคให้เป็นอักขระอื่น ๆ ตามที่เราต้องการได้\n",
        "โดยใส่อักขระที่เราต้องการไว้หลังเครื่องหมายโคลอน (“ : ”) ดังตัวอย่าง\n",
        "\"\"\"\n",
        "\n",
        "print(\"{0:_^20s}\".format(\"Sammy\"))"
      ],
      "metadata": {
        "id": "BXru9bFeflA1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "nR5FvsuPiath"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## แบบฝึกหัด\n",
        "\n",
        "เรื่องพื้นฐานโปรแกรมภาษาไพธอน"
      ],
      "metadata": {
        "id": "zQrPgD_AgKdu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. จงเขียนโปรแกรมไพธอนเพื่อรับข้อมูล ที่เป็นชื่อผู้ใช้งานจากแป้นพิมพ์และแสดงออกทางหน้าจอ"
      ],
      "metadata": {
        "id": "-OQZLtI_gY5K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# พิมพ์โค้ดโปรแกรมด้านล่างนี้\n",
        "\n"
      ],
      "metadata": {
        "id": "r0clwQFwfmcX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. จงเขียนโปรแกรมเพื่อแสดงค่าของ pi คือ 3.14159 ออกทางหน้าจอโดยทำการกำหนดรูปแบบในการแสดงผล\n",
        "\n",
        "ดังต่อไปนี้\n",
        "<pre>pi = 3\n",
        "pi = 3.14\n",
        "pi = 3.1416</pre>"
      ],
      "metadata": {
        "id": "iyObsoaKgfuW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# พิมพ์โค้ดโปรแกรมด้านล่างนี้\n",
        "\n"
      ],
      "metadata": {
        "id": "_Irl4t2bgerU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. จงเขียนโปรแกรมที่แสดงคำว่า \"dog\", \"cat\", \"bat\" ออกทางหน้าจอ โดยกำหนดรูปแบบในการแสดงดังต่อไปนี้"
      ],
      "metadata": {
        "id": "aw1YJTMWg1tr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "```\n",
        "|dog       |   cat    |       bat|\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "_a9Alhi2g9nT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# พิมพ์โค้ดโปรแกรมด้านล่างนี้\n",
        "\n"
      ],
      "metadata": {
        "id": "PMGd8glPhCpl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "4. จงเขียนโปรแกรมที่แสดงคำว่า \"dog\", \"cat\", \"bat\" ออกทางหน้าจอ โดยกำหนดรูปแบบในการแสดงดังต่อไปนี้"
      ],
      "metadata": {
        "id": "0af-yEnEhLz3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "```\n",
        "|dog*******|***cat****|*******bat|\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "n6a1mFzhhRuW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# พิมพ์โค้ดโปรแกรมด้านล่างนี้\n",
        "\n"
      ],
      "metadata": {
        "id": "-In8BBsthd_h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "cYKfecVPgfHA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# ตัวแปรและประเภทข้อมูล\n",
        "\n",
        "\n",
        "\n",
        "<pre>\n",
        "หน่วยการเรียนนี้ ผู้เรียนจะได้เรียนรู้เกี่ยวกับตัวแปรและประข้อมูลในภาษา Python\n",
        "\n",
        "เนื้อหาประกอบไปด้วย\n",
        "1. ตัวแปรและการประกาศค่า\n",
        "2. การตั้งชื่อตัวแปรในภาษาไพธอน\n",
        "3. การกำหนดค่าให้กับตัวแปร\n",
        "4. ชนิดข้อมูลพื้นฐาน\n",
        "  a. ตัวเลข\n",
        "  b. สตริง\n",
        "5. ชนิดข้อมูลเชิงประกอบ\n",
        "  a. ลิสต์\n",
        "  b. ทัพเพิล\n",
        "  c. ดึกชันนารี\n",
        "  d. เซต\n",
        "</pre>\n",
        "\n"
      ],
      "metadata": {
        "id": "ly8YDhXXjYgg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## ตัวแปร และการประกาศค่า\n",
        "\n",
        "**ตัวแปร (Variable)** คือ ชื่อ หรือเครื่องหมายที่ถูกกำหนดขึ้นสำหรับใช้อ้างอิงถึงข้อมูลที่ถูกจัดเก็บเอาไว้ในหน่วยความจำ\n",
        "\n",
        "**ตัวแปรจะมีชื่อ (Identifier)** สำหรับใช้ในการอ้างถึงข้อมูล ในการเขียนโปรแกรม ค่าของตัวแปรสามารถที่จะกำหนดได้ใน Run-Time หรือเปลี่ยนแปลงอยู่ตลอดเวลาในขณะที่โปรแกรมทำงาน (Executing)\n",
        "\n",
        "และเพื่อความสะดวกในการนำเอาค่าข้อมูลที่จัดเก็บไว้ในหน่วยความจำเพื่อการประมวลผลภายในโปรแกรม โดยการอ้างอิงผ่านตัวแปรนั้น ป้ายชื่อที่เราใช้เรียกตัวแปรภายในโปรแกรมนั้น ควรเป็นชื่อที่สื่อความหมายซึ่จะทำให้ทั้งโปรแกรมและผู้ผ่าน รวมทั้งตัวผู้พัฒนาโปรแกรมเองสามารถเข้าใจได้ง่าย\n",
        "\n",
        "ในการเขียนโปรแกรมคอมพิวเตอร์ ตัวแปรจะแตกต่างจากตัวแปรในทางคณิตศาสตร์ ค่าของตัวแปรนั้นไม่จำเป็นต้องประกอบไปด้วยสูตรหรือสมการที่สมบูรณ์เหมือนกับในคณิตศาสตร์\n",
        "\n",
        "และในคอมพิวเตอร์นั้น ตัวแปรอาจจะมีการทำงานซ้ำ ๆ เช่น การกำหนดค่าในที่หนึ่ง และนำไปใช้อีกที่หนึ่งในโปรแกรม และนอกจากนี้ยังสามารถกำหนดค่าใหม่ให้กับตัวแปรได้ตลอดเวลา"
      ],
      "metadata": {
        "id": "bqgXr1jckoyX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "5G_oOCOolxmB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## การประกาศค่าตัวแปร\n",
        "\n",
        "การประกาศค่าตัวแปรในภาษาไพธอนสามารถทำได้โดยการใช้นิพจน์เพื่อกำหนดค่าให้แก่ตัวแปรโดยใช้เครื่องหมายเท่ากับ (=) ซึ่งไม่จำเป็นต้องมีการระบุ หรือประกาศว่าที่แปรที่เราสร้างขึ้นมีชนิดข้อมูลเป็นชนิดใด ซึ่งตัวแปรจะมีชนิดข้อมูลแปรผันตามค่าของข้อมูลที่เรากำหนดให้ ดังตัวอย่าง"
      ],
      "metadata": {
        "id": "Oqjzh1-Ckow5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 3\n",
        "b = 4.92\n",
        "c = \"marcuscode.com\"\n",
        "c = 10.5"
      ],
      "metadata": {
        "id": "_jPZISpyicWY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "การประกาศตัวแปรในภาษา Python นั้นไม่จำเป็นต้องระบุประเภทของตัวแปรในตอนที่ประกาศเหมือนในภาษา C หรือ Java\n",
        "\n",
        "* ในตัวแปร a มีค่าเป็น 3 และเป็นประเภทเป็น Integer\n",
        "\n",
        "* ตัวแปร b มีค่าเป็น 4.92\n",
        "* และเป็นประเภทเป็น Float\n",
        "และตัวแปร c มีค่าเป็น \"marcuscode.com\" และเป็นประเภท String\n",
        "\n",
        "และในภายหลังเราได้เปลี่ยนค่าของตัวแปร c เป็น 10.5 ทำให้ตัวแปร c มีชนิดข้อมูลกลายเป็นประเภท Float"
      ],
      "metadata": {
        "id": "K_E79ByFlSjF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "_GY3v6vilz2K"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## กำหนดค่าให้กับหลายตัวแปร (Multiple Assignment)\n",
        "\n",
        "ในภาษา Python สนับสนุนการกำหนดค่าให้กับหลายตัวแปร (Multiple Assignment) ในคำสั่งเดียวในตัวอย่างด้านล่าง เป็นการกำหนดค่า 1 และ 2 กับตัวแปร a และ b ตามลำดับ\n",
        "\n",
        "และในคำสั่งต่อมาเป็นการกำหนดค่า 10 ให้กับตัวแปร x y และ z ซึ่งทำให้การเขียนโปรแกรมสะดวกและรวดเร็วมากขึ้น\n",
        "\n",
        "โดยผลของการกำหนดค่าของตัวแปรด้านบน เป็นดังนี้"
      ],
      "metadata": {
        "id": "roP2SJsbloV5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a, b, c = 1, 2, 3\n",
        "x = y = z = 10"
      ],
      "metadata": {
        "id": "7xDf2B1clipl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"a = \" , a)\n",
        "print(\"b = \" , b)\n",
        "print(\"c = \" , c)\n",
        "print(\"x = \" , x)\n",
        "print(\"y = \" , y)\n",
        "print(\"z = \" , z)"
      ],
      "metadata": {
        "id": "ppLuLvTgl39G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# การกำหนดค่าเริ่มต้นให้ ตัวแปร\n",
        "\n",
        "x1 = x2 = x3 = x4 = x5 = x6 = x7 = x8 = x9 = x10 = 20\n",
        "\n",
        "print(x3)"
      ],
      "metadata": {
        "id": "fuHiWL_Nl374"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "การประยุกต์การกำหนดค่าให้หลายตัวแปร\n",
        "ตัวอย่างของการกำหนดค่าให้หลายตัวแปรที่มีในภาษาไพธอน นั้นสามารถนำมาประยุกต์ใช้ในการเรื่องของการสลับค่าระหว่างตัวแปร\n",
        "ซึ่งจะทำให้การดำเนินการรวดเร็วขึ้น โปรแกรมมีความกระชับขึ้น"
      ],
      "metadata": {
        "id": "ujphSc75l-f2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 10\n",
        "b = 20\n",
        "tmp = a\n",
        "a = b\n",
        "b = tmp\n",
        "\n",
        "print(a)\n",
        "print(b)"
      ],
      "metadata": {
        "id": "gUUjZ_Q-mFPQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = 10\n",
        "b = 20\n",
        "\n",
        "a, b = b, a\n",
        "\n",
        "print(a)\n",
        "print(b)"
      ],
      "metadata": {
        "id": "JWb5sJ1el73S"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lt = [1, 2, 3, 4, 5, 6]\n",
        "\n",
        "# a, b = b, a\n",
        "lt[0], lt[-1] = lt[-1], lt[0]\n",
        "\n",
        "print(lt)"
      ],
      "metadata": {
        "id": "reDp3al3mNAa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "B5fTsK7PmYDQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## การตั้งชื่อตัวแปรในภาษาไพธอน\n",
        "\n",
        "ไพทอนไม่จำเป็นต้องประกาศตัวแปรก่อนใช้งาน สามารถกำหนดค่าขึ้นมา และเรียกใช้ได้เลย แต่การตัวชื่อตัวแปรของ ไพทอนต้องเป็นไปตามกฏดังนี้\n",
        "\n",
        "1. ต้องขึ้นต้นด้วยตัวอักษร\n",
        "2. ห้ามใช้ตัวเลขหรือสัญลักษณ์ใดๆ\n",
        "3. ห้ามมีช่องว่างหรือเว้นวรรค\n",
        "ห้ามใช้เครื่องหมายต่อไปนี้ในการประกาศตัวแปร !...@...#...$...%...^...&...*...(...)...-...=...+...~\n",
        "4. ควรตั้งชื่อตัวแปรที่สื่อความหมายให้ชัดเจน เพื่อผู้อื่นตีความหมายได้เข้าใจ แต่ถ้ามีความหมายยาวมาก ให้ย่อ เช่น student_name ควรใช้ st_name เป็นต้น\n",
        "5. ตัวแปรที่มีตัวพิมพ์ใหญ่และตัวพิมพ์เล็กผสมกันจะมีความหมายต่างกับตัวพิมพ์เล็กเพียงอย่างเดียว เช่น St_Id แตกต่างจากตัวแปร st_id เป็นต้น"
      ],
      "metadata": {
        "id": "YWnCyNb_md5r"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## คำสงวน ในภาษาไพทอน\n",
        "คำสงวน คือชื่อหรือคำที่ภาษา Python (ไพทอน) ไว้ใช้เฉพาะเพื่อเป็นคำสั่ง หรือมีไว้เพื่อเขียนเป็นโครงสร้างของตัวภาษาเอง โดยคำสงวนของ Python จะมีทั้งหมด 31 คำ ดังนี้\n",
        "\n",
        "and, as, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is, lambda, not, or, pass, print, raise, return, try, while, with, yield"
      ],
      "metadata": {
        "id": "v23lpbHdmwSb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "ATte2E5Pm8W6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Numbers\n",
        "ไพทอนรองรับข้อมูลชนิดตัวเลขทั้ง 4 ชนิดดังนี้\n",
        "\n",
        "**int (signed integers)** − เรามักเรียกข้อมูลประเภทนี้ว่า จำนวนเต็ม (Integer), ซึ่งเป็นได้ทั้งตัวเลขจำนวนเต็มบวก หรือเต็มลบก็ได้ ในระบบเลขฐาน 10.\n",
        "\n",
        "**long (long integers)** − เป็นข้อมูลจำนวนเต็มที่ไม่ได้จำกัดขนาด แต่จะเขียนตามด้วยตัว L ตัวเล็กหรือตัวใหญ่ก็ได้.\n",
        "\n",
        "**float (floating point real values)** − เป็นข้อมูลตัวเลขประเภทจำนวนจริง ซึ่งจะเรียนในรูปแบบตัวเลขทศนิยม และ Floats อาจใช้เขียนในรูปแบบสัญลักษณ์ทางวิทยาศาสตร์ ซึ่งใช้ E หรือ e ในการแทนเลขยกกำลัง 10 (2.5e2 = 2.5 x 102 = 250).\n",
        "\n",
        "**complex (complex numbers)** − คือข้อมูลที่ถูกเขียนในรูปของ a + bJ, โดย a และ b คือจำนวนจริง และ J คือค่ารากที่สองของ -1 โดย Complex numbers ไม่ค่อยได้ถูกใช้ในการเขียนโปรแกรมในภาษาไพทอน\n",
        "\n",
        "หมายเหตุ ใน Python 3 ข้อมูลชนิด long ถูกตัดออกไป"
      ],
      "metadata": {
        "id": "OAUoqWdFm_zh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## Integer\n",
        "print(type(10))\n",
        "\n",
        "# Float\n",
        "print(type(15.20))\n",
        "\n",
        "# Complex\n",
        "print(type(9.322e-36j))"
      ],
      "metadata": {
        "id": "PR8FzuUzmR-V"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การแปลงข้อมูลตัวเลข\n",
        "\n",
        "1. **int(x)** เป็นการแปลง x ให้อยู่ในรูปแบบจำนวนเต็ม.\n",
        "\n",
        "2. **float(x)** เป็นการแปลง x ให้อยู่ในรูปแบบจำนวนจริง (เลขทศนิยม).\n",
        "\n",
        "3. **complex(x)** เป็นการแปลง x เป็นจำนวนเชิงซ้อนกับส่วนจริง x และศูนย์ส่วนจินตภาพ.\n",
        "\n",
        "4. **complex(x, y)** เป็นการแปลง x และ y เป็นจำนวนเชิงซ้อนกับส่วนจริง x และ y ส่วนจินตภาพ x และ y เป็นนิพจน์ตัวเลข."
      ],
      "metadata": {
        "id": "GbEXpiUonUVZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 10.8\n",
        "int(x)"
      ],
      "metadata": {
        "id": "CnUv04ZqnoIn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = 2.58\n",
        "int(x)"
      ],
      "metadata": {
        "id": "YDyjVUpjnpxm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = 10\n",
        "complex(x)"
      ],
      "metadata": {
        "id": "SDznQ1zhnsEO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = 10\n",
        "complex(x, 2)"
      ],
      "metadata": {
        "id": "qYWMucNWnv93"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### ฟังก์ชันทางคณิตศาสตร์"
      ],
      "metadata": {
        "id": "666f2XBgoFip"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "abs(x)\n",
        "\n",
        "ค่าสัมบูรณ์ของ x: ระยะทาง (บวก) ระหว่าง x และศูนย์"
      ],
      "metadata": {
        "id": "Hy8ryqvuoKBS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "abs(-10)"
      ],
      "metadata": {
        "id": "xWRv0cVqnP3f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import math"
      ],
      "metadata": {
        "id": "OFzctTA7oPRO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**math.log(x)**\n",
        "\n",
        "The natural logarithm of x, for x > 0."
      ],
      "metadata": {
        "id": "bFY59ic9oSiH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "math.log(10)"
      ],
      "metadata": {
        "id": "kIj1_FewoRLm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**math.log10(x)**\n",
        "\n",
        "The base-10 logarithm of x for x > 0."
      ],
      "metadata": {
        "id": "DJSf5txeoXok"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "math.log10(10)"
      ],
      "metadata": {
        "id": "quBiEEtboeob"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**math.sqrt(x)**\n",
        "\n",
        "The square root of x for x > 0."
      ],
      "metadata": {
        "id": "N85M4cKZoiRR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "math.sqrt(2)"
      ],
      "metadata": {
        "id": "rNqSUoNXonGs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Power of number**"
      ],
      "metadata": {
        "id": "jRzfhZaloiPG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "3**2"
      ],
      "metadata": {
        "id": "WxAf2qtKosr9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "kwYwwN8Aoxef"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Strings\n",
        "\n",
        "สตริง หรือข้อมูลประเภทลำดับของอักขระ เป็นข้อมูลอีกประเภทที่นิยมใช้มากในภาษาไพธอน โดยที่เราสามารถสร้างได้ง่าย ๆ โดยการใส่ตัวอักษร หรือข้อความไว้ภายในในเครื่องหมายคำพูด (' ' หรือ \" \") การสร้างข้อมูลประเภทสตริงสามารถทำได้โดยการกำหนดค่าให้กับตัวแปร ตัวอย่างเช่น -"
      ],
      "metadata": {
        "id": "Rx85gkxSo4oU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การสร้างสตริงในภาษาไพธอน\n",
        "\n",
        "สตริงที่สามารถสร้างขึ้นได้โดยใส่ตัวอักษรไว้ภายในเครื่องหมายคำพูดเดี่ยว ('..') หรือเครื่องหมายคำพูดคู่ (\"..\") และคำพูดสาม (\"\"\"..\"\"\") สามารถใช้ในไพธอน แต่โดยทั่วไปใช้เพื่อแสดงสายอักขระแบบหลายบรรทัด"
      ],
      "metadata": {
        "id": "5kmlMQ5gpJzJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# การกำหนดค่าให้กับตัวแปรที่มีชนิดข้อมูลเป็นสตริง\n",
        "my_string = 'Hello'\n",
        "print(my_string)\n",
        "\n",
        "my_string = \"Hello\"\n",
        "print(my_string)\n",
        "\n",
        "my_string = '''Hello'''\n",
        "print(my_string)\n",
        "\n",
        "# triple quotes string สามารถใช้สำหรับการแสดงสตริงในหลายบรรทัด\n",
        "my_string = \"\"\"Hello, welcome to\n",
        "           the world of Python\"\"\"\n",
        "print(my_string)"
      ],
      "metadata": {
        "id": "BHmJmWmWovLN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การเข้าถึงอักขระในสตริง\n",
        "\n",
        "ภาษาไพธอนนั้นไม่สนับสนุนข้อมูลประเภทอักขระ (Character) โดยจะถือว่าข้อมูลอักขระแต่ละตัวนั้นถือว่าเป็นสตริงที่มีขนาดความยาวเท่ากับ 1 โดยในการเข้าถึงอักขระแต่ละตัวภายในสติงนั้นให้ใช้วงเล็บเหลี่ยม ( [ ] ) สำหรับการหั่น (Slide) ตามดัชนีหรือดัชนีการเข้าถึงอักขระภายในสตริง ตัวอย่างเช่น -"
      ],
      "metadata": {
        "id": "r1U1K4qBpW5J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "str = 'Hello World!'\n",
        "\n",
        "print (str)          # พิมพ์สตริงตั้งหมด\n",
        "print (str[0])       # พิมพ์อักขระลำดับแรกของสตริง\n",
        "print (str[2:5])     # พิมพ์อักขระลำดับที่ 3 ถึงลำดับที่ 5 ภายในสตริง\n",
        "print (str[2:])      # พิมพ์อักขระลำดับที่ 3 จนถึงลำดับสุดท้ายภายในสตริง\n",
        "print (str * 2)      # พิมพ์สตริง จำนวน 2 ครั้ง\n",
        "print (str + \"TEST\") # พิมพ์สตริงโดยรวมสายอักขระเข้าด้วยกัน"
      ],
      "metadata": {
        "id": "9F_BqNhUpR7P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การปรับปรุงสตริง\n",
        "\n",
        "เราสามารถ \"ปรับปรุง\" สตริงที่มีอยู่โดย (อีกครั้ง) การกำหนดตัวแปรให้กับสตริงอื่น ค่าใหม่อาจเกี่ยวข้องกับค่าก่อนหน้านี้หรือเป็นสตริงที่แตกต่างกันโดยสิ้นเชิง ตัวอย่างเช่น -"
      ],
      "metadata": {
        "id": "FvaOYsd5pe17"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "var = 'Hello World!'\n",
        "print(\"Updated String :- \", var[:6] + 'Python')"
      ],
      "metadata": {
        "id": "dzafeFnypjDQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "str = \"Computer Science\"\n",
        "\n",
        "print(str[:8] + ' Today')"
      ],
      "metadata": {
        "id": "2TlW4FVTpm7_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(str[9:] + ' Today')"
      ],
      "metadata": {
        "id": "A1puDUW3pol4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "str = \"Computer Science\"\n",
        "\n",
        "print(str[:8]+\" Today \"+str[9:])"
      ],
      "metadata": {
        "id": "7MZNU7Sypr4d"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การดำเนินการสตริง\n",
        "\n",
        "ข้อมูลประเภทสตริงนั้นสามารถมีการดำเนินการที่หลากหลาย ดังนี้\n",
        "\n",
        "การรวมสองหรือมากกว่าสตริง\n",
        "การรวมสตริงตั้งแต่สอง หรือมากกว่านั้นเข้าเป็นหนึ่งเดียวเรียกว่าการ concatenation\n",
        "\n",
        "โดยใช้ตัวดำเนินการบวก ( + ) เพียงแค่เขียนนำสตริงสองตัวดำเนิการเข้าด้วยกันก็จะถูกเชื่อมต่อกัน\n",
        "\n",
        "และโอเปอเรเตอร์คูณ ( * ) สามารถใช้เพื่อทำซ้ำสตริงได้หลายครั้ง"
      ],
      "metadata": {
        "id": "6M6Qw3H7pt0u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "str1 = 'Hello'\n",
        "str2 ='World!'\n",
        "\n",
        "# using +\n",
        "print('str1 + str2 = ', str1 + str2)\n",
        "\n",
        "# using *\n",
        "print('str1 * 3 =', str1 * 3)"
      ],
      "metadata": {
        "id": "meI2NrE7pzLg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "หรือถ้าเราต้องการต่อสตริงต่าง ๆ ที่มีหลายบรรทัด เราสามารถใช้วงเล็บในการดำเนินการได้"
      ],
      "metadata": {
        "id": "_pEeBXJDp4e0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# using parentheses\n",
        "s = ('Hello '\n",
        "     'World')\n",
        "\n",
        "print(s)"
      ],
      "metadata": {
        "id": "lz8Y6-uWp2Rb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>\n",
        "\n",
        "**เกร็ดน่ารู้** ตัวดำเนินการ + และ * เวลาใช้งานกับสตริง\n",
        "\n",
        "* เมื่อใช้ + ระหว่างสองสตริง จะเป็นการนำสตริงมาต่อกัน\n",
        "* เมื่อใช้ * ระหว่างสตริงกับเลขจำนวนเต็ม จะเป็นการนำสตริงมาต่อกันตามจำนวนครั้งของเลขจำนวนเต็ม\n",
        "\n",
        "<hr>"
      ],
      "metadata": {
        "id": "oh2FgNZAjaHl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"Hello\" + \"World\""
      ],
      "metadata": {
        "id": "vm5M4vEqjdza"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"Hello\" + \"World\" + \"!\""
      ],
      "metadata": {
        "id": "j_fjoV2hjfYf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "3*\"Hello+\""
      ],
      "metadata": {
        "id": "S3ypSvuFjhNM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การวนซ้ำบนสตริง\n",
        "\n",
        "เราสามารถใช้การทำซ้ำผ่านสตริง จากตัวอย่างด้านล่างเป็นการวนซ้ำเพื่อนับจำนวน 'l' ที่อยู่ในสตริง"
      ],
      "metadata": {
        "id": "35MCdNrgqAH8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "count = 0\n",
        "\n",
        "for letter in 'Hello World':\n",
        "    # count += 1\n",
        "    if(letter == 'l'):\n",
        "        count += 1\n",
        "\n",
        "print(count,'letters found')"
      ],
      "metadata": {
        "id": "pfgn8m0Ip7Xn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การทดสอบสมาชิกในสตริง\n",
        "\n",
        "เราสามารถทดสอบว่ามีอักขระ หรือสตริงย่อยอยู่ภายในสตริงหรือไม่โดยใช้ keyword คือ in"
      ],
      "metadata": {
        "id": "ZBQo6Ns3qPn8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'a' in 'program'"
      ],
      "metadata": {
        "id": "XGld2IoyqHBf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'at' not in 'battle'"
      ],
      "metadata": {
        "id": "94svCi8eqX1i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Escape Characters\n",
        "\n",
        "กรณีตัวอย่าง : ถ้าหากเราต้องการพิมพ์ข้อความเช่น - He said, \"What's there?\" - เราไม่สามารถใช้เครื่องหมายคำพูดหรือคำพูดแบบคู่ได้ ซึ่งจะส่งผลให้เกิด SyntaxError เนื่องจากข้อความนั้นมีทั้งเครื่องหมายคำพูดแบบเดียว และแบบคู่\n"
      ],
      "metadata": {
        "id": "uWk43lCQqMLe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#ตัวอย่างที่เกิดข้อผิดพลาด\n",
        "# ต้องการพิมพ์\n",
        "# He said, \"What's there?\"\n",
        "\n",
        "print(\"He said, \"What's there?\"\")"
      ],
      "metadata": {
        "id": "L5_olm0pqwwC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "วิธีหนึ่งในการแก้ปัญหานี้คือการใช้เครื่องหมายคำพูดแบบสามตัว หรือเราสามารถใช้ escape characters\n",
        "\n",
        "Escape characters เป็นอักขระพิเศษในไพธอน ซึ่งเป็นอักขระที่จะไม่แสดงผล หรือไม่ปรากฏให้เห็นตอนแสดงผลผ่านหน้าจอ ยกตัวอย่างเช่น \"\\n\" เป็นอักขระที่หมายถึงการขึ้นบรรทัดใหม่\n",
        "\n",
        "escape sequence เริ่มต้นด้วยเครื่องหมายแบ็กสแลช (\" \\ \") และถูกตีความแตกต่างกัน ถ้าเราใช้เครื่องคำพูดเดี่ยวเพื่อแทนสตริงจะต้องยกเว้นเครื่องหมายเดียวทั้งหมดภายในสตริง คล้ายกันคือกรณีที่มีเครื่องหมายคำพูดคู่ นี่คือวิธีที่สามารถทำได้เพื่อแสดงข้อความข้างต้น"
      ],
      "metadata": {
        "id": "Hq0dzu71qyTk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# using triple quotes\n",
        "print(\"\"\"He said, \"What's there?\"\"\")"
      ],
      "metadata": {
        "id": "uRQGSOVsqkEU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# escaping single quotes\n",
        "print('He said, \"What\\'s there?\"')"
      ],
      "metadata": {
        "id": "CWtBbWaCqn_X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# escaping double quotes\n",
        "print(\"He said, \\\"What's there?\\\"\")"
      ],
      "metadata": {
        "id": "PIUbdMLtqqfi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### เมธอด format()\n",
        "สำหรับการจัดรูปแบบแสดงผลของสตริง\n",
        "\n",
        "เมธอด format() สามารถใช้งานกับสตริงอ็อบเจ็กต์ที่มีความหลากหลายและมีประสิทธิภาพในการจัดรูปแบบการแสดงผลของสตริง สตริงการจัดรูปแบบมีวงเล็บปีกกา {} เป็นตัวยึดตำแหน่ง หรือฟิลด์แทนที่ซึ่งจะถูกแทนที่\n",
        "\n",
        "ภายในเครื่องหมาย {} เราสามารถใช้อาร์กิวเมนต์ตัวเลขตำแหน่ง หรืออาร์กิวเมนต์คำหลักเพื่อระบุลำดับในการแสดงผลได้"
      ],
      "metadata": {
        "id": "bA7490J6rMDA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# default(implicit) order\n",
        "default_order = \"{}, {} and {}\".format('John','Bill','Sean')\n",
        "print('\\n--- Default Order ---')\n",
        "print(default_order)\n",
        "\n",
        "# order using positional argument\n",
        "positional_order = \"{1}, {0} and {2}\".format('John','Bill','Sean')\n",
        "print('\\n--- Positional Order ---')\n",
        "print(positional_order)\n",
        "\n",
        "# order using keyword argument\n",
        "keyword_order = \"{s}, {b} and {j}\".format(j='John',b='Bill',s='Sean')\n",
        "print('\\n--- Keyword Order ---')\n",
        "print(keyword_order)"
      ],
      "metadata": {
        "id": "YES1LRRVqsU6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**format()**\n",
        "ผู้ใช้งานสามารถกำหนดทางเลือกในการแสดงผลสตริงได้อย่างหลากหลาย และจำเพาะเจาะจง\n",
        "\n",
        "ตัวอย่างเช่น สามารถใช้สัญลักพิเศษในการกำหนดรูปแบบการแสดงสตริงใช้ ชิดซ้าย <, ชิดขวา > หรือตรงกลาง ^ ได้\n",
        "\n",
        "นอกจากนี้เรายังสามารถจัดรูปแบบ integers เป็น binary, hexadecimal ฯลฯ\n",
        "\n",
        "และ floats สามารถปัดเศษหรือแสดงในรูปแบบเลขชี้กำลัง มีการจัดรูปแบบมากมายที่คุณสามารถใช้ได้"
      ],
      "metadata": {
        "id": "MGaISULw5CX-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# formatting integers\n",
        "\"Binary representation of {0} is {0:b}\".format(12)"
      ],
      "metadata": {
        "id": "-MUkzdLq5ESG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# formatting floats\n",
        "\"Exponent representation: {0:e}\".format(1566.345)"
      ],
      "metadata": {
        "id": "dbTtY_ny5MR5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# round off\n",
        "\"One third is: {0:.3f}\".format(1/3)"
      ],
      "metadata": {
        "id": "Cn35CwU95OUD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# string alignment\n",
        "\"|{:<10}|{:^10}|{:>10}|\".format('butter','bread','ham')"
      ],
      "metadata": {
        "id": "1HhzLJ-x5QDN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### String Method ที่มักใช้งานบ่อย\n",
        "\n",
        "String Method ที่มักใช้งานบ่อย เช่น lower(), upper(), join(), split(), find(), replace() เป็นต้น"
      ],
      "metadata": {
        "id": "RSqyd9ca5WV9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Funciton\n",
        "# lower(\"PrOgRaMiZ\")\n",
        "\n",
        "# Method\n",
        "\"PrOgRaMiZ\".lower()"
      ],
      "metadata": {
        "id": "7ooSitKv5Upt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"PrOgRaMiZ\".upper()"
      ],
      "metadata": {
        "id": "po04dQnu5iNP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"This will split all words into a list\".split()"
      ],
      "metadata": {
        "id": "2DskzjID5nSl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "' '.join(['This', 'will', 'join', 'all', 'words', 'into', 'a', 'string'])"
      ],
      "metadata": {
        "id": "-Xx6wDbQ5o7E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'Happy New Year'.find('p')"
      ],
      "metadata": {
        "id": "py28hfhV5riN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'Happy New Year, Happy'.replace('Happy','Brilliant')"
      ],
      "metadata": {
        "id": "dK5o66K45u1h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### ตัวอย่างการคำนวณค่า BMI"
      ],
      "metadata": {
        "id": "NZtSAPnG54mS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "weight, height = input(\"Enter your data (weight, height) : \").split()\n",
        "\n",
        "height_meter = int(height) / 100\n",
        "\n",
        "bmi = int(weight) / height_meter ** 2\n",
        "\n",
        "print(\"{0:.2f}\".format(bmi))"
      ],
      "metadata": {
        "id": "qW-gZqfM5zpA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# เขียนโปรแกรมแบบย่อ\n",
        "\n",
        "data = [int(i) for i in input(\"Enter your data: \").split()]\n",
        "print(\"{0:.2f}\".format(data[0] / (data[1]/100)**2))"
      ],
      "metadata": {
        "id": "N99DIcwk59LH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "zpapQPSc68Up"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## List"
      ],
      "metadata": {
        "id": "-Q9CPLCo6fQ6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**วิธีการสร้าง List ในภาษาไพธอน**\n",
        "\n",
        "ในการเขียนโปรแกรมภาษาไพธอน List จะถูกสร้างขึ้นโดยการวางไอเท็มทั้งหมด (element) ภายในวงเล็บเหลี่ยม [ ] โดยคั่นด้วยเครื่องหมายจุลภาค (,) และภายใน List นั้นสามารถมีสมาชิกจำนวนมาก และอาจมีหลากหลายประเภทข้อมูล (จำนวนเต็ม, จำนวนจริง, สตริง ฯลฯ )"
      ],
      "metadata": {
        "id": "AF4fnFYN6fPD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# empty list\n",
        "my_list = []\n",
        "\n",
        "# list of integers\n",
        "my_list = [1, 2, 3]\n",
        "\n",
        "# list with mixed datatypes\n",
        "my_list = [1, \"Hello\", 3.4]"
      ],
      "metadata": {
        "id": "N9xNr5gl6KVr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "นอกจากนี้ภายใน List ยังสามารถมี List อื่นเป็นเป็นสมาชิกได้อีกด้วยซึ่งเรียกว่า Nested List"
      ],
      "metadata": {
        "id": "jSAHiIWR7EWX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# nested list\n",
        "my_list = [\"mouse\", [8, 4, 6], ['a']]"
      ],
      "metadata": {
        "id": "vyofhT3M61DG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### วิธีการเข้าถึงสมาชิก (Element) ภายใน List\n",
        "\n",
        "มีหลายวิธีที่เราสามารถเข้าถึงสมาชิกของ List ได้\n",
        "\n",
        "ดัชนีรายการ (Index) เราสามารถใช้ตัวดำเนินการดัชนี [ ] เพื่อเข้าถึงสมาชิกภายใน List ได้ โดยดัชนีเริ่มจาก 0 ดังนั้น List ที่มีสมาชิก 5 ตัว จะมีดัชนีตั้งแต่ 0 ถึง 4"
      ],
      "metadata": {
        "id": "okT4plg17QQ4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = ['p','r','o','b','e']\n",
        "# Output: p\n",
        "print(my_list[0])\n",
        "\n",
        "# Output: o\n",
        "print(my_list[2])\n",
        "\n",
        "# Output: e\n",
        "print(my_list[4])\n",
        "\n",
        "# Error! Only integer can be used for indexing\n",
        "# my_list[4.0]\n",
        "\n",
        "# Nested List\n",
        "n_list = [\"Happy\", [2,0,1,5]]\n",
        "\n",
        "# Nested indexing\n",
        "\n",
        "# Output: a\n",
        "print(n_list[0][1])\n",
        "\n",
        "# Output: 5\n",
        "print(n_list[1][3])"
      ],
      "metadata": {
        "id": "qlnvz9zn7V8W"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Nested List\n",
        "# n_list = [\"Happy\", [2,0,1,5]]\n",
        "\n",
        "n_list = [[1, 2, 3], [4, 5, 6, [7, 8, 9, 10, [11, 12]]]]\n",
        "\n",
        "# จงเข้าถึงเลข 12 ใน n_list\n",
        "\n"
      ],
      "metadata": {
        "id": "5lge73_A7I-p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "matrx = [\n",
        "    [1, 2, 3, 4],\n",
        "    [5, 6, 7, 8],\n",
        "    [9, 10, 11, 12]\n",
        "]\n",
        "\n",
        "# จงเข้าถึงเลข 12 ใน n_list\n",
        "\n"
      ],
      "metadata": {
        "id": "yRKKqnOg7hxl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "str_lt = [\n",
        "        [\"Phisan\"],\n",
        "        [\"Sookkhee\", \"Hello\"],\n",
        "        ]\n",
        "\n",
        "# จงเข้าถึงตัวอักษร o ใน Hello ใน str_list\n",
        "\n"
      ],
      "metadata": {
        "id": "cf6lNw5s7oJD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การจัดทำดัชนีเชิงลบ (Negative indexing)\n",
        "\n",
        "โปรแกรมภาษาไพธอนช่วยช่วยอำนวนความสะดวกในการเข้าถึงสมาชิกที่อยู่ใน List ให้สามารถทำได้ง่ายขึ้น โดยอนุญาติให้มีการจัดทำดัชนีเชิงลบ โดย ดัชนี -1 หมายถึงรายการสุดท้ายภายใน List และ -2 ไปยังรายการสุดท้ายที่สองและอื่น ๆ"
      ],
      "metadata": {
        "id": "4wMXhVUJ8FWQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = ['p','r','o','b','e']"
      ],
      "metadata": {
        "id": "g44oDpjD7-27"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_list[len(my_list) - 1]"
      ],
      "metadata": {
        "id": "wHpBOQaG8SZG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_list[-1]"
      ],
      "metadata": {
        "id": "eP4t9MpT8URq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Slice Lists\n",
        "\n",
        "เราสามารถเข้าถึงสมาชิกต่าง ๆ ภายใน List โดยใช้ตัวดำเนินการ slice ( : )"
      ],
      "metadata": {
        "id": "BAcjVruT8p5X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = ['p','r','o','g','r','a','m','i','z']\n",
        "\n",
        "# สมาชิกลำดับที่ 3 ถึง 5\n",
        "print(my_list[2:5])\n",
        "\n",
        "# สมาชิกเริ่มจากลำดับที่ 1 ถึง 4\n",
        "print(my_list[:-5])\n",
        "\n",
        "# สมาชิกลำดับที่ 6 ถึง ลำดับสุดท้าย\n",
        "print(my_list[5:])\n",
        "\n",
        "# สมาชิกลำดับแรก ถึง ลำดับสุดท้าย\n",
        "print(my_list[:])"
      ],
      "metadata": {
        "id": "b_a5aFa78W0O"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# var[start:stop:step]\n",
        "\n",
        "n = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
        "\n",
        "n[::-1]"
      ],
      "metadata": {
        "id": "I1ozQtks8xTY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
        "n[::-2]"
      ],
      "metadata": {
        "id": "aYpoh1CE80Ve"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#การบ้าน\n",
        "'''\n",
        "เลขพาลินโดรม\n",
        "เลขที่เมื่อกลับหลังแล้วยังได้ตัวเดิม\n",
        "เช่น 8008, 0880\n",
        "'''\n",
        "\n",
        "# โจทย์ จงหาว่าในช่วง 1 - 1000 มีเลยพาลินโดรมอยู่เท่าไร่\n",
        "# การแปลงชนิดข้อมูล\n",
        "# int -> string\n",
        "count = 0\n",
        "for i in range(100, 1001):\n",
        "    if str(i) == _______:\n",
        "        count += 1\n",
        "\n",
        "print(count)"
      ],
      "metadata": {
        "id": "P5TFd8TK83jM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### วิธีการเปลี่ยน หรือเพิ่มข้อมูลสมาชิกลงใน List\n",
        "\n",
        "เราสามารถใช้ตัวดำเนินการกำหนดค่า (=) เพื่อเปลี่ยนแปลงข้อมูลสมาชิกภายใน List ได้ ซึ่งในการเปลี่ยนแปลงข้อมูลนั้นสามารถทำได้ทีละตัว หรือกระทำเป็นช่วงข้อมูลได้"
      ],
      "metadata": {
        "id": "WpGcF1Ns9OHG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lt = []\n",
        "\n",
        "# วิธีที่ 1 : append\n",
        "lt.append(1)\n",
        "lt.append(3)\n",
        "lt.append(5)"
      ],
      "metadata": {
        "id": "iRwbX5a39ReH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lt"
      ],
      "metadata": {
        "id": "z30wI48o9U65"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# วิธีที่ 2 : insert\n",
        "lt = [1, 3, 5]\n",
        "\n",
        "lt.insert(0, 0)\n",
        "# [0, 1, 3, 5]\n",
        "\n",
        "lt.insert(2, 2)\n",
        "# [0, 1, 2, 3, 5]\n",
        "\n",
        "lt.insert(4, 4)\n",
        "# [0, 1, 2, 3, 4, 5]"
      ],
      "metadata": {
        "id": "jEV34g-59WXC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lt"
      ],
      "metadata": {
        "id": "Agv_bCEV9ZGi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# mistake values\n",
        "odd = [2, 4, 6, 8]\n",
        "\n",
        "# change the 1st item\n",
        "odd[0] = 1\n",
        "\n",
        "# Output: [1, 4, 6, 8]\n",
        "print(odd)\n",
        "\n",
        "# change 2nd to 4th items\n",
        "odd[1:4] = [3, 5, 7]\n",
        "\n",
        "# Output: [1, 3, 5, 7]\n",
        "print(odd)"
      ],
      "metadata": {
        "id": "FLJmIiq_9Z4n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "เราสามารถเพิ่มข้อมูลเข้าไปใน List ทีละตัวได้โดยใช้ append() หรือเพิ่มข้อมูลครั้งละหลายรายการเข้าไปใน List ได้โดยใช้ extend()"
      ],
      "metadata": {
        "id": "BYGfhtpN92Ut"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "odd = [1, 3, 5]\n",
        "\n",
        "odd.append(7)\n",
        "\n",
        "# Output: [1, 3, 5, 7]\n",
        "print(odd)\n",
        "\n",
        "odd.extend([9, 11, 13])\n",
        "\n",
        "# Output: [1, 3, 5, 7, 9, 11, 13]\n",
        "print(odd)"
      ],
      "metadata": {
        "id": "DJjx2rw19jiE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3]\n",
        "b = [4, 5, 6]\n",
        "\n",
        "a.extend(b)\n",
        "a"
      ],
      "metadata": {
        "id": "UiOdK1c09589"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "นอกจากนี้ยังสามารถใช้ตัวดำเนินการบวก ( + ) เพื่อทำการรวม 2 List เข้าด้วยกัน วิธีนี้เรียกว่า Concatenation\n",
        "\n",
        "และสามารถใช้ตัวดำเนินการคูณ ( * ) เพื่อการสร้างสมาชิกซ้ำภายใน List ตามจำนวนครั้งที่กำหนด"
      ],
      "metadata": {
        "id": "0zeMsZl-9_98"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "odd = [1, 3, 5]\n",
        "\n",
        "# Output: [1, 3, 5, 9, 7, 5]\n",
        "print(odd + [9, 7, 5])\n",
        "\n",
        "#Output: [\"re\", \"re\", \"re\"]\n",
        "print([\"re\"] * 3)"
      ],
      "metadata": {
        "id": "CIeFXBFH98r7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3]\n",
        "b = [4, 5, 6]\n",
        "\n",
        "a + b #เท่ากับการ extend"
      ],
      "metadata": {
        "id": "m8Cp0mY7-Co4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### วิธีการลบมูลสมาชิกออกจาก List\n",
        "\n",
        "เราสามารถลบข้อมูลสมาชิกออกจาก List ครั้งละหนึ่งรายการ หรือมากกว่านั้นออกจาก List โดยใช้คำสำคัญ delรายการได้ทั้งหมด"
      ],
      "metadata": {
        "id": "r5_Oo0vE-Lmy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = ['p','r','o','b','l','e','m']\n",
        "\n",
        "# delete one item\n",
        "del my_list[2]\n",
        "\n",
        "# Output: ['p', 'r', 'b', 'l', 'e', 'm']\n",
        "print(my_list)\n",
        "\n",
        "# delete multiple items\n",
        "del my_list[1:5]\n",
        "\n",
        "# Output: ['p', 'm']\n",
        "print(my_list)\n",
        "\n",
        "# delete entire list\n",
        "del my_list\n",
        "\n",
        "# Error: List not defined\n",
        "# print(my_list)"
      ],
      "metadata": {
        "id": "f8fGA4dc-HSG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "ในอีกทางหนึ่งนั้น เราสามารถใช้เมธอด remove() เพื่อทำการลบข้อมูลสมาชิกที่กำหนดได้ทันที หรือใช้เมทอด pop() เพื่อทำการลบข้อมูลภายสมาชิกในรายการที่กำหนดได้\n",
        "\n",
        "เมธอด pop() จะลบและส่งกลับรายการสุดท้ายหากไม่มีดัชนี ซึ่งช่วยให้เราสามารถใช้ List เพื่อเป็นสแต็ก\n",
        "\n",
        "นอกจากนี้เรายังสามารถใช้เมธอด clear() เพื่อลบข้อมูลสมาชิกทั้งหมดออกจาก List"
      ],
      "metadata": {
        "id": "24Kk-tHa-k5u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = ['p','r','o','b','l','e','m']\n",
        "my_list.remove('p')\n",
        "\n",
        "# Output: ['r', 'o', 'b', 'l', 'e', 'm']\n",
        "print(my_list)\n",
        "\n",
        "# Output: 'o'\n",
        "print(my_list.pop(1))\n",
        "\n",
        "# Output: ['r', 'b', 'l', 'e', 'm']\n",
        "print(my_list)\n",
        "\n",
        "# Output: 'm'\n",
        "print(my_list.pop())\n",
        "\n",
        "# Output: ['r', 'b', 'l', 'e']\n",
        "print(my_list)\n",
        "\n",
        "my_list.clear()\n",
        "\n",
        "# Output: []\n",
        "print(my_list)"
      ],
      "metadata": {
        "id": "t8XcuQkj-TXF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การทดสอบการเป็นสมาชิกใน List หรือไม่\n",
        "\n",
        "เราสามารถใช้ keyword in สำหรับการทดสองว่ามีข้อมูลที่ต้องการทดสอบเป็นสมาชิกอยู่ List หรือไม่"
      ],
      "metadata": {
        "id": "glrzMYVA-ruP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = ['p','r','o','b','l','e','m']\n",
        "\n",
        "# Output: True\n",
        "print('p' in my_list)\n",
        "\n",
        "# Output: False\n",
        "print('a' in my_list)\n",
        "\n",
        "# Output: True\n",
        "print('c' not in my_list)"
      ],
      "metadata": {
        "id": "f6LXCNwe-o2D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "### ข้อพึงระวัง"
      ],
      "metadata": {
        "id": "YkjYma_5mABf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, 3, 4]\n",
        "\n",
        "b = a\n",
        "\n",
        "b[0] = 100\n",
        "\n",
        "print(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "peUyhOq9mIcU",
        "outputId": "2f3584e2-1faa-4ebd-aae5-a216f362e865"
      },
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[100, 2, 3, 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import copy\n",
        "\n",
        "a = [1, 2, 3, 4]\n",
        "\n",
        "b = copy.copy(a)\n",
        "\n",
        "b[0] = 100\n",
        "\n",
        "print(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xcCna3ZxmUzJ",
        "outputId": "7ded9da3-8297-4a76-f31f-f70cb67a3b11"
      },
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "5Kj2KfP8l_9r"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "IjFNt9_Q-zHe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tuple"
      ],
      "metadata": {
        "id": "MMW6oeE2_JFE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "ในการเขียนโปรแกรมภาษาไพธอนนั้น Tuple จะมีความคล้ายกับ List แต่ความแตกต่างระหว่างของทั้งสอง คือการที่เราไม่สามารถเปลี่ยนแปลงข้อมูลสมาชิกของ Tuple ได้ ซึ่งแตกต่างกับ List ที่สามารถเปลี่ยนแปลงค่าข้อมูลสมาชิกภายใน List ได้ตลอดเวลา\n",
        "\n"
      ],
      "metadata": {
        "id": "I9WUAlGY_NP5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### ข้อดีของ Tuple\n",
        "\n",
        "โดย Tuples นั้นค่อนข้างคล้ายกับ List ซึ่งทั้งสองจะสามารถใช้งานได้คล้ายกัน\n",
        "\n",
        "อย่างไรก็ตามมีข้อดีบางอย่างในการใช้งาน Tuple ที่เหนือกว่าการใช้งาน List ดังนี้ :\n",
        "\n",
        "1. โดยทั่วไปเราใช้ Tuple สำหรับประเภทข้อมูลที่แตกต่างกัน และ List สำหรับประเภทข้อมูลที่เหมือนกัน (หรือคล้ายกัน)\n",
        "\n",
        "2. เนื่องจาก Tuple จะไม่มีการเปลี่ยนแปลงข้อมูล การทำงานวนซ้ำ (Itering) บน Tuple จะเร็วกว่า List ซึ่งเป็นการเพิ่มประสิทธิภาพการทำงานขึ้นเล็กน้อย\n",
        "\n",
        "3. Tuples มีข้อมูลสมาชิกที่คงที่ ไม่มีการเปลี่ยนแปลง ทำให้สามารถใช้เป็นคีย์สำหรับพจนานุกรมได้ ซึ่งต่างจาก List ที่ไม่สามารถทำได้\n",
        "\n",
        "4. หากมีข้อมูลที่ไม่ต้องการให้ทำการเปลี่ยนแปลง การนำ Tuple มาใช้งานจะรับประกันได้ว่าจะสามารถป้องกันการเขียน หรือแก้ไขข้อมูลสมาชิกได้"
      ],
      "metadata": {
        "id": "FQFLVh1c_k4G"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การสร้าง Tuple\n",
        "\n",
        "Tuple จะถูกสร้างขึ้นโดยวางข้อมูลสมาชิกทั้งหมดไว้ในวงเล็บ () โดยคั่นด้วยเครื่องหมายจุลภาค\n",
        "\n",
        "ภายใน Tuple สามารถมีข้อมูลสมาชิกที่เป็น List ได้หลาย List และอาจมีข้อมูลได้หลายประเภทข้อมูล (integer, float, list, string เป็นต้น)"
      ],
      "metadata": {
        "id": "IIDcq8uR_rMP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# empty tuple\n",
        "# Output: ()\n",
        "my_tuple = () # []\n",
        "print(my_tuple)\n",
        "\n",
        "# tuple having integers\n",
        "# Output: (1, 2, 3)\n",
        "my_tuple = (1, 2, 3)\n",
        "print(my_tuple)\n",
        "\n",
        "# tuple with mixed datatypes\n",
        "# Output: (1, \"Hello\", 3.4)\n",
        "my_tuple = (1, \"Hello\", 3.4)\n",
        "print(my_tuple)\n",
        "\n",
        "# nested tuple\n",
        "# Output: (\"mouse\", [8, 4, 6], (1, 2, 3))\n",
        "my_tuple = (\"mouse\", [8, 4, 6], (1, 2, 3))\n",
        "print(my_tuple)\n",
        "\n",
        "# tuple can be created without parentheses\n",
        "# also called tuple packing\n",
        "# Output: 3, 4.6, \"dog\"\n",
        "\n",
        "my_tuple = 3, 4.6, \"dog\"\n",
        "print(my_tuple)\n",
        "\n",
        "# tuple unpacking is also possible\n",
        "# Output:\n",
        "# 3\n",
        "# 4.6\n",
        "# dog\n",
        "a, b, c = my_tuple\n",
        "print(a)\n",
        "print(b)\n",
        "print(c)"
      ],
      "metadata": {
        "id": "3CB7OuLJ-wcy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### ข้อสังเกตุในการสร้าง Tuple\n",
        "\n",
        "การสร้าง Tuple ที่มีข้อมูลสมาชิกเพียง 1 ตัวนั้น มีข้อน่าสังเกตุ คือ หากใส่ข้อมูลเข้าไปเครื่องหมาย ( ) เลยจะทำให้ตัวแปรภาษาทำการตีความหมายผิดไป จึงจำเป็นจะต้องมีเครื่องหมายจุลภาคต่อท้ายข้อมูลสมาชิกนั้นด้วย เพื่อบ่งบอกว่าสิ่งที่เราสร้างขึ้นนั้นเป็น Tuple"
      ],
      "metadata": {
        "id": "Kp5IkZlg_1rE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# only parentheses is not enough\n",
        "# Output: <class 'str'>\n",
        "my_tuple = (\"hello\")\n",
        "print(type(my_tuple))\n",
        "\n",
        "# need a comma at the end\n",
        "# Output: <class 'tuple'>\n",
        "my_tuple = (\"hello\",)\n",
        "print(type(my_tuple))\n",
        "\n",
        "# parentheses is optional\n",
        "# Output: <class 'tuple'>\n",
        "my_tuple = \"hello\",\n",
        "print(type(my_tuple))"
      ],
      "metadata": {
        "id": "hPBExfbs_wcp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การเปลี่ยนแปลง Tuple\n",
        "\n",
        "Tuple นั้นจะมีลักษณะคงที่ไม่สามารถทำการเปลี่ยนแปลงค่าของสมาชิกหลังจากถูกสร้างขึ้น\n",
        "\n",
        "ซึ่งหมายความว่าข้อมูลสมาชิกของ Tuple ไม่สามารถเปลี่ยนแปลงได้เมื่อมีการกำหนดค่าแล้ว แต่ถ้าข้อมูลสมาชิกภายใน Tuple นั้นเป็นข้อมูลประเภทที่แก้ไขค่าได้เช่น List จะสามารถเปลี่ยนแปลงได้ค่าที่อยู่ภายใน List นั้นได้"
      ],
      "metadata": {
        "id": "urR_dY3FAhXG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_tuple = (4, 2, 3, [6, 5])\n",
        "\n",
        "# เราไม่สามารถเปลี่ยนองค์ประกอบได้\n",
        "\n",
        "# หากคุณยกเลิกการ comment คำสั่งด้านล่าง\n",
        "# คุณจะได้รับข้อความแจ้งข้อผิดพลาด:\n",
        "# TypeError: 'tuple' object does not support item assignment\n",
        "\n",
        "#my_tuple [1] = 9\n",
        "\n",
        "# แต่รายการขององค์ประกอบที่เปลี่ยนแปลงได้สามารถเปลี่ยนแปลงได้\n",
        "# ผลลัพธ์: (4, 2, 3, [9, 5])\n",
        "my_tuple[3][0] = 9\n",
        "print(my_tuple)\n",
        "\n",
        "# tuples สามารถกำหนดใหม่ได้\n",
        "# ผลลัพธ์: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')\n",
        "my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')\n",
        "print(my_tuple)"
      ],
      "metadata": {
        "id": "6J73V_Wx_7oo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_tuple [1] = 9"
      ],
      "metadata": {
        "id": "Zef7f1VVAnY1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "เราสามารถใช้ตัวดำเนินการบวก ( + ) เพื่อรวม Tuple ซึ่งการดำเนินการนี้เรียกว่า Concatenation\n",
        "\n",
        "นอกจากนี้เราสามารถทำซ้ำข้อมูลสมาชิกภายใน Tuple ตามจำนวนครั้งที่ต้องการ โดยใช้ตัวดำเนินการคูณ ( * )\n",
        "\n",
        "โดยผลการดำเนินงานทั้ง + และ * เป็น Tuple ชุดใหม่"
      ],
      "metadata": {
        "id": "Q6grBLkkBI6o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Concatenation\n",
        "\n",
        "# ผลลัพธ์: (1, 2, 3, 4, 5, 6)\n",
        "print((1, 2, 3) + (4, 5, 6))\n",
        "\n",
        "# Repeat\n",
        "# ผลลัพธ์: ('Repeat', 'Repeat', 'Repeat')\n",
        "print((\"Repeat\",) * 3)"
      ],
      "metadata": {
        "id": "chrN-1udBCY7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การลบ Tuple\n",
        "\n",
        "ตามที่กล่าวไว้ข้างต้นเราไม่สามารถเปลี่ยนแปลงข้อมูลสมาชิกภายใน Tuple ได้ นั่นหมายความว่าเราไม่สามารถลบหรือนำข้อมูลออกจาก Tuple ได้\n",
        "\n",
        "แต่ลบสามารถลบ Tuple ทั้งหมดเป็นไปได้โดยใช้คำหลัก del"
      ],
      "metadata": {
        "id": "EnglPJ7NBSfi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')\n",
        "\n",
        "# ไม่สามารถลบรายการได้\n",
        "# ถ้ายกเลิกการ comment คำสั่งด้านล่าง,\n",
        "# คุณจะได้รับข้อความแจ้งข้อผิดพลาด:\n",
        "# TypeError: 'tuple' object doesn't support item deletion\n",
        "\n",
        "#del my_tuple [3]\n",
        "\n",
        "# สามารถลบ Tuple ทั้งหมดได้\n",
        "# NameError: name 'my_tuple' is not defined\n",
        "del my_tuple\n",
        "\n",
        "my_tuple"
      ],
      "metadata": {
        "id": "TfnN49gkBM2i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Dictionary"
      ],
      "metadata": {
        "id": "ZrTfnJIODPtx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Dictionary ในภาษา Python คืออะไร\n",
        "\n",
        "Dictionary หรือ พจนานุกรมในภาษา Python คือชุดของข้อมูลที่ไม่มีลำดับ โดยพจนานุกรมจะแตกต่างจากชนิดข้มูลอื่น ๆ ซึ่งจะมีเพียงแค่ข้อมูลเป็นสมาชิกภายในเท่านั้น แต่ว่าพจนานุกรมนั้นข้อมูลสมาชิกแต่ละตัวจะประกอบไปด้วยคู่ของ คีย์ : ค่าข้อมูล\n",
        "\n",
        "เราสามารถเข้าถึงค่าข้อมูลสมาชิกภายในพจนานุกรมได้ก็ต่อเมื่อเราทราบคีย์ที่ในอ้างอิงถึงข้อมูลนั้น\n",
        "\n"
      ],
      "metadata": {
        "id": "TjcSHfo1DURs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### วิธีการสร้างพจนานุกรม?\n",
        "การสร้างพจนานุกรมทำได้ง่าย เพียงแค่วางข้อมูลสมาชิกภายในวงเล็บปีกกา {} โดยคั่นด้วยเครื่องหมายจุลภาค\n",
        "\n",
        "รายการมีคีย์และค่าข้อมูลสมาชิก ที่สอดคล้องกันแสดงเป็นคู่ คือ คีย์ : ค่า\n",
        "\n",
        "แม้ว่าค่าจะเป็นชนิดข้อมูลใดก็ตามและสามารถทำซ้ำได้ คีย์ต้องเป็นประเภทที่ไม่เปลี่ยนรูป (สตริง, จำนวน, หรือ tuple ที่มีองค์ประกอบไม่เปลี่ยนรูป) และต้องไม่ซ้ำกัน"
      ],
      "metadata": {
        "id": "z7CvsPGpDeQK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# empty dictionary\n",
        "my_dict = {}\n",
        "\n",
        "my_dict = {\"key\": \"value\"}\n",
        "\n",
        "my_dic = {\"name\": \"Phisan\", 'last_name': 'Sookkhee'}\n",
        "\n",
        "# dictionary with integer keys\n",
        "my_dict = {1: 'apple', 2: 'ball'}\n",
        "\n",
        "# dictionary with mixed keys\n",
        "my_dict = {'name': 'John', 1: [2, 4, 3]}\n",
        "\n",
        "# using dict()\n",
        "my_dict = dict({1:'apple', 2:'ball'})\n",
        "\n",
        "# from sequence having each item as a pair\n",
        "my_dict = dict([(1,'apple'), (2,'ball')])"
      ],
      "metadata": {
        "id": "LASx6bW8BYCU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "non-structure data\n",
        "นักศึกษาคนที่ 1 นายพิศาล สุขขี รหัส 123456\n",
        "นักศึกษาคนที่ 2 นายสายฟ้า ธานี รหัส 098764222\n",
        "นักศึกษาคนที่ 3 เจษฎา ตอนศรี รหัส 9999282727\n",
        "'''\n",
        "\n",
        "# structure data\n",
        "my_students = {\n",
        "    '123456' : {\n",
        "        'name': 'นายพิศาล',\n",
        "        'lname': 'สุขขี',\n",
        "    },\n",
        "    '098764222': {\n",
        "        'name': 'สายฟ้า',\n",
        "        'lname': 'ธานี',\n",
        "    },\n",
        "    '9999282727': {\n",
        "        'name': 'เจษฎา',\n",
        "        'lname': 'ตอนศรี',\n",
        "    }\n",
        "}"
      ],
      "metadata": {
        "id": "UablrGc7Di-f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_students.get('123456').get('name')"
      ],
      "metadata": {
        "id": "vFHw3FhrDpCJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### วิธีการเข้าถึงข้อมูลสมาชิกภายในพจนานุกรม\n",
        "\n",
        "แม้ว่าการจัดทำดัชนีจะมีลักษณะคล้ายกับข้อมูลประเภทอื่น ๆ ในการเข้าถึงค่าข้อมูลสมาชิกในพจนานุกรมจะใช้คีย์ คีย์สามารถใช้ได้ทั้งภายในวงเล็บเหลี่ยม หรือด้วยเมธอด get( )\n",
        "\n",
        "ความแตกต่างในขณะที่ใช้ get( ) คือจะทำการส่งกลับค่า None แทนที่จะเป็น KeyError ถ้าหากไม่พบคีย์"
      ],
      "metadata": {
        "id": "GO7IYSKfDwSc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_dict = {'name':'Jack', 'age': 26}\n",
        "\n",
        "# Output: Jack\n",
        "print(my_dict['name'])\n",
        "\n",
        "# Output: 26\n",
        "print(my_dict.get('age'))\n",
        "\n",
        "# Trying to access keys which doesn't exist throws error\n",
        "# my_dict.get('address')\n",
        "# my_dict['address']"
      ],
      "metadata": {
        "id": "b06EVNI3Dpc9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "profile = {\n",
        "    \"name\": \"Phisan\",\n",
        "    \"lname\": \"Sookkhee\",\n",
        "    \"age\": 18,\n",
        "}\n",
        "\n",
        "profile.get(\"age\")"
      ],
      "metadata": {
        "id": "eLeBY9XHD0u2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### วิธีเปลี่ยนหรือเพิ่มข้อมูลสมาชิกในพจนานุกรม\n",
        "\n",
        "พจนานุกรมสามารถเปลี่ยนแปลงค่าข้อมูลสมาชิกได้\n",
        "\n",
        "เราสามารถเพิ่มข้อมูลใหม่ หรือเปลี่ยนค่าของข้อมูลที่มีอยู่โดยใช้โอเปอเรเตอร์กำหนดค่า ( = )\n",
        "\n",
        "หากว่ามีคีย์อยู่แล้วในพจนานุกรม ค่าของข้อมูลใหม่จะได้รับการอัพเดตในคีย์ที่มีอยู่เดิม แต่หากไม่มีคีย์นั้นอยู่จะมีการเพิ่มคีย์ใหม่ : ค่าลงในพจนานุกรม"
      ],
      "metadata": {
        "id": "bqmcdBA0LH1x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_dict = {'name': 'Jack', 'age': 26}\n",
        "\n",
        "# update value\n",
        "my_dict ['age'] = 27\n",
        "\n",
        "#Output: {'age': 27, 'name': 'Jack'}\n",
        "print(my_dict)\n",
        "\n",
        "# เพิ่มรายการ\n",
        "my_dict ['address'] = 'Downtown'\n",
        "\n",
        "# ผลลัพธ์: {'address': 'Downtown', 'age': 27, 'name': 'Jack'}\n",
        "print(my_dict)"
      ],
      "metadata": {
        "id": "ggfFyNp9D3EH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_dict = {'name': 'Jack', 'age': 26}\n",
        "my_dict[\"address\"] = \"40/6\"\n",
        "my_dict['age'] = 18"
      ],
      "metadata": {
        "id": "2ySchb6LLOKb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_dict"
      ],
      "metadata": {
        "id": "yPz2N3VNLQDN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การลบพจนานุกรม หรือลบข้อมูลสมาชิกออกจากพจนานุกรม\n",
        "\n",
        "เราสามารถลบข้อมูลสมาชิกในพจนานุกรมโดยใช้เมธอด pop( ) โดยวิธีนี้จะทำการลบข้อมูลสมาชิกผ่านคีย์ที่ระบุและส่งคืนค่าออกมาจากพจนานุกรม\n",
        "\n",
        "และเราสามารถใช้เมทธอด popitem( ) เพื่อลบและส่งคืนค่าข้อมูลสมาชิกที่กำหนดเอง (อ้างอิงจากคีย์) จากพจนานุกรม\n",
        "\n",
        "และสามารถลบข้อมูลทั้งหมดออกได้ในครั้งเดียวโดยใช้เมธอด clear( )\n",
        "\n",
        "นอกจากนี้เรายังสามารถใช้คำสำคัญ del เพื่อลบทั้งพจนานุกรมด้วย"
      ],
      "metadata": {
        "id": "P6s7TPSHLXB4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# create a dictionary\n",
        "squares = {1:1, 2:4, 3:9, 4:16, 5:25}\n",
        "\n",
        "# remove a particular item\n",
        "# Output: 16\n",
        "print(squares.pop(4))\n",
        "\n",
        "# Output: {1: 1, 2: 4, 3: 9, 5: 25}\n",
        "print(squares)\n",
        "\n",
        "# remove an arbitrary item\n",
        "# Output: (1, 1)\n",
        "print(squares.popitem())\n",
        "\n",
        "# Output: {2: 4, 3: 9, 5: 25}\n",
        "print(squares)\n",
        "\n",
        "# Output: {2: 4, 3: 9}\n",
        "print(squares)\n",
        "\n",
        "# remove all items\n",
        "squares.clear()\n",
        "\n",
        "# Output: {}\n",
        "print(squares)\n",
        "\n",
        "# delete the dictionary itself\n",
        "del squares"
      ],
      "metadata": {
        "id": "8SSPZ4gMLTti"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_dict = {'name': 'Jack', 'age': 18, 'address': '40/6'}\n",
        "\n",
        "del my_dict[\"address\"]"
      ],
      "metadata": {
        "id": "SbQnK62uLfo6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_dict"
      ],
      "metadata": {
        "id": "a6zQm6EhLeYm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Set\n",
        "\n",
        "เซต (Set) คือ\n",
        "\n",
        "เซตในภาษาไพธอนเป็นโครงสร้างข้อมูลที่เหมือนกันกับเซตทางคณิตศาสตร์ อาจประกอบด้วยข้อมูลสมาชิกต่าง ๆ โดยไม่คำนึงถึงลำดับในการจัดเก็บ และข้อมูลสมาชิกทุกตัวภายในเซตมีเอกลักษณ์ (ไม่มีรายการที่ซ้ำกัน)\n",
        "\n",
        "เราสามารถเพิ่มและลบข้อมูลสมาชิกของเซต เราสามารถใช้ข้อมูลสมาชิกของเชตในการทำซ้ำเช่นเดียวกับลิสต์ ตลอดจนสามารถใช้การดำเนินการมาตรฐานที่เกี่ยวกับเซต เช่น union, intersection, difference, symmetric difference นอกจากนั้นยังสามารถตรวจสอบว่าข้อมูลใด ๆ เป็นสมาชิกภายในเซตหรือไม่\n",
        "\n",
        "ลำดับของข้อมูลสมาชิกภายในเซตจะไม่ได้ถูกกำหนดไว้ และชนิดข้อมูลที่เปลี่ยนแปลงไม่ได้ใด ๆ สามารถเป็นเป็นองค์ประกอบของเซตได้ เช่น จำนวน, จำนวนจริง, ข้อความ, ทัพเพิล เป็นต้น ประเภทข้อมูลที่เปลี่ยนแปลงได้ ไม่สามารถเป็นองค์ประกอบของเซตได้ โดยเฉพาะอย่างยิ่ง ลิสต์ นั้นไม่สามารถเป็นข้อมูลสมาชิกของเซตได้ และเซตใด ๆ ไม่สามารถใช้เป็นข้อมูลสมาชิกภายในเซตอื่น ๆ ได้ นั่นคือ จะไม่มีเซตภายในเซตได้\n",
        "\n",
        "เซตสมารถสร้างขึ้นโดยการวางข้อมูลทั้งหมด (element) ภายในเครื่องหมายวงเล็บปีกกา {} คั่นด้วยเครื่องหมายจุลภาคหรือใช้ฟังก์ชั่น set()\n",
        "\n",
        "โดยเซตนั้นสามารถมีข้อมูลสมาชิกจำนวนมาก และอาจมีหลากหลายประเภท (จำนวน, จำนวนจริง, ข้อความ เป็นต้น) แต่สมาชิกภายในเซตต้องไม่เป็นข้อมูลประเภทที่มีขนาดไม่คงตัว เช่น ลิสต์ หรือ ดิกชันนารี"
      ],
      "metadata": {
        "id": "H9nAijcALr_m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# เซตของจำนวนเต็ม\n",
        "my_set = {1, 2, 3}\n",
        "print(my_set)\n",
        "\n",
        "# เซตที่มีข้อมูลสมาชิกหลากหลายประเภทข้อมูล\n",
        "my_set = {1.0, \"Hello\", (1, 2, 3)}\n",
        "print(my_set)"
      ],
      "metadata": {
        "id": "qBtpC_VrLjzf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# ข้อมูลสมาชิกภายในเซตจะไม่สามารถซ้ำกันได้\n",
        "my_set = {1,2,3,4,3,2}\n",
        "print(my_set)\n",
        "\n",
        "# สมาชิกภายในเซตต้องไม่เป็นข้อมูลประเภทที่แก้ไขได้\n",
        "# เช่น [3, 4] เป็นลิสต์ที่แก้ไขได้\n",
        "\n",
        "# บรรทัดที่ 11 จะทำให้เกิดข้อผิดพลาด\n",
        "#เพราะไม่สามารถใช้ลิสต์ในการเป็นข้อมูลสมาชิกภายในเซต\n",
        "# TypeError: unhashable type: 'list'\n",
        "my_set = {1, 2, [3, 4]}\n",
        "\n",
        "# เราสามารถสร้างเซตจากลิสต์ได้เลย\n",
        "# Output: {1, 2, 3}\n",
        "my_set = set([1,2,3,2])\n",
        "print(my_set)"
      ],
      "metadata": {
        "id": "t2LQYK-YL2_5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "การสร้างเซตที่ว่างเปล่าจะมีความยุ่งยากเล็กน้อย\n",
        "\n",
        "การใช้วงเล็บปีกกาที่ว่างเปล่า {} เพื่อประกาศตัวแปร จะทำให้เกิดพจนานุกรมว่างเปล่าในภาษาไพธอน (ไม่ใช่เซต)\n",
        "\n",
        "ดังนั้นเมื่อต้องการสร้างเซตเปล่า ๆ ที่ไม่มีข้อมูลสมาชิกใด ๆ ภายในเซต เราจะใช้ฟังก์ชัน set () โดยไม่มีอาร์กิวเมนต์ใด ๆ แทน {}"
      ],
      "metadata": {
        "id": "nNPEJ0PMMGdL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# initialize a with {}\n",
        "a = {}\n",
        "\n",
        "# check data type of a\n",
        "# Output: <class 'dict'>\n",
        "print(type(a))\n",
        "\n",
        "# initialize a with set()\n",
        "a = set()\n",
        "\n",
        "# check data type of a\n",
        "# Output: <class 'set'>\n",
        "print(type(a))"
      ],
      "metadata": {
        "id": "YAcbXAqcL45Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### วิธีการแก้ไขเซตในภาษาไพธอน\n",
        "\n",
        "สำหรับเซตนั้น ข้อมูลสมาชิกภายในเซตถูกจัดเก็บอย่างไม่เป็นลำดับ ดังนั้นจัดทำดัชนีเพื่ออ้างอิงถึงข้อมูลสมาชิกแต่ละตัวจึงไม่มีความหมาย\n",
        "\n",
        "เราไม่สามารถเข้าถึงหรือเปลี่ยนข้อมูลสมาชิกของเซตโดยใช้การจัดทำดัชนีหรือการหั่นส่วน ซึ่งเป็นการดำเนินการที่เซตไม่ให้การรองรับ\n",
        "\n",
        "เราสามารถเพิ่มข้อมูลสมาชิกเพียงหนึ่งตัวโดยใช้เมธอด add() และ ข้อมูลสมาชิกหลายตัวโดยใช้เมธอด update() ในการ update() สามารถใช้ tuples, list, strings หรือ other sets เป็นอาร์กิวเมนต์ได้ ซึ่งจะต้องหลีกเลี่ยงความซ้ำซ้อนของข้อมูล"
      ],
      "metadata": {
        "id": "7UBJXFV1MMBs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# ตั้งต่าเริ่มต้นให้ตัวแปร\n",
        "my_set = {1,3}\n",
        "print(my_set)\n",
        "\n",
        "# หากเปิด comment ในบรรทัดที่ 8 จะพบ Error\n",
        "# TypeError: 'set' object does not support indexing\n",
        "\n",
        "# my_set[0]\n",
        "\n",
        "# เพ่ิมข้อมูล 1 ตัวเข้าสู่เซต\n",
        "# ผลลัพธ์: {1, 2, 3}\n",
        "my_set.add(2)\n",
        "print(my_set)\n",
        "\n",
        "# เพ่ิมข้อมูลหลายตัวเข้าสู่เซต\n",
        "# ผลลัพธ์: {1, 2, 3, 4}\n",
        "my_set.update([2,3,4])\n",
        "print(my_set)\n",
        "\n",
        "# เพิ่มข้อมูลหลายตัวจากลิสต์ และเซต\n",
        "# Output: {1, 2, 3, 4, 5, 6, 8}\n",
        "my_set.update([4,5], {1,6,8})\n",
        "print(my_set)"
      ],
      "metadata": {
        "id": "f8ymxhyBMIpO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การลบข้อมูลสมาชิกภายในเซต\n",
        "\n",
        "ข้อมูลสมาชิกของเซตสามารถที่จะถูกลบออกจากเซตได้โดยใช้เมธอด discard() และ remove()\n",
        "\n",
        "ข้อแตกต่างระหว่างสองคือในขณะที่ใช้ discard() หากไม่มีรายการอยู่ในเซ็ตก็จะไม่มีการเปลี่ยนแปลง remove() จะทำให้เกิดข้อผิดพลาดในสภาพดังกล่าว\n",
        "\n",
        "ดังแสดงได้ในตัวอย่างด้านล่าง"
      ],
      "metadata": {
        "id": "f3oVaUI5MYAW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# กำหนดค่าเริ่มต้นให้กับตัวแปร my_set\n",
        "my_set = {1, 3, 4, 5, 6}\n",
        "print(my_set)\n",
        "\n",
        "# การลบข้อมูลสมาชิกโดยใช้เมธอด discard()\n",
        "# Output: {1, 3, 5, 6}\n",
        "my_set.discard(4)\n",
        "print(my_set)\n",
        "\n",
        "# การลบข้อมูลสมาชิกโดยใช้เมธอด remove()\n",
        "# Output: {1, 3, 5}\n",
        "my_set.remove(6)\n",
        "print(my_set)\n",
        "\n",
        "# การลบข้อมูลสมาชิกที่ไม่ปรากฏอยู่ในเซต\n",
        "# โดยใช้เมธอด discard()\n",
        "# Output: {1, 3, 5}\n",
        "my_set.discard(2)\n",
        "print(my_set)\n",
        "\n",
        "# การลบข้อมูลสมาชิกที่ไม่ปรากฏอยู่ในเซต\n",
        "# โดยใช้เมธอด remove()\n",
        "# จะมทำให้ปรากฏ Error\n",
        "# Output: KeyError: 2\n",
        "\n",
        "my_set.remove(2)"
      ],
      "metadata": {
        "id": "ykibBo8dMUUl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "ในทำนองเดียวกันเราสามารถลบและส่งคืนค่าข้อมูลสมาชิกได้โดยใช้เมธอด pop ()\n",
        "\n",
        "แต่เนื่องด้วยข้อมูลภายในเซตถูกจัดเก็บอย่างไม่เป็นลำดับ ทำให้ไม่สามารถคาดคะเนล่วงหน้าได้ว่าผลของการใช้เมธอด pop() นั้นจะทำให้ได้ข้อมูลอะไรออกมาในขณะนั้น\n",
        "\n",
        "และนอกจากนี้เรายังสามารถลบรายการทั้งหมดออกจากเซตโดยใช้เมธอด clear ()"
      ],
      "metadata": {
        "id": "s-tP0IQMMorJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# ผลลัพธ์: เซตที่มีข้อมูลสมาชิกที่ไม่ซ้ำกัน\n",
        "my_set = set(\"HelloWorld\")\n",
        "print(my_set)\n",
        "\n",
        "# ทำการ pop() ข้อมูลภายในเซต\n",
        "# ผลลัพธ์: ข้อมูลถูก pop() แบบสุ่ม\n",
        "print(my_set.pop())\n",
        "\n",
        "# pop() ข้อมูล\n",
        "my_set.pop()\n",
        "print(my_set)\n",
        "\n",
        "# ล้างข้อมูลภายในเซตทั้งหมด\n",
        "# ผลลัพธ์: set() - เซตว่าง\n",
        "my_set.clear()\n",
        "print(my_set)"
      ],
      "metadata": {
        "id": "4sldD3N3MeZ_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### การดำเนินการกับเซต\n",
        "\n",
        "เซตสามารถนำไปใช้ในการดำเนินการทางคณิตศาสตร์ได้ เช่น union, intersection, difference and symmetric difference\n",
        "\n",
        "ลองพิจารณาการดำเนินการระหว่างเซต 2 เซตต่อไปนี้"
      ],
      "metadata": {
        "id": "WM2i4RTLM2F0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = {1, 2, 3, 4, 5}\n",
        "B = {4, 5, 6, 7, 8}"
      ],
      "metadata": {
        "id": "SDpCrkUJMtOe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Set Union\n",
        "\n",
        "union ของเซต A และเซต B คือ เซตที่ประกอบไปด้วยข้อมูลสมาชิกจากเชต A และเซต B\n",
        "\n",
        "union สมารถดำเนินการโดยใช้เครื่องหมาย | หรือสามารถดำเนินการได้โดยใช้เมธอด union()"
      ],
      "metadata": {
        "id": "TBVcDkSQM9N6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = {1, 2, 3, 4, 5}\n",
        "B = {4, 5, 6, 7, 8}\n",
        "\n",
        "# ใช้ | operator\n",
        "print(A | B)"
      ],
      "metadata": {
        "id": "CyVyZxlFM540"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "A.union(B)"
      ],
      "metadata": {
        "id": "DEzvD5nnNFKT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "B.union(A)"
      ],
      "metadata": {
        "id": "4G7EJMqiNJDx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Set Intersection\n",
        "\n",
        "Intersection ของเซต A และเซต B คือ เซตของข้อมูลสมาชิกที่มีอยู่ในเซต A และเซต B\n",
        "\n",
        "การ Intersection สามารถดำเนินการโดยใช้เครื่องหมาย & หรือสามารถทำได้โดยใช้เมธอด intersection()"
      ],
      "metadata": {
        "id": "9HS_ktueNQB7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = {1, 2, 3, 4, 5}\n",
        "B = {4, 5, 6, 7, 8}\n",
        "\n",
        "# ใช้ & operator\n",
        "print(A & B)"
      ],
      "metadata": {
        "id": "pcHRdpUqNKZR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "A.intersection(B)"
      ],
      "metadata": {
        "id": "fhChKq0INV3D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### ความต่างระหว่างเซต\n",
        "\n",
        "ความต่างของเซต A และเซต B (A - B) คือเซตที่ประกอบไปด้วยข้อมูลสมาชิกที่อยู่ใน A แต่ไม่อยู่ใน B เช่นเดียวกัน B - A คือเซตที่ประกอบไปด้วยข้อมูลสมาชิกที่อยู่ใน B แต่ไม่อยู่ใน A\n",
        "\n",
        "การหาความต่างระหว่างเซตสามารถดำเนินการโดยใช้ตัวดำเนินการ - เช่นเดียวกันสามารถดำเนินการโดยใช้เมธอด difference()"
      ],
      "metadata": {
        "id": "VPpIA4I9NcyZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = {1, 2, 3, 4, 5}\n",
        "B = {4, 5, 6, 7, 8}\n",
        "\n",
        "# ใช้ - operator on A\n",
        "print(A - B)"
      ],
      "metadata": {
        "id": "Nfd04N8VNX9v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "A.difference(B)"
      ],
      "metadata": {
        "id": "Wx7IX_ohNhSo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "B - A"
      ],
      "metadata": {
        "id": "RzJk8ENMNisM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "B - A"
      ],
      "metadata": {
        "id": "C-3knGDGNj_w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### ความต่างแบบสมมาตรระหว่างเซต\n",
        "\n",
        "ความแตกต่างแบบสมมาตรระหว่างเซต A และเซต B คือเซตของข้อมูลสมาชิกจากทั้งเซต A และเซต B ยกเว้นข้อมูลสมาชิกที่มีอยู่ทั่วไปในทั้งสองเซต\n",
        "\n",
        "ความแตกต่างแบบสมมาตรจะดำเนินการโดยใช้ตัวดำเนินการ ^ และสามารถทำได้โดยใช้เมธอด symmetric_difference()"
      ],
      "metadata": {
        "id": "UE2rMIqFPHm2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = {1, 2, 3, 4, 5}\n",
        "B = {4, 5, 6, 7, 8}\n",
        "\n",
        "# ใช้ ^ operator\n",
        "print(A ^ B)"
      ],
      "metadata": {
        "id": "_0cFmJIMPNrs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "A.symmetric_difference(B)"
      ],
      "metadata": {
        "id": "LNn4IXfGNlig"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "B.symmetric_difference(A)"
      ],
      "metadata": {
        "id": "qoWGNiZEPQ9X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "X01ZZJs5PejG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## แบบฝึกหัด"
      ],
      "metadata": {
        "id": "IvifERzLPxd-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "xEqkZegcPxbp"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "-N0o8hU8PXAD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>"
      ],
      "metadata": {
        "id": "atqtnNvvQCpM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# การคำนวณทางคณิตศาสตร์\n",
        "\n"
      ],
      "metadata": {
        "id": "naATAUr2T4_H"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### คำสั่งเลขคณิต (arithmetic operations) และนิพจน์ทางคณิตศาสตร์ (mathematical expression)\n",
        "\n",
        "* เราสามารถทำการคำนวณทางคณิตศาสตร์ได้ โดยใช้เครื่องหมายบวก +, ลบ -, คูณ *, และหาร / กับตัวเลขได้\n",
        "* ข้อสังเกต: เราจะใช้เครื่องหมายดอกจัน * แทนการคูณนะครับ\n",
        "\n",
        "* เช่น ถ้าเราสั่งให้คอมพิวเตอร์คำนวณค่าของนิพจน์ทางคณิตศาสตร์  5×2+10  คอมพิวเตอร์ก็จะคำนวณผลลัพธ์ให้ทันที"
      ],
      "metadata": {
        "id": "eUeSnXhhUSMJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "5 * 2 + 10"
      ],
      "metadata": {
        "id": "kR9Oiv-iQDmD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- ถ้าเราสั่งให้คอมพิวเตอร์คำนวณค่าของนิพจน์ $ 10 + \\frac{5}{2} $ เราจะได้ผลลัพธ์ดังนี้ครับ"
      ],
      "metadata": {
        "id": "CR4N_bhtUZ0I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "10 + 5 / 2"
      ],
      "metadata": {
        "id": "p_wyXYw6UfKj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- จะสังเกตได้ว่า คอมพิวเตอร์คำนวณการหาร 5 / 2 และใส่ค่าทศนิยมให้โดยอัตโนมัติครับ"
      ],
      "metadata": {
        "id": "DB3qyNE6UZxM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<hr>\n",
        "\n",
        "**เกร็ดน่ารู้** ตัวดำเนินการทางคณิตศาสตร์\n",
        "\n",
        "ตัวดำเนินการสำหรับการบวก ลบ คูณ และหาร ใน python ใช้เครื่องหมาย +, -, * และ / ตามลำดับ\n",
        "\n",
        "นอกจากนี้แล้วยังมีการใช้เครื่องหมาย **, //, % ซึ่งหมายถึงการยกกำลัง, การหารปัดเศษทิ้ง และเศษที่ได้จากการหาร ตามลำดับ\n",
        "\n",
        "<hr>"
      ],
      "metadata": {
        "id": "pUo4iGWijw41"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "4**3"
      ],
      "metadata": {
        "id": "y_T9AovRj0R_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "7//3"
      ],
      "metadata": {
        "id": "y0zlNm5cj0PA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "7%3"
      ],
      "metadata": {
        "id": "_De-jUjbj3qz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "ตัวอย่าง ทอนเท่าไร\n",
        "\n",
        "นักเรียนซื้อแฟลชไดรฟ์ ขนาด 32 GB ราคา 117 บาท ที่ร้านสะดวกซื้อ โดยจ่ายเงินด้วยธนบัตรหนึ่งร้อยบาท 2 ใบ ในลิ้นชักเก็บเงินของร้าน มีแต่ธนบัตร 20 บาท และเหรียญหนึ่งบาท พนักงานจะต้องทอนเงินเป็นธนบัตร 20 บาท จำนวนกี่ใบ และเหรียญหนึ่งบาทจำนวนกี่เหรียญ?"
      ],
      "metadata": {
        "id": "gAmuw3xQj9zg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "change = 200 - 177\n",
        "note20 = change//20\n",
        "coin1 = change % 20\n",
        "\n",
        "print(\"เงินทอนทั้งหมด\", change, \"บาท\")\n",
        "print(\"เป็นธนบัตรยี่สิบบาท จำนวน\", note20, \"ใบ\")\n",
        "print(\"เป็นหนึ่งบาท จำนวน\", coin1, \"เหรียญ\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QdzoDAouj_pY",
        "outputId": "b23a4402-1bb3-4ccd-f54d-4adc364f981b"
      },
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "เงินทอนทั้งหมด 23 บาท\n",
            "เป็นธนบัตรยี่สิบบาท จำนวน 1 ใบ\n",
            "เป็นหนึ่งบาท จำนวน 3 เหรียญ\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### แบบฝึกหัด\n"
      ],
      "metadata": {
        "id": "ZKRq3YUQUqgI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "เรามาลองคำนวณค่าของนิพจน์ทางคณิตศาสตร์ต่อไปนี้กันดูบ้างครับ\n",
        "\n",
        "1. $ \\frac{3}{4} + \\frac{1}{4} $"
      ],
      "metadata": {
        "id": "DmenGyChU3sh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# ข้อที่ 1\n",
        "\n"
      ],
      "metadata": {
        "id": "G5evfAlRVIUM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. $ 1 + 6 \\times 8 - 7 $"
      ],
      "metadata": {
        "id": "uPXGFoEpU-4T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# ข้อที่ 2\n",
        "\n"
      ],
      "metadata": {
        "id": "JolSbB62UjQV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. $ 5 \\times 6 + 7 \\times 8 - \\frac{2}{5} $"
      ],
      "metadata": {
        "id": "YY1sDqRkU6ee"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# ข้อที่ 3\n",
        "\n"
      ],
      "metadata": {
        "id": "9wrZB3_AYcIP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### วงเล็บในนิพจน์ทางคณิตศาสตร์\n",
        "\n",
        "- ทั้งนี้ เราสามารถใช้เครื่องหมายวงเล็บ `( )` ได้เหมือนกับนิพจน์ทางคณิตศาสตร์ปกติเลยครับ\n",
        "- เช่น เราสามารถคำนวณค่าของนิพจน์ $ 4 \\times 3 + (1 + 2) / 4 $ ได้ด้วยคำสั่งนี้"
      ],
      "metadata": {
        "id": "ieJuDtiUVfUc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "4 * 3 + (1 + 2) / 4"
      ],
      "metadata": {
        "id": "hxKyfx0SVlhB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- ข้อแตกต่างคือ ในกรณีที่มีวงเล็บซ้อนวงเล็บ เราจะใช้เครื่องหมายวงเล็บ `( )` เสมอ <u>**ห้ามใช้**</u>เครื่องหมายก้ามปู `[ ]` และเครื่องหมายปีกกา `{ }` โดยเด็ดขาด\n",
        "- เช่น ถ้าเราจะคำนวณค่าของนิพจน์ $ \\left( \\left[ 1 / \\left\\{ 2 + 3 \\right\\} \\right] \\times 4 + 5 \\right) / 6 $ เราจะต้องเปลี่ยนก้ามปูและปีกกากลับมาเป็นวงเล็บก่อนเสมอ"
      ],
      "metadata": {
        "id": "ZSNf82jlVfRV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "((1 / (2 + 3)) * 4 + 5) / 6"
      ],
      "metadata": {
        "id": "v4iSg0wWU85M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- **หัวใจ:** เครื่องหมายวงเล็บมีหน้าที่เปลี่ยนลำดับการทำงาน โดยจะเริ่มทำในวงเล็บก่อนเสมอ โดยลำดับการทำงานจะเริ่มจาก (1) ทำในวงเล็บ (2) คูณและหาร (3) บวกและลบ\n",
        "- เช่น ลองสังเกตผลลัพธ์ของนิพจน์ทั้งสองนี้ครับ: $ (1 + 2) \\times 3 $ กับ $ 1 + (2 \\times 3) $"
      ],
      "metadata": {
        "id": "BUG7yKXwVvE8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(1 + 2) * 3"
      ],
      "metadata": {
        "id": "hCXDKEjDVz6O"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "1 + (2 * 3)"
      ],
      "metadata": {
        "id": "4wgvki-HV0uO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "ทั้งนี้ขอให้ท่านระมัดระวังการใช้เครื่องหมายคูณ `*` และหาร `/` ด้วยนะครับ เพราะถ้าหากไม่ระบุวงเล็บให้ชัดเจน ลำดับการคำนวณก็อาจจะไม่เป็นไปตามที่ท่านต้องการได้"
      ],
      "metadata": {
        "id": "XjE79WWuVvB6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### แบบฝึกหัด"
      ],
      "metadata": {
        "id": "9IUfRJixWDvx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "เรามาลองคำนวณค่าของนิพจน์ทางคณิตศาสตร์ต่อไปนี้กันครับ\n",
        "\n",
        "1. $ 3 \\times (4 + 1 - 2 \\times 5) $"
      ],
      "metadata": {
        "id": "58ufl1fyWDso"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "AUszZeOhVtTa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. $ \\frac{1 + 2 + 3}{4 + 5 + 6} $   \n",
        "\n",
        "\n",
        "[**หมายเหตุ:** โปรดเลือกการใช้เครื่องหมายวงเล็บด้วยความระมัดระวัง]"
      ],
      "metadata": {
        "id": "OY7aSqltWSJZ"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "gCZRh_lYYR6j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### เครื่องหมายยกกำลัง (power) และการถอดราก (root)\n",
        "\n",
        "- เครื่องหมายยกกำลังในภาษา Python จะใช้เครื่องหมาย `**` (ดอกจันเขียนติดกัน 2 ดวง) ครับ\n",
        "- เช่น ถ้าเราจะคำนวณค่าของนิพจน์ $ 2^5 $ เราจะใช้คำสั่งว่า"
      ],
      "metadata": {
        "id": "dPISCAl6WZFb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "2 ** 5"
      ],
      "metadata": {
        "id": "aG2dpiDIWTXw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- เมื่อเรานำเครื่องหมายยกกำลังมาใส่ในนิพจน์ทางคณิตศาสตร์ ลำดับการทำงานจะเปลี่ยนไปตามนี้ครับ\n",
        "  1. ทำในวงเล็บก่อน\n",
        "  2. ทำเครื่องหมายยกกำลัง\n",
        "  3. ทำเครื่องหมายคูณและหาร\n",
        "  4. ทำเครื่องหมายบวกและลบ\n",
        "- เช่น ลองสังเกตการคำนวณค่าของนิพจน์ 3 ตัวนี้กันครับ: `(2 * 5) ** 3`, `2 * (5 ** 3)`, และ `2 * 5 ** 3`"
      ],
      "metadata": {
        "id": "EYvIF2paWd6b"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(2 * 5) ** 3"
      ],
      "metadata": {
        "id": "xWx-horrWfwc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "2 * (5 ** 3)"
      ],
      "metadata": {
        "id": "2Lp9itJcWmmv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "2 * 5 ** 3"
      ],
      "metadata": {
        "id": "znvsMeI8Wn01"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- ดังนั้นเพื่อความปลอดภัย เราจึงนิยมเขียนเครื่องหมายยกกำลัง `**` ติดกับตัวเลข เพื่อให้เป็นที่รู้กันว่า ถ้าหากไม่มีวงเล็บ เราจะเริ่มทำจากเครื่องหมายยกกำลังก่อนเสมอ เช่น เราจะเขียนนิพจน์ $ 2 \\times 5^3 $ ด้วยคำสั่ง `2 * 5**3` เป็นต้น"
      ],
      "metadata": {
        "id": "poDR5vSlWsNu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "- นอกจากนี้เรายังสามารถคำนวณค่าราก\n",
        "\n",
        "(root) ได้โดยการใช้สูตร:\n",
        "\n",
        "$$ \\sqrt[r]{a} = a^{1/r} $$\n",
        "\n",
        "- เช่น เราสามารถคำนวณค่า $ \\sqrt[3]{8} $ (รากที่ 3 ของ 8) ได้โดยคำสั่ง `8**(1/3)`"
      ],
      "metadata": {
        "id": "skVUl4jwWyOc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "8**(1/3)"
      ],
      "metadata": {
        "id": "CzcqcrdwWpQ7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### แบบฝึกหัด"
      ],
      "metadata": {
        "id": "RAWbKOrRXC8N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "เรามาคำนวณค่าของนิพจน์ดังต่อไปนี้กันครับ\n",
        "\n",
        "1. $ 3^{5 + 3/4} $"
      ],
      "metadata": {
        "id": "8CXbTrjlXGnt"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "03H0NxzOXH8I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. $ \\sqrt[2]{\\left( 7 + 3 \\times 4 \\right)} $"
      ],
      "metadata": {
        "id": "_4g3mmXFXMEc"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "GMoHSUKaW86J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. $ \\frac{5 + 6^{2.5}}{\\sqrt[2]{3.5}} + 3^2 $"
      ],
      "metadata": {
        "id": "pEUqkZNWXPMt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "yURXS-Q9XVQm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# ตัวดำเนินการบูลีน\n",
        "\n",
        "ประโยคคำสั่งที่ต้องมีการเปรียบเที่ยบเงื่อนไข เช่น if , if-else while เป็นต้น เราต้องระบุนิพจน์เปรียบเทียบได้แก่ True หรือ False ในการกำหนดเงื่อนไข\n",
        "\n",
        "แต่หาต้องการกำหนดเงือนไขที่ซับซ้อนขึ้น สามารถใช้ตัวดำเนินการบูลีนได้แก่ and or หรือ not ในการเชื่อมนิพจน์เปรียบเทียบอย่างง่ายเข้าด้วยกันได้\n",
        "\n",
        "<hr>"
      ],
      "metadata": {
        "id": "axuFi8JZlJnM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<img height=\"300px\" src=\"https://www.patanasongsivilai.com/blog/wp-content/uploads/2020/02/opertor_boolean.png\" align=\"left\" hspace=\"10px\" vspace=\"0px\">"
      ],
      "metadata": {
        "id": "wmVbM6h1lVCY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "age = 12"
      ],
      "metadata": {
        "id": "NBs9cNxQlJTy"
      },
      "execution_count": 91,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "age > 13 and age < 19"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X09jfDGQlJQ3",
        "outputId": "5cad2f48-8cb0-4aca-ae90-d1d65508f8ec"
      },
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 92
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "age > 13 or age < 19"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xsg-4zauXRk2",
        "outputId": "32a501ca-e99e-4e64-816a-b69428bd49e9"
      },
      "execution_count": 93,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 93
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "not age > 13"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5fuojuOAlcst",
        "outputId": "85a9a36b-cf75-43d5-f58a-2c346fa30a0c"
      },
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "d0SjJR2Hlohy"
      }
    }
  ]
}