{ "cells": [ { "cell_type": "markdown", "id": "a80d2a32", "metadata": {}, "source": [ "# Introduction to Python" ] }, { "cell_type": "markdown", "id": "8a6e5f76", "metadata": {}, "source": [ "\n", "\n", "

ภาษา Python คืออะไร

\n", "\n", "

ภาษา Python ถูกสร้างขึ้นในปี 1989 โดย Guido van Rossum ซึ่งถูกพัฒนาขึ้นมาโดยไม่ยึดติดกับแพลตฟอร์ม กล่าวคือสามารถรันภาษา Python ได้ทั้งบนระบบ Unix, Linux, Windows NT, Windows 2000, Windows XP หรือแม้แต่ระบบ FreeBSD อีกอย่างหนึ่งภาษา Python นี้เป็นภาษาลักษณะ Open Source เหมือนอย่าง PHP, JAVA, Perl เป็นต้น


\n", "\n", "
\n", "
\n", " \n", "
Guido van Rossum ผู้สร้างโปรแกรมภาษา Python
\n", "
\n", "
\n", "\n", "

ประเภทของภาษา Python

\n", "\n", "

Python จัดอยู่ในหมวดภาษาทั่วไป ที่ถูกออกแบบมาให้ใช้งานได้หลายหลายแตกต่างกับภาษาเฉพาะทางที่จำกัดการใช้งานเฉพาะทาง Python เป็นภาษาระดับสูงประเภท

\n", " \n", "

ซึ่งทำให้ Python เป็นภาษาที่เขียนง่ายเหมาะสมกับงานพัฒนาแอพพลิเคชันที่รวดเร็ว รวมถึงเป็นโปรแกรมเชื่อมโยงแอพพลิเคชันต่าง ๆ เข้าด้วยกัน

\n", "\n", "

วัตถุประสงค์หลักของ Python คือ ความอ่านง่าย (readability) เพื่อให้การดูแลและพัฒนาโปรแกรม (maintenance) มีประสิทธิภาพ อีกทั้ง Python ยังรองรับการเขียนโปรแกรมแบบแยกส่วน (modular programming) และการนำโค้ดกลับมาใช้งาน ตัวโปรแกรม Python ก็มี library ให้เลือกใช้มากมาย โปรแกรม Python เป็นโปรแกรมที่นักพัฒนาชื่นชอบเนื่องจาก Python ถูกออกแบบมาเพื่อให้นักพัฒนาสามารถเขียนโปรแกรมโดยใช้ระยะเวลาที่สั้น จำนวนบรรทัดที่ไม่มากนัก ซึ่งง่ายต่อการแก้ปัญหา (debug) เนื่องจากไม่มีกระบวนการเรียบเรียง (compilation) ก่อนที่จะนำโปรแกรมมาใช้งาน ทำให้กระบวนการ แก้ไข ทดสอบโปรแกรมทำได้ง่ายและรวดเร็ว

\n", "\n", "

Python มีข้อดีหลายอย่างแต่ก็ไม่ใช่ว่าจะดีกว่าภาษาอื่นทุกด้าน ข้อเสียหลักของ Python คือความเร็วในการประมวลผลจะสู้ภาษาคอมไพล์ (compiled language) เช่น C หรือ C++ ไม่ได้ เนื่องจาก Python ถูกแปลงถึงระดับไบต์โค้ด (byte code) ซึ่งเป็นโค้ดที่ไม่ขึ้นกับเพลตฟอร์ม แต่ไม่ได้ถูกแปลงไปถึงระดับบิทโค้ด (binary machine code) ซึ่งขึ้นกับเพลตฟอร์ม โดยทั่วไปแล้วความเร็วของภาษา Python จัดว่าดีในระดับหนึ่งแต่ก็ไม่เท่ากับภาษาคอมไพล์ ถ้าความต่างด้านความเร็วในการประมวลผลไม่ใช่ประเด็นหลักในการทำงาน หรือไม่จำเป็นต้องเขียนภาษาเพิ่มดึงประสิทธิภาพด้านความเร็วสูงสุดจาก CPU ภาษา Python จัดว่าเป็นภาษาที่สร้างความได้เปรียบในหลาย ๆ ด้าน

\n", "\n", "

ลักษณะการทำงานของ Python

\n", "\n", "

ในหัวข้อนี้จะอธิบายลักษณะการทำงานของ Python เพื่อให้ทราบถึงกลไกในการแปลคำสั่ง และการประมวลผลของโปรแกรม โดยผ่านตัวแปลคำสั่ง (interpreter) ในตอนเริ่มต้นตัวแปลคำสั่งจะทำการแปลงประโยคคำสั่ง ส่งคำสั่งไปให้คอมพิวเตอร์ปฏิบัติ และส่งค่าคืน ในการสร้างผู้พัฒนาโปรแกรมจะเขียนภาษา Python โดยใช้โปรแกรมแก้ไขข้อความ (text editor program) และบันทึกโดยใช้นามสกุล .py ซึ่งเป็นมาตรฐานโดยทั่วไปสำหรับโค้ดภาษา Python สำหรับผู้ที่เริ่มต้นเขียนโปรแกรมโดยใช้ภาษา Python รายละเอียดของการทำงานของ Python อาจจะยังไม่สำคัญนักสำหรับผู้เริ่มต้น แต่สำหรับผู้พัฒนาโปรแกรมที่ต้องการจะเขียนโปรแกรมให้มีประสิทธิภาพรายละเอียดนี้ขาดไม่ได้เลยทีเดียว

\n", "\n", "

การแปลงเป็นไบต์โค้ด

\n", "\n", "

ขั้นตอนการทำงานของ Python จะเป็นกึ่งแปลคำสั่งกึ่งคอมไพล์ เรียกว่า การแปลงเป็นไบต์โค้ด (byte-code compilation) โดยการรันโค้ดที่เขียนโดยภาษา Python ในครั้งแรก Python จะทำการแปลงโค้ดให้อยู่ในรูปของไบต์โค้ดซึ่งเข้าถึงการกลไกการทำงานของคอมพิวเตอร์มากกว่าและไม่ขึ้นกับแพลตฟอร์ม โดยในการรันครั้งถัดไปจะนำไบต์โค้ดกลับมาใช้เพื่อให้การคำนวณไวขึ้น โดยไม่ต้องเสียเวลาในการแปลงไฟล์ .py ก่อน

\n", "\n", "

Python Virtual Machine

\n", "\n", "

เมื่อ Python ได้ทำการคอมไพล์ไฟล์ไปถึงระดับไบต์โค้ดแล้ว โปรแกรมจะถูกอ่านโดย Python Virtual Machine (PVM) ซึ่งเป็นตัวที่ใช้ในการค่านวณที่แท้จริง


\n", "\n", "
\n", "
\n", " \n", "
การทำงานของโปรแกรมภาษา Python
\n", "
\n", "
" ] }, { "cell_type": "markdown", "id": "01432fd0", "metadata": {}, "source": [ "

รูปแบบการใช้งานโปรแกรม Python โดยหลักมีด้วยกันทั้งหมดสามแบบ คือ

\n", "\n", "
    \n", "
  1. แบบโต้ตอบ (interactive)
    2. \n", "
  2. แบบ script หรือ batch
    3. \n", "
  3. แบบ notebook ผ่าน Jupyter Notebook
    4. \n", "
" ] }, { "cell_type": "markdown", "id": "4111ef02", "metadata": {}, "source": [ "\n", "\n", "

ตัวอย่างการคำนวณพื้นฐาน

\n", "\n", "

เมื่อเราเข้ามายัง Jupyter Notebook แล้ว เราสามารถที่จะพิมพ์คำสั่ง Python ลงในกล่องข้อความ notebook ได้ทันที โดยที่เราจะต้องอยู่ใน mode edit และ กล่องข้อความเป็นประเภท code เมื่อพิมพ์คำสั่งที่เราต้องเสร็จสิ้นแล้ว เราจะใน Python ประมวลคำสั่งได้โดยการกด Shift + Enter

" ] }, { "cell_type": "code", "execution_count": 1, "id": "2e3d9e39", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1 + 1" ] }, { "cell_type": "markdown", "id": "779606ff", "metadata": {}, "source": [ "

Python สามารถคำนวณคำสั่งพื้นฐานทางคณิตศาสตร์ได้เหมือนเครื่องคิดเลขทั่วไป

" ] }, { "cell_type": "code", "execution_count": 2, "id": "60ab2ea1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "20" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "4 * 5" ] }, { "cell_type": "code", "execution_count": 3, "id": "560f8354", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1267650600228229401496703205376" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "2 ** 100" ] }, { "cell_type": "markdown", "id": "dcd991a0", "metadata": {}, "source": [ "

เราสามารถเขียนชุดคำสั่งภาษา Python ได้หลาย ๆ บรรทัด และประมวลผลชุดคำสั่งทั้งหมดในคราวเดียว

" ] }, { "cell_type": "code", "execution_count": 4, "id": "61f885ed", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello, World!\n" ] } ], "source": [ "s = \"Hello, World!\"\n", "print(s)" ] }, { "cell_type": "markdown", "id": "7d02da2c", "metadata": {}, "source": [ "\n", "\n", "

Object พื้นฐานของภาษา Python

\n", "\n", "

ในบทนี้จะพูดถึงข้อมูลพื้นฐาน (built-in data) ของ Python ซึ่งนักพัฒนาโปรแกรมสามารถใช้งานได้โดยไม่จำเป็นต้องโหลด module อื่นเพิ่มเติม ข้อดีของการใช้ข้อมูลพื้นฐานมีดังต่อไปนี้

\n", "\n", "
\n", "\n", "

ประเภทข้อมูลหลักของภาษา Python

\n", "\n", "

ข้อมูลพื้นฐานของ Python ถูกแบ่งเป็นชนิดต่าง ๆ ตามลักษณะข้อมูลดัง ตาราง จะเห็นได้ว่าในภาษา Python โปรแกรมยูนิต เช่น ฟังก์ชัน module และ คลาสถือว่าเป็นข้อมูล เช่นกัน ซึ่งแตกต่างจากภาษาอื่น ๆ ซึ่งทำให้การส่งโปรแกรมยูนิตไปยังโปรแกรมยูนิตอื่น เช่น ส่งฟังก์ชันไปยังอีกฟังก์ชันหนึ่งทำได้ง่ายและสะดวก ซึ่งถือว่าเป็นข้อได้เปรียบของภาษา Python เมื่อเทียบกับภาษาอื่น ๆ ตัวอย่างข้อมูลพื้นฐานใน ตาราง เป็นเพียงพื้นฐานเท่านั้น ในการใช้งานภาษา Python ในระดับสูงจะมีข้อมูลพื้นฐานอื่นๆ เพิ่มเติมขึ้นมา


\n", "\n", "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
ชนิดของข้อมูลการสร้างข้อมูล
ตัวเลข1234, 2.3, 3+4j
สายอักขระ'DELPHYS', \"Python\"
ลิสท์[1, [2, 'three'], 4.5], list(range(10))
ดิกชันนารี{'food':'curry', 'taste': 'yummy'}, dict(hours=10)
ไฟล์open('text.txt'), open(r'C:\\text.bin', 'wb')
เซตset('abc')
\n", "
" ] }, { "cell_type": "markdown", "id": "4d9898fd", "metadata": {}, "source": [ "\n", "\n", "

ข้อมูลประเภทตัวเลข

\n", "\n", "

ข้อมูลประเภทตัวเลขเป็นตัวอย่างหนึ่งในข้อมูลพื้นฐานในโปรแกรมภาษา Python ข้อมูลชนิดตัวเลขได้แก่

\n", "\n", "

ซึ่งสามารถใช้แทนปริมาณเชิงตัวเลขในงานทั่วไปได้ ตัวดำเนินการของตัวเลขที่สำคัญได้แก่ การบวก + การลบ - การคูณ * การหาร / และ การยกกำลัง **


\n", "\n", "

ข้อมูลประเภทจำนวนเต็ม

\n", "\n", "\n", "

ข้อมูลประเภทจำนวนเต็ม บางทีเรียกว่าจำนวนจุดคงที่ (fixed-point number) ใช้แทนจำนวนเต็มในทางคณิตศาสตร์ การสร้างจำนวนเต็มสามารถสร้างได้ง่าย ๆ โดยพิมพ์ตัวเลขที่ไม่มีจุดทศนิยมเข้าไป

" ] }, { "cell_type": "code", "execution_count": 5, "id": "0c88ac42", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1 + 1" ] }, { "cell_type": "code", "execution_count": 6, "id": "ea711606", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "54" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "6 * 9" ] }, { "cell_type": "code", "execution_count": 7, "id": "5342cf8f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "515377520732011331036461129765621272702107522001" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "3 ** 100" ] }, { "cell_type": "markdown", "id": "022d0caf", "metadata": {}, "source": [ "

จากตัวอย่างข้างต้น เราจะสังเกตได้ว่าเราสามารถสร้างจำนวนเต็มที่มีประมาณมากได้เท่าที่เราต้องการ ซึ่งแตกต่างจากภาษาอื่นที่จำนวนเต็มส่วนมากจะมีการจำกัดขนาดไว้

\n", "\n", "

หากเราใช้ฟังก์ชัน type จะได้ชนิดข้อมูลประเภทจำนวนเต็ม int

" ] }, { "cell_type": "code", "execution_count": 8, "id": "47149caa", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "int" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = 3\n", "type(x)" ] }, { "cell_type": "code", "execution_count": 9, "id": "b96496b6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "13 % 5" ] }, { "cell_type": "markdown", "id": "ab6c2b96", "metadata": {}, "source": [ "\n", "\n", "\n", "

ข้อมูลประเภทจำนวนจุดลอยตัว

\n", "\n", "

จำนวนจุดลอยตัว (floating-point number) คือจำนวนที่ใช้แทนจำนวนจริงในทางคณิตศาสตร์ การสร้างจำนวนจุดลอยตัวจะต่างแตกจากจำนวนเต็ม คือ ต้องมีจุดทศนิยมกำกับอยู่เสมอ

" ] }, { "cell_type": "code", "execution_count": 10, "id": "e5b75fee", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(int, float)" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x, y = 0, 0.\n", "type(x), type(y)" ] }, { "cell_type": "markdown", "id": "8688647f", "metadata": {}, "source": [ "

เราสามารถสร้างจำนวนจุดลอยตัวได้หลายแบบรวมถึงการใช้ scientific notation ในการสร้างจำนวนจุดลอยตัวได้ดังตัวอย่าง

" ] }, { "cell_type": "code", "execution_count": 11, "id": "e25ddb42", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(float, float, float)" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x, y, z = 1.0e-1, 1.0E10, 1.0e+200\n", "type(x), type(y), type(z)" ] }, { "cell_type": "markdown", "id": "3e6f539f", "metadata": {}, "source": [ "

เราสามารถใช้ตัวดำเนินการบวก + การลบ - การคูณ * การหาร / และ การยกกำลัง ** เหมือนกับจำนวนเต็มทุกประการ การเรานำจำนวนเต็มมาดำเนินการกับจำนวนจุดลอยตัว Python จะทำการแปลงให้เป็นจำนวนจุดลอยตัวอัตโนมัติ

\n", "\n", "

เราสามารถโหลด module math เพื่อเราฟังก์ชันที่ใช้งานในทางคณิตศาสตร์ออกมาเพิ่มเติมได้

" ] }, { "cell_type": "code", "execution_count": 12, "id": "5d06323d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2.718281828459045, 3.141592653589793)" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import math\n", "math.e, math.pi" ] }, { "cell_type": "code", "execution_count": 13, "id": "7559e762", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1.0, 2.302585092994046, 4.47213595499958)" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "math.cos(0), math.log(10), math.sqrt(20)" ] }, { "cell_type": "markdown", "id": "47ea815e", "metadata": {}, "source": [ "\n", "\n", "

ข้อมูลประเภทจำนวนเชิงซ้อน

\n", "\n", "

ในโปรแกรมภาษา Python มีข้อมูลที่รองรับการใช้งานจำนวนเชิงซ้อนในทางคณิตศาสตร์ ซึ่งสามารถสร้างได้ด้วยใช้ j หรือ J แทนส่วนจินตภาพ

" ] }, { "cell_type": "code", "execution_count": 14, "id": "22bd5a03", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "complex" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "z = 1 + 1j\n", "type(z)" ] }, { "cell_type": "code", "execution_count": 15, "id": "35a6322c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(-1+0j)" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1j * 1J" ] }, { "cell_type": "markdown", "id": "24d66ae5", "metadata": {}, "source": [ "

การดำเนินการทางคณิตศาสตร์เหมือนกับจำนวนเต็ม และจำนวนจุดลอยตัว

" ] }, { "cell_type": "code", "execution_count": 16, "id": "06c9667b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(8-1j)" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(2 + 3j) * (1 - 2j)" ] }, { "cell_type": "code", "execution_count": 17, "id": "4b4f77d8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(0.5-0.375j)" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(3 + 4j) / 8j" ] }, { "cell_type": "markdown", "id": "40e5dcb8", "metadata": {}, "source": [ "

ข้อควรระวังในการเขียนจำนวนเชิงซ้อนคือ ตัว j และ J จะต้องอยู่ติดกับตัวเลขที่อยู่ข้างหน้า และไม่นำตัวเลขไว้ข้างหลัง

\n", "\n", "

จำนวนเชิงซ้อนยังมีกระบวนวิธี (method) ที่ไม่มีในจำนวนเต็ม เข่น การดึงส่วนจริง ส่วนจินตภาพ หรือ การหา conjugate เป็นต้น

" ] }, { "cell_type": "code", "execution_count": 18, "id": "d0c821a7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3.0, 2.0)" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "z = 3 + 2j\n", "z.real, z.imag" ] }, { "cell_type": "code", "execution_count": 19, "id": "52d9a518", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3-2j)" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "z.conjugate()" ] }, { "cell_type": "markdown", "id": "6e1806da", "metadata": {}, "source": [ "\n", "\n", "

ข้อมูลประเภทสายอักขระ

\n", "\n", "

สายอักขระ (string) คือชนิดของข้อมูลที่เป็นข้อความตัวอักษร สายอักขระเป็นข้อมูลประเภทแรกในภาษา Python ที่เราจะได้ศึกษากันที่อยู่ในกลุ่มลำดับ (sequence) ซึ่งมีการเรียงลำดับข้อมูลสมาชิกจากซ้ายไปขวา และเราสามารถดึงสมาชิกเพื่อมาใช้งานได้โดยการอ้างอิงตำแหน่งในลำดับสมาชิกนั้น ข้อมูลพื้นฐานที่อยู่ในกลุ่มลำดับอื่น ๆ ใน โปรแกรมภาษา Python ได้แก่ ลิสท์ (list) และ ทูเพิล (tuple) ซึ่งจะกล่าวถึงต่อไป

\n", "\n", "

ในการสร้างสายอักขระ เราสามารถสร้างได้โดยใช้สัญลักษณ์ อัญประกาศเดี่ยว (') อัญประกาศคู่ (\") หรือ อัญประกาศคู่สามตัว (\"\"\")

" ] }, { "cell_type": "code", "execution_count": 20, "id": "b289a2d2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(str, str, str)" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a, b, c = 'f', \"f\", \"\"\"f\"\"\"\n", "type(a), type(b), type(c)" ] }, { "cell_type": "markdown", "id": "7ce40809", "metadata": {}, "source": [ "

ในกรณีที่เราต้องการพิมพ์สัญลักษณ์ อัญประกาศเดี่ยว หรือ อัญประกาศคู่ในสายอักษระในใช้สัญลักษณ์อีกตัวเป็นตัวกำหนดสายอักขระแทน

" ] }, { "cell_type": "code", "execution_count": 21, "id": "27637822", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "It's a fine day\n", "He said, \"I love you\"\n" ] } ], "source": [ "S = \"It's a fine day\"\n", "print(S)\n", "S1 = 'He said, \"I love you\"'\n", "print(S1)" ] }, { "cell_type": "markdown", "id": "633bc825", "metadata": {}, "source": [ "

ในกรณีของสายอักขระเป็นแบบอัญประกาศคู่สามตัวสามารถเขียนได้หลายบรรทัด

" ] }, { "cell_type": "code", "execution_count": 22, "id": "05f57ada", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "This is the first sentence.\n", "This is the second sentence.\n" ] } ], "source": [ "S = \"\"\"This is the first sentence.\n", "This is the second sentence.\"\"\"\n", "print(S)" ] }, { "cell_type": "markdown", "id": "e25a7645", "metadata": {}, "source": [ "

เราสามารถดึงสมาชิกในแต่ล่ะตัวของสายอักขระได้โดยในใส่หมายเลขลำดับใน [ ] ดังตัวอย่าง

" ] }, { "cell_type": "code", "execution_count": 23, "id": "a4da8be2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "('D', 'E', 'L', 'P')" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "S = 'DELPHYS'\n", "S[0], S[1], S[2], S[3]" ] }, { "cell_type": "markdown", "id": "4b1a6e44", "metadata": {}, "source": [ "

หรือจะใช้การสไลซ์เพื่อเลือกลำดับสมาชิกทีละหลาย ๆ ตัว

" ] }, { "cell_type": "code", "execution_count": 24, "id": "1e4d8373", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'DELP'" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "S[0:4]" ] }, { "cell_type": "markdown", "id": "00d24e3d", "metadata": {}, "source": [ "\n", "\n", "

ตัวดำเนินการของสายอักขระ

\n", "\n", "

ในโปรแกรมภาษา Python เราสามารถใช้ตัวดำเนินการทางคณิตศาสตร์กับข้อมูลประเภทสายอักขระได้โดยจะมีความหมายที่คล้ายคลึงกับทางคณิตศาสตร์ ดังนี้

" ] }, { "cell_type": "code", "execution_count": 25, "id": "9fc19c8e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'DELPHYS'" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'DEL' + 'PHYS'" ] }, { "cell_type": "markdown", "id": "af6378ce", "metadata": {}, "source": [ "

เครื่องหมายบวกใช้ในการเชื่อมสายอักขระมากกว่าหนึ่งสายเข้าเป็นสายเดียวกัน โดยจะเป็นสายอักขระได้หลายแบบ เช่น

" ] }, { "cell_type": "code", "execution_count": 26, "id": "ac5a2960", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Hello This is John'" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"Hello \" + 'This is John'" ] }, { "cell_type": "markdown", "id": "0e90ab5f", "metadata": {}, "source": [ "

เรายังสามารถใช้ตัวดำเนินการคูณกับสายอักขระได้เช่นกัน โดยผลลัพธ์ที่ได้จะเป็นการต่อสายอักขระตามจำนวนเต็มที่นำมาคูณ

" ] }, { "cell_type": "code", "execution_count": 27, "id": "8fa9183b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'NiceNiceNiceNice'" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'Nice' * 4" ] }, { "cell_type": "markdown", "id": "1ec53ef1", "metadata": {}, "source": [ "

เนื่องจากสายอักขระเป็น object หนึ่งในโปรแกรมภาษา Python จึงมีฟังก์ชันที่สามารถเรียกตัวเองได้ที่เราเรียกว่า กระบวนวิธี (method) ซึ่งเราสามารถเรียกใช้ได้โดยใช้ผ่าน . แล้วตามด้วยชื่อกระบวนวิธี ดังตัวอย่าง

" ] }, { "cell_type": "code", "execution_count": 28, "id": "79b6f719", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "('Fallibility', 'FALLIBILITY')" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "S = 'fallibility'\n", "S.capitalize(), S.upper()" ] }, { "cell_type": "markdown", "id": "f7be358f", "metadata": {}, "source": [ "

ในตัวอย่างข้างต้นเราเรียกกระบวนวิธี capitalize และ upper จาก S เพื่อเปลี่ยนตัวอักษรใน S หากเราไม่ทราบว่า object นั้น ๆ มีกระบวนวิธีอะไรบ้างสามารถทำได้โดยใช้คำสั่ง dir(S) เพื่อแสดงกระบวนวิธี และ attribute ทั้งหมดของ S

\n", "\n", "

สำหรับผู้เรียนที่ใช้งาน Python ผ่าน Jupyter Notebook สามารถแสดงกระบวนวิธีทั้งหมดได้โดยการกด TAB หลังเครื่องหมาย .


" ] }, { "cell_type": "markdown", "id": "7481ae37", "metadata": {}, "source": [ "\n", "\n", "

การใช้งานข้อมูลประเภท List

\n", "\n", "

ลิสท์ (list) คือ ข้อมูลพื้นฐานในโปรแกรมภาษา Python ที่เป็นลำดับ และสมาชิกในลิสท์เป็นข้อมูลอะไรที่ได้ในโปรแกรมภาษา Python โดยไม่จำกัดความยาว ซึ่งความยาวของลิสท์นั้นสามารถต่อออกไปได้เรื่อย ๆ เราเรียกข้อมูลที่สามารถเปลี่ยน หรือเพิ่มสมาชิกได้ว่า mutable การสร้างลิสท์สามารถสร้างได้โดยการใช้สัญลักษณ์ []\n", "

" ] }, { "cell_type": "code", "execution_count": 29, "id": "df839b8e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "list" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L = [1, 'strawberry', 2.3]\n", "type(L)" ] }, { "cell_type": "markdown", "id": "095744bc", "metadata": {}, "source": [ "

เราจะเห็นได้ว่าสมาชิกในลิสท์ไม่จำเป็นต้องเป็นข้อมูลประเภทเดียวกันเราสามารถหาจำนวนสมาชิกในลิสท์ได้โดยใช้คำสั่ง len

" ] }, { "cell_type": "code", "execution_count": 30, "id": "4cd76c41", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(L)" ] }, { "cell_type": "markdown", "id": "e8f84f0a", "metadata": {}, "source": [ "

เนื่องจากลิสท์เป็นข้อมูลประเภทที่มีลำดับ (sequence) ดังนั้นเราสามารถใช้การสไลซ์เพื่อดึงสมาชิกออกมาได้

" ] }, { "cell_type": "code", "execution_count": 31, "id": "1f82ca91", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L = [0, 1, 2, 3, 4]\n", "L[0]" ] }, { "cell_type": "code", "execution_count": 32, "id": "7815e068", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0, 1]" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L[0:2]" ] }, { "cell_type": "markdown", "id": "c6a437b6", "metadata": {}, "source": [ "

ข้อมูลประเภทลิสท์เป็นประเภท mutable คือเมื่อสร้างมาแล้วสามารถแก้ไข เพิ่มเติม หรือทำลายสมาชิกได้ ดังเช่น

" ] }, { "cell_type": "code", "execution_count": 33, "id": "4aca6f8a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['bnk', 'akb', 4.8]\n" ] } ], "source": [ "L = [3, 'akb', 4.8]\n", "L[0] = 'bnk'\n", "print(L)" ] }, { "cell_type": "markdown", "id": "917d04d6", "metadata": {}, "source": [ "

เราสามารถนำลิสท์มาซ้อนกันได้ โดยวิธีการเรียกสมาชิกในลิสท์ก็จะแบ่งเป็นตำแหน่งของสมาชิกในแต่ละระดับ

" ] }, { "cell_type": "code", "execution_count": 34, "id": "2a2af53d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L = [[1, 2], [3, 4]]\n", "L[0][0]" ] }, { "cell_type": "markdown", "id": "0a2ada70", "metadata": {}, "source": [ "\n", "\n", "

การใช้งานข้อมูลประเภท Tuple

\n", "\n", "

ทูเพิล (tuple) คือข้อมูลพื้นฐานที่ใกล้เคียงกับลิสท์ประเภทหนึ่งที่ immutable คือไม่สามารถเปลี่ยน เพิ่ม หรือทำลายสมาชิกได้ ในการใช้งานทูเพิล เป็นลักษณะของการรวมรวมข้อมูลที่คงที่และไม่เปลี่ยนแปลง การสร้างและการใช้งานทูเพิลสามารถศึกษาได้จากตัวอย่าง

\n" ] }, { "cell_type": "code", "execution_count": 35, "id": "a63968e2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tuple" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "T = (1, 'christina', 7.9)\n", "type(T)" ] }, { "cell_type": "markdown", "id": "e96e81c5", "metadata": {}, "source": [ "

การใช้งานทูเพิลจะเหมือนกับลิสท์ทุกประการเช่นการสไลซ์สมาชิก ยกเว้นแต่ว่าเราไม่สามารถที่จะแก้ไขสมาชิกหรือเพิ่มสมาชิกได้

" ] }, { "cell_type": "code", "execution_count": 36, "id": "f2daf46a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "T[0]" ] }, { "cell_type": "code", "execution_count": 37, "id": "23554c0a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'christina'" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "T[1]" ] }, { "cell_type": "code", "execution_count": 38, "id": "a141a5cd", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1, 'christina')" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "T[0:2]" ] }, { "cell_type": "markdown", "id": "d6e3a407", "metadata": {}, "source": [ "

กระบวนวิธีของทูเพิลจะมีน้อยกว่าลิสท์เนื่องจากการใช้งานที่จำกัดกว่าลิสท์

" ] }, { "cell_type": "markdown", "id": "04f2cec1", "metadata": {}, "source": [ "\n", "\n", "

เปรียบเทียบการใช้งานระหว่าง List กับ Tuple

\n", "\n", "

เราจะเห็นได้ว่าข้อมูลพื้นฐานประเภทลิสท์ และทูเพิลมีความคล้ายคลึงกันมากทำให้ผู้ที่เริ่มศึกษาหลายคนสงสัยว่า ทำไมจึงมีการสร้างชนิดของข้อมูลที่คล้ายคลึงกันขึ้นมา และคำถามที่มักจะถามกันมาก คือในเมื่อมีลิสท์ที่ใช้งานได้มากกว่า ทำไมจึงต้องมีทูเพิลอยู่ด้วย เหตุผลประการหลักของการมีทูเพิลที่เป็นข้อมูลประเภท immutability คือการคงสภาพของข้อมูลโดยไม่มีการเปลี่ยนแปลง ทำให้ลดความผิดพลาดที่จะทำให้ข้อมูลมีการเปลี่ยนแปลงภายหลังได้ อีกทั้งการใช้งานทูเพิลจะมีประสิทธิภาพในการสร้าง การจัดเก็บ และการเข้าถึงข้อมูลมากกว่าลิสท์ ดังนั้นหากเราทราบว่าข้อมูลที่เราต้องการจะไม่มีการเปลี่ยนแปลงแก้ไขอีก เราจึงควรที่จะใช้ทูเพิลเพื่อประสิทธิภาพของโปรแกรมที่เราเขียน

" ] }, { "cell_type": "code", "execution_count": null, "id": "9af53044", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "6376c7bf", "metadata": {}, "source": [ "\n", "\n", "

การใช้งานข้อมูลประเภท Dictionary

\n", "\n", "

ในโปรแกรมภาษา Python ดิกชันนารี (dictionary) เป็นข้อมูลพื้นฐานที่แตกต่างจากสายอักขระ และลิสท์ คือไม่อยู่ในกลุ่มลำดับ แต่จะอยู่ในกลุ่มที่เรียกว่า mapping ซึ่งคือการรวมข้อมูลต่าง ๆ เข้าไว้ด้วยกันแต่ไม่มีลำดับ การอ้างอิงสมาชิกในดิกชันนารี จะใช้การอ้างอิงจากคีย์ (key) เป็นหลัก ดิกชันนารีมีลักษณะเช่นเดียวกับลิสท์ คือ เป็นข้อมูลประเภท mutable คือสามารถแก้ไขข้อมูลของสมาชิกได้ และเพิ่มจำนวนสมาชิกได้ไม่จำกัด การสร้างดิกชันนารีสามารถศึกษาได้จากตัวอย่าง

" ] }, { "cell_type": "code", "execution_count": 39, "id": "205512c1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dict" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D = {'First':1, 'Second':2, 'Third':3, 'Fourth':4}\n", "type(D)" ] }, { "cell_type": "markdown", "id": "48e98880", "metadata": {}, "source": [ "

การดึงค่าของดิกชันนารีจะทำผ่าน key เท่านั้น

" ] }, { "cell_type": "code", "execution_count": 40, "id": "64c7ca71", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D['First']" ] }, { "cell_type": "code", "execution_count": 41, "id": "e5be06b8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D['Second']" ] }, { "cell_type": "markdown", "id": "6650b48a", "metadata": {}, "source": [ "

เราสามารถตรวจสอบ key ในดิกชันนารีได้ด้วยการใช้ตัวดำเนินการ in

" ] }, { "cell_type": "code", "execution_count": 42, "id": "a1c01429", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'First' in D" ] }, { "cell_type": "code", "execution_count": 43, "id": "a3d1ee8c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'Fifth' in D" ] }, { "cell_type": "markdown", "id": "a3a85a7a", "metadata": {}, "source": [ "

เราสามารถดู key ทั้งหมดของดิกชันนารีได้โดยการใช้กระบวนวิธี keys ดังตัวอย่าง

" ] }, { "cell_type": "code", "execution_count": 44, "id": "94e0a684", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dict_keys(['First', 'Second', 'Third', 'Fourth'])" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D.keys()" ] }, { "cell_type": "markdown", "id": "b120f08c", "metadata": {}, "source": [ "

ข้อควรระวังประการหนึ่งคือ เราไม่สามารถใช้ลิสท์ หรือดิกชันนารีสร้างเป็นคีย์ได้เนื่องจากเป็นข้อมูลประเภท mutable เราจึงสรุปได้ว่า key ต้องเป็นข้อมูลประเภท immutable เท่านั้น

" ] }, { "cell_type": "code", "execution_count": null, "id": "77ec3116", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "3e92cfe1", "metadata": {}, "source": [ "\n", "\n", "

ข้อมูลประเภทไฟล์

\n", "\n", "

ไฟล์เป็นข้อมูลพื้นฐานประเภทหนึ่งในโปรแกรมภาษา Python ที่ใช้เชื่อมต่อกับไฟล์อื่น ๆ โดยส่วนมากจะเป็นการอ่าน และเขียนไฟล์ โดยใช้ฟังก์ชัน open ดังนี้

\n", "\n", "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
ความหมายการสร้าง
บันทึกไฟล์ (w หมายถึงบันทึก (write))output = open('file.txt', 'w')
บันทึกไฟล์แบบ binary (b มาจาก binary)output = open('file.bin', 'wb')
บันทึกไฟล์ต่อ (a หมายถึงบันทึกต่อ (append))output = open('file.txt', 'a')
บันทึกไฟล์ต่อแบบ binaryoutput = open('file.txt', 'ab')
อ่านไฟล์ r หมายถึงอ่าน (read)input = open('file.txt', 'r')
อ่านไฟล์ b แบบ binaryinput = open('file.bin', 'rb')
อ่านไฟล์ (โหมดปรกติเป็นโหมดอ่าน)input = open('file.txt')
อ่านสายอักขระทั้งหมดใน inputtext = input.read()
อ่านสายอักขระทั้งหมด N บรรทัดtext = input.read(N)
อ่านสายอักขระทีล่ะบรรทัดจาก inputline = input.readline()
อ่านสายอักขระทั้งหมดจาก input โดยแยกบรรทัดline = input.readlines()
บันทึก text ลงในไฟล์output.write(text)
บันทึกtext ลงในไฟล์ทุกบรรทัดoutput.writelines(line)
ปิดการเข้าถึงไฟล์output.close()
การใช้ฟังก์ชัน open ในการเข้าถึงไฟล์
\n", "
\n", "\n", "

ตัวอย่างข้างล่างเป็นการบันทึก และอ่านไฟล์อย่างง่ายที่ผู้ใช้สามารถนำไปประยุกต์ใช้ได้

" ] }, { "cell_type": "code", "execution_count": 45, "id": "1d10909e", "metadata": {}, "outputs": [], "source": [ "output = open('file.txt', 'w')\n", "output.write('Hello')\n", "output.close()" ] }, { "cell_type": "code", "execution_count": 46, "id": "9d6e5626", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello\n" ] } ], "source": [ "input = open('file.txt')\n", "text = input.read()\n", "print(text)\n", "input.close()" ] }, { "cell_type": "markdown", "id": "e93adaa4", "metadata": {}, "source": [ "\n", "\n", "

ข้อมูลประเภท Set

\n", "\n", "

เซต (set) เป็นข้อมูลพื้นฐานประเภทหนึ่งในโปรแกรมภาษา Python ที่ไม่มีลำดับ และนับเฉพาะสมาชิกที่ไม่ซ้ำเท่านั้น โดยมีลักษณะ และตัวดำเนินการเหมือนกับเซตในทางคณิตศาสตร์ทุกประการ ตัวอย่างต่อไปนี้เป็นการใช้งานเซตเบื้องต้น

" ] }, { "cell_type": "code", "execution_count": 47, "id": "74b0537b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "set" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "s = {1, 2, 3, 3, 2, 1}\n", "type(s)" ] }, { "cell_type": "code", "execution_count": 48, "id": "013bfedd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{1, 2, 3}\n" ] } ], "source": [ "print(s)" ] }, { "cell_type": "markdown", "id": "68b6853b", "metadata": {}, "source": [ "

นอกจากนี้เรายังสามารถใช้ฟังก์ชัน set ในการสร้างได้

" ] }, { "cell_type": "code", "execution_count": 49, "id": "96e81b21", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'D', 'E', 'H', 'L', 'P', 'S', 'Y'}" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "set('DELPHYS')" ] }, { "cell_type": "markdown", "id": "938c733c", "metadata": {}, "source": [ "

ตัวดำเนินการที่สามารถใช้ได้กับเซตได้ ได้แก่ ผลต่าง - ยูเนียน | อินเตอร์เซกชัน &

" ] }, { "cell_type": "code", "execution_count": 50, "id": "7bd332c5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'o', 'r', 'u'}" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "X = set('Fourth')\n", "Y = set('Fifth')\n", "X - Y" ] }, { "cell_type": "code", "execution_count": 51, "id": "933c0501", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'F', 'f', 'h', 'i', 'o', 'r', 't', 'u'}" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "X | Y" ] }, { "cell_type": "code", "execution_count": 52, "id": "40eaf44c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'F', 'h', 't'}" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "X & Y" ] }, { "cell_type": "markdown", "id": "86341b69", "metadata": {}, "source": [ "

ความสัมพันธ์อื่น ๆ ได้แก่ สับเซต < และ ซุปเปอร์เซต >

" ] }, { "cell_type": "code", "execution_count": 53, "id": "8c0543ed", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "X = set('strawberry')\n", "Y = set('berry')\n", "X > Y" ] }, { "cell_type": "code", "execution_count": 54, "id": "7fa9d983", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Y > X" ] }, { "cell_type": "code", "execution_count": 55, "id": "0dab5758", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Y < X" ] }, { "cell_type": "markdown", "id": "ec85cb1d", "metadata": {}, "source": [ "\n", "\n", "

การทำงานของ Python

\n", "\n", "

ในการเขียนโปรแกรมภาษา Python เราสามารถแบ่งหน่วยของโปรแกรมออกเป็นหน่วยที่เล็กที่สุดแล้วนำมาสร้างเป็นหน่วยที่ใหญ่ขึ้นมาเรื่อย ๆ หน่วยที่เล็กที่สุด คือ ข้อมูล (data) ซึ่งเราได้กล่าวไว้แล้วในหัวข้อที่แล้ว ในหัวข้อนี้เราจะพูดถึงการนำข้อมูลมาสร้างเป็นประโยคคำสั่ง (statement) ในโปรแกรมภาษา Python กัน ประโยคคำสั่ง คือ ประโยคคำสั่งที่มีความสมบูรณ์ให้ตัวเอง รูปแบบของประโยคคำสั่งเป็นไปดังตาราง

\n", "\n", "\n", "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
ประโยคคำสั่งหน้าที่ตัวอย่าง
การกำหนดค่าการอ้างอิงa, b = 'good', 'bad'
การเรียกนิพจน์การใช้งานฟังก์ชันoutput.write('Hello')
คำสั่ง printแสดงค่าของข้อมูลprint('DELPHYS')
ตัวอย่าง statement ใน Python
\n", "

\n", "\n", "

ประโยคคำสั่งเหล่านี้เราได้ศึกษามาแล้วในหัวข้อที่ผ่านมา ซึ่งลักษณะทางทำงานจะเป็นไปในลักษณะทิศทางเดียว คือ ปฎิบัติทีละคำสั่งตามลำดับ


\n", "\n", "
\n", "
\n", " \n", "
ลักษณะการทำงานของโปรแกรมภาษา Python แบบปรกติ
\n", "
\n", "

\n", "\n", "

ให้หัวข้อที่จะได้ศึกษาต่อไปนี้จะพูดประโยคคำสั่ง if, while, for และ comprehension ที่จะมีทิศทางการทำงานแตกต่างกันไปตามชุดคำสั่ง

" ] }, { "cell_type": "markdown", "id": "28c41967", "metadata": {}, "source": [ "\n", "\n", "

ตัวอย่าง statement

\n", "\n", "

ตัวอย่างประโยคคำสั่งประเภทกำหนดค่า (assignment)

" ] }, { "cell_type": "code", "execution_count": 56, "id": "0cd67c51", "metadata": {}, "outputs": [], "source": [ "apple = 1\n", "cherry = 2" ] }, { "cell_type": "markdown", "id": "cf3d2ef2", "metadata": {}, "source": [ "

การกำหนดค่าแบบทูเพิล

" ] }, { "cell_type": "code", "execution_count": 57, "id": "a6a92d3b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1, 2)" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A, B = apple, cherry\n", "A, B" ] }, { "cell_type": "markdown", "id": "61577716", "metadata": {}, "source": [ "

การกำหนดค่าแบบลิสท์

" ] }, { "cell_type": "code", "execution_count": 58, "id": "98871482", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2]" ] }, "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[C, D] = apple, cherry\n", "[C, D]" ] }, { "cell_type": "markdown", "id": "0cf0cf74", "metadata": {}, "source": [ "

การสลับค่าในทูเพิล

" ] }, { "cell_type": "code", "execution_count": 59, "id": "456435ae", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2, 1)" ] }, "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cherry, apple = apple, cherry\n", "apple, cherry" ] }, { "cell_type": "markdown", "id": "1b9c3f03", "metadata": {}, "source": [ "

การกำหนดค่าในลิสท์จากทูเพิล

" ] }, { "cell_type": "code", "execution_count": 60, "id": "7eacba77", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1, 3)" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[a, b, c] = (1, 2, 3)\n", "a, c" ] }, { "cell_type": "markdown", "id": "b0e83e6a", "metadata": {}, "source": [ "

การกำหนดค่าจากสายอักขระ

" ] }, { "cell_type": "code", "execution_count": 61, "id": "1c533ec8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "('A', 'C')" ] }, "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a, b, c = \"ABC\"\n", "a, c" ] }, { "cell_type": "markdown", "id": "071387b9", "metadata": {}, "source": [ "

การกำหนดค่าตัวแปรผ่าน ลิสท์ ทูเพิล หรือสายอักขระ จะทำได้เฉพาะกรณีที่จำนวนสมาชิกเท่ากันเท่านั้น

\n", "\n", "

เราสามารถกำหนดค่าได้หลายทางเช่นกัน โดยที่แต่ละตัวแปรจะเป็นอิสระต่อกันในกรณีที่เป็นข้อมูลชนิด immutable

" ] }, { "cell_type": "code", "execution_count": 62, "id": "2566c90c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(0, 1)" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = b = 0\n", "b = b + 1\n", "a, b" ] }, { "cell_type": "markdown", "id": "8995d700", "metadata": {}, "source": [ "

แต่การกำหนดค่าหลายทาง ตัวแปรจะบันทึกข้อมูลชนิดเดียวกันในกรณีที่เป็นข้อมูลประเภท mutable

" ] }, { "cell_type": "code", "execution_count": 63, "id": "083a0ba9", "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "([3], [3])" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = b = []\n", "b.append(3)\n", "a, b" ] }, { "cell_type": "markdown", "id": "8dd1299f", "metadata": {}, "source": [ "\n", "\n", "

ลักษณะของเงื่อนไข If

\n", "\n", "

ในบางกรณีเรามีความเป็นจำเป็นที่จะต้องเลือกทิศทางของการทำงานของโปรแกรมไปทางใด ทางหนึ่งโดยขึ้นกับเงื่อนไขต่าง ๆ กัน ซึ่งเป็นทิศทางการไหลของชุดคำสั่งแบบไม่เป็นทางเดียว เราสามารถเขียนให้การทำงานของโปรแกรมแบบมีเงื่อนไขได้โดยใช้คำสั่ง if


\n", "\n", "
\n", "
\n", " \n", "
ทิศทางการไหลของโปรแกรมภาษา Python แบบไม่เป็นไปทางเดียว
\n", "
\n", "

\n", "\n", "

รูปแบบการเขียนคำสั่ง if จะเป็นดังนี้

" ] }, { "cell_type": "markdown", "id": "26112e3a", "metadata": {}, "source": [ "\n", " if condition1:\n", "
\n", " \n", " statements1\n", "
\n", " \n", " else condition2:\n", "
\n", " \n", " statements2\n", " " ] }, { "cell_type": "markdown", "id": "3a28a1f8", "metadata": {}, "source": [ "\n", "\n", "\n", "

โดยที่ condition1 และ condition2 แทนประโยคคำสั่งที่คืนค่าความจริงเป็น True หรือ False อย่างใดอย่างหนึ่งเท่านั้น
statements1 และ statements2 แทนชุดคำสั่ง

\n", "\n", "

โดยเริ่มต้น condition1 จะทำการประมวลก่อน ถ้าค่าความจริงเป็น True จะประมวลผลชุดคำสั่ง statements1 แต่ถ้าค่าความจริงเป็น False จะประมวลผลชุดคำสั่ง statements2 หลังจากนั้นจึงดำเนินการต่อไป ดังรูป


\n", "\n", "
\n", "
\n", " \n", "
ทิศทางการไหลของโปรแกรมภาษา Python แบบ If
\n", "
\n", "
" ] }, { "cell_type": "code", "execution_count": null, "id": "86d37f06", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "d4af837b", "metadata": {}, "source": [ "\n", "\n", "

ตัวอย่างเงื่อนไข If

\n", "\n", "

การเขียนคำสั่ง if เราจะวางสัญลักษณ์เครื่อง :ต่อท้ายเงื่อนไขเสมอ การที่เราวางเครื่องหมาย : ต่อท้ายจะเป็นการเลื่อน block ของชุดคำสั่งไปอีกระดับโดยการใช้ย่อหน้า (พิมพ์ TAB) โดยที่ประโยคคำสั่งที่ลงท้ายด้วย สัญลักษณ์เครื่อง : จะเป็น Header ของ block นั้น

\n", "\n", "

การแบ่ง block ออกเป็นระดับ คือการแสดงขอบเขตของ Header ในกรณีของคำสั่ง if ทำให้โปรแกรมทราบว่าชุดคำสั่งไหนเป็นชุดคำสั่งที่ต้องกระทำภายใต้เงื่อนไขที่เป็นจริง ชุดคำสั่งไหนเป็นชุดคำสั่งที่ต้องกระทำกรณีที่เงื่อนไขเป็นเท็จ ชุดคำสั่งไหนเป็นชุดคำสั่งที่ต้องทำเสมอหลังจากกระทำเงื่อนที่ทางเลือกเสร็จสิ้นแล้ว ดังรูป


\n", "\n", "
\n", "
\n", " \n", "
ลักษณะของ Block ใน Python
\n", "
\n", "
\n", "
\n", "\n", "

ก่อนที่เราจะไปถึงตัวอย่างการใช้คำสั่ง if เราจำเป็นต้องทราบก่อนว่าข้อมูลที่ไม่เป็นศูนย์ หรือไม่ว่างจะให้ค่าความจริงเป็น True เสมอ ส่วนข้อมูลที่เท่ากับศูนย์หรือว่างจะให้ค่าความจริงเป็น False เสมอ

\n" ] }, { "cell_type": "code", "execution_count": 64, "id": "85dad622", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(False, False, False)" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bool(0), bool(0.0), bool(0j)" ] }, { "cell_type": "code", "execution_count": 65, "id": "f294bcf0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(True, True, True)" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bool(1), bool(1.0), bool(1j)" ] }, { "cell_type": "code", "execution_count": 66, "id": "d5340c53", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(False, False, False, False)" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bool([]), bool(()), bool({}), bool(set())" ] }, { "cell_type": "code", "execution_count": 67, "id": "26f6348c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(False, False, False, False)" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bool([]), bool(()), bool({}), bool(set())" ] }, { "cell_type": "markdown", "id": "a40c5f89", "metadata": {}, "source": [ "

ต่อไปนี้จะเป็นตัวอย่างการใช้คำสั่ง if

" ] }, { "cell_type": "code", "execution_count": 68, "id": "953cd1aa", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "true\n" ] } ], "source": [ "if 1:\n", " print('true')" ] }, { "cell_type": "code", "execution_count": 69, "id": "f93f9568", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "false\n" ] } ], "source": [ "if not 1:\n", " print('true')\n", "else:\n", " print('false')" ] }, { "cell_type": "markdown", "id": "b03a3046", "metadata": {}, "source": [ "

เราสามารถใช้คำสั่ง in เพื่อตรวจสอบสมาชิก และคืนค่าความจริงได้เช่นกัน

" ] }, { "cell_type": "code", "execution_count": 70, "id": "2c67e454", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "YES\n" ] } ], "source": [ "if 'x' in 'xmas':\n", " print('YES')" ] }, { "cell_type": "markdown", "id": "32a333fa", "metadata": {}, "source": [ "

เราสามารถใช้คำสั่ง elif เป็น Header ต่อจาก if เพื่อตรวจสอบเงื่อนไขต่อไปได้ ดังตัวอย่างต่อไปนี้

" ] }, { "cell_type": "code", "execution_count": 71, "id": "75187e79", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The number is zero.\n" ] } ], "source": [ "x = 0\n", "if x > 0:\n", " print('The number is positive.')\n", "elif x < 0:\n", " print('The number is negative.')\n", "else:\n", " print('The number is zero.')" ] }, { "cell_type": "markdown", "id": "be6cbac9", "metadata": {}, "source": [ "

เราสามารถใช้คำสั่ง if ซ้อนกันได้โดยให้ผลเช่นเดียวกันโดยที่เราจำเป็นต้องย่อหน้าเพิ่มเพื่อเพิ่มระดับของ block

" ] }, { "cell_type": "code", "execution_count": 72, "id": "ed3400ef", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The number is zero.\n" ] } ], "source": [ "x = 0\n", "if x > 0:\n", " print('The number is positive.')\n", "else:\n", " if x < 0:\n", " print('The number is negative.')\n", " else:\n", " print('The number is zero.')" ] }, { "cell_type": "code", "execution_count": null, "id": "690dffc1", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "6c4aa6eb", "metadata": {}, "source": [ "\n", "\n", "

ลักษณะการทำงานของลูป While

\n", "\n", "

ในหัวข้อนี้จะพูดถึงการสร้างประโยคคำสั่งที่แสดงการวนซ้ำ (loop) ซึ่งในโปรแกรมภาษา Python จะมีให้เลือกใช้สองแบบ คือการวนซ้ำแบบ while และ การวนซ้ำแบบ for

\n", "\n", "

การวนซ้ำ (loop) คือ การทำงานของโปรแกรมที่จะวนซ้ำชุดคำสั่งหนึ่ง ภายใต้เงื่อนไขที่เป็นจริง จนกว่าเงื่อนไขจะเป็นเท็จจึงข้ามไปดำเนินในชุดคำสั่งต่อไป สำหรับรูปแบบของการวนซ้ำแบบ while เป็นดังนี้

" ] }, { "cell_type": "markdown", "id": "7bccecb4", "metadata": {}, "source": [ "\n", " while condition:\n", "
\n", " \n", " statements1\n", "
\n", " \n", " else:\n", "
\n", " \n", " statements2\n", " " ] }, { "cell_type": "markdown", "id": "d040480b", "metadata": {}, "source": [ "\n", "\n", "

โดยที่ โปรแกรมจะทำการตรวจสอบเงื่อนไขใน condition ถ้าเงื่อนไขของ condition ให้ค่าความจริงเป็น True โปรแกรมจะดำเนินการตามชุดคำสั่งใน statements1 จนกว่าค่าความจริงใน condition จะเป็นเท็จจึงดำเนินการใน statements2

\n", "\n", "

เราจะเห็นได้ว่า condition ต้องสามารถเปลี่ยนค่าความจริงจาก True เป็น False ได้ระหว่าง statements1 มิฉะนั้นจะเกิดลูปอนันต์ (infinite loop)

\n", "\n", "

โปรแกรมภาษา Python มีคำสั่งที่ใช้ในการวนซ้ำดังนี้

\n", "\n", "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
คำสั่งการใช้งาน
breakใช้ออกจากคำสั่งการวนซ้ำที่ใกล้ที่สุด
continueใช้สำหรับวนกลับไปยังเงื่อนไขของการวนซ้ำที่ใกล้ที่สุด
passไม่ดำเนินการอะไรเลย
คำสั่งที่สามารถใช้ได้ในการวนซ้ำในโปรแกรมภาษา Python
\n", "
\n", "\n", "

คำสั่ง pass สามารถใช้นอกการวนซ้ำได้

" ] }, { "cell_type": "code", "execution_count": null, "id": "7b887ebd", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "9586f312", "metadata": {}, "source": [ "\n", "\n", "

ตัวอย่างการทำงานของลูป While

\n", "\n", "

ในตัวอย่างต่อไปนี้จะเป็นการแสดงการใช้การวนซ้ำแบบ while

\n", "\n", "

ในตัวอย่างนี้จะเป็นการพิมพ์ค่าของ x จาก 9 ถึง 0 โดยจะพิมพ์เฉพาะเลขคู่เท่านั้น โดยการใช้ร่วมกับคำสั่ง continue

" ] }, { "cell_type": "code", "execution_count": 73, "id": "2b9e130c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "8\n", "6\n", "4\n", "2\n", "0\n" ] } ], "source": [ "x = 10\n", "while x:\n", " x = x - 1\n", " if x % 2 != 0: continue\n", " print(x)" ] }, { "cell_type": "markdown", "id": "e8c2f063", "metadata": {}, "source": [ "

ต่อไปจะเป็นการนำคำสั่ง while ร่วมกับคำสั่ง break

" ] }, { "cell_type": "code", "execution_count": 74, "id": "4b2ff1fa", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "9\n", "8\n", "7\n", "6\n", "5\n", "4\n", "3\n" ] } ], "source": [ "x = 10\n", "while True:\n", " x = x - 1\n", " if x < 3 != 0: break\n", " print(x)" ] }, { "cell_type": "markdown", "id": "ce49b8cc", "metadata": {}, "source": [ "

ในตัวอย่างข้างต้นเราให้เงื่อนไขใน while เป็น True เสมอเพื่อให้การวนซ้ำเกิดขึ้นได้เรื่อย ๆ จนกว่าจะเจอเงื่อนไขที่อยู่ใน if เป็นจริงจึงทำการออกจากการวนซ้ำโดยคำสั่ง break

\n", "\n", "

สำหรับตัวอย่างสุดท้ายจะเป็นตัวอย่างการใช้คำสั่ง while ร่วมกับ else

" ] }, { "cell_type": "code", "execution_count": 75, "id": "10b2d0e8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "11 is a prime.\n" ] } ], "source": [ "y = 11\n", "x = y // 2\n", "while x > 1:\n", " if y % x == 0:\n", " print(y, 'has a factor', x)\n", " break\n", " x -= 1\n", "else:\n", " print(y, 'is a prime.')" ] }, { "cell_type": "markdown", "id": "39dcfd92", "metadata": {}, "source": [ "

ในตัวอย่างจะเป็นป้อนตัวเลขลงไปเพื่อหาว่าจำนวนที่ป้อนลงไปเป็นจำนวนเฉพาะหรือไม่โดยบันทึกตัวเลขไว้ในตัวแปร y หลังจากนั้นจึงทำการหาตัวประกอบโดยใช้การวนซ้ำแบบ while โดยการหาตัวประกอบที่น้อยกว่าครึ่งหนึ่งของ y ในกรณีที่หาเจอจะคืนตัวประกอบของ y จนกระทั่งหาไม่เจอจริงแสดงได้ว่า y เป็นจำนวนเฉพาะ

" ] }, { "cell_type": "code", "execution_count": null, "id": "2ad31bfe", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "37889ec6", "metadata": {}, "source": [ "\n", "\n", "

ลักษณะการทำงานของลูป For

\n", "\n", "

คำสั่งการวนซ้ำแบบ for จะวนซ้ำภายในสมาชิกของข้อมูลที่เป็นลำดับจนหมด โดยมีรูปแบบดังนี้

" ] }, { "cell_type": "markdown", "id": "663f6023", "metadata": {}, "source": [ "\n", " for target in sequence:\n", "
\n", " \n", " statements\n", " " ] }, { "cell_type": "markdown", "id": "2f6d7f7d", "metadata": {}, "source": [ "

โดยที่ target ในแทนสมาชิกของลำดับ sequence ทีล่ะสมาชิก และ statements จะเป็นชุดคำสั่งที่ใช้การการประมวลผลในแต่ละรอบของการวนซ้ำ ในแต่ล่ะการวนซ้ำ target จะบันทึกสมาชิกใน sequence ตั้งแต่ตัวแรกไปจนกระทั่งถึงตัวสุดท้าย แล้วจึงออกจากการวนซ้ำ

\n", "\n", "

เราสามารถประยุกต์ใช้การวนซ้ำแบบ for ร่วมกับคำสั่ง continue ได้โดยมีรูปแบบคำสั่งดังนี้

" ] }, { "cell_type": "markdown", "id": "ee7cb2c6", "metadata": {}, "source": [ "\n", " for target in sequence:\n", "
\n", " \n", " statements1\n", " \n", "
\n", " \n", " if test: continue\n", "
\n", " \n", " statements2\n", " " ] }, { "cell_type": "markdown", "id": "4f8f9bfc", "metadata": {}, "source": [ "

รูปแบบการใช้งานการวนซ้ำแบบ for ในแบบข้างต้นจะดำเนินการ statements1 ในทุกกรณีของการวนซ้ำ แต่จะดำเนินการ statements2 ก็ต่อเมื่อเงื่อนไขใน test ไม่เป็นจริง

\n", "\n", "

การใช้งานการวนซ้ำแบบ for มีความน่าสนใจมากหากใช้งานร่วมกับคำสั่ง break และ else ดังนี้

" ] }, { "cell_type": "markdown", "id": "9e67bcee", "metadata": {}, "source": [ "\n", " for target in sequence:\n", "
\n", " \n", " statements1\n", "
\n", " \n", " if test: break\n", "
\n", " \n", " else:\n", "
\n", " \n", " statements2\n", " " ] }, { "cell_type": "markdown", "id": "5071766f", "metadata": {}, "source": [ "

ในกรณีข้างต้น การวนซ้ำจะสิ้นสุดทันทีที่เงื่อนไข test เป็นจริง ในกรณีที่การวนซ้ำสมาชิกในแต่ละตัวของ sequence หมดแล้วไม่เจอคำสั่ง break โปรแกรมจะดำเนินการในชุดคำสั่ง statements2 ต่อไปนี้

\n", "\n", "

เราสามารถนำการวนซ้ำในทุกรูปแบบที่กล่าวข้างต้นมาซ้อนกันได้เช่นกัน โดยการเพิ่มระดับของ block ในแต่ละขั้นของการวนซ้ำ (ทั้ง while และ for)

" ] }, { "cell_type": "code", "execution_count": null, "id": "5f83c9c0", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "f991203a", "metadata": {}, "source": [ "\n", "\n", "

ตัวอย่างการทำงานของลูป For

\n", "\n", "

ตัวอย่างต่อไปนี้เป็นรูปแบบการใช้งานการวนซ้ำแบบ for ในรูปแบบต่าง ๆ ที่ได้กล่าวไว้ในหัวข้อที่ผ่านมา

\n", "\n", "

ตัวอย่างต่อไปนี้เป็นการวนซ้ำภายในสมาชิกของข้อมูลที่เป็นลำดับ

" ] }, { "cell_type": "code", "execution_count": 76, "id": "36914b33", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "happy new year " ] } ], "source": [ "for x in ['happy', 'new', 'year']:\n", " print(x, end=' ')" ] }, { "cell_type": "code", "execution_count": 77, "id": "1064eab6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n" ] } ], "source": [ "total = 0\n", "for x in [1, 2, 3, 4]:\n", " total = total + x\n", "print(total)" ] }, { "cell_type": "code", "execution_count": 78, "id": "c052b4c8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n", "7\n", "11\n" ] } ], "source": [ "T = [(1,2), (3,4), (5,6)]\n", "for (x, y) in T:\n", " print(x + y)" ] }, { "cell_type": "code", "execution_count": 79, "id": "6a1ccc4a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a -> 1\n", "b -> 2\n", "c -> 3\n" ] } ], "source": [ "D = {'a':1, 'b':2, 'c':3}\n", "for keys in D:\n", " print(keys, \"->\", D[keys])" ] }, { "cell_type": "markdown", "id": "9bfb10d7", "metadata": {}, "source": [ "

กรณีที่เราต้องการให้ตัวแปรที่วนซ้ำเป็นจำนวนเต็มเรียงลำดับ เราจะใช้ฟังก์ชัน range ช่วย โดยที่ฟังก์ชัน range มีการใช้งาน

" ] }, { "cell_type": "markdown", "id": "f0de69d1", "metadata": {}, "source": [ " \n", " range(begin, end, increment)\n", " " ] }, { "cell_type": "markdown", "id": "fd68ff29", "metadata": {}, "source": [ "

โดยที่ begin แทนจำนวนเต็มที่เริ่มนับ end แทนจำนวนสุดท้ายที่นับ (หัก 1) increment แทน การเพิ่มการนับ ในกรณีที่ฟังก์ชัน range มี argument เป็นเลขตัวเดียว เช่น range(n) จะนับจำนวนตั้งแต่ 0 ถึง n - 1 ดังตัวอย่าง

" ] }, { "cell_type": "code", "execution_count": 80, "id": "3f0e1afb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "2\n", "4\n", "6\n", "8\n" ] } ], "source": [ "for i in range(0, 10, 2):\n", " print(i)" ] }, { "cell_type": "code", "execution_count": null, "id": "f85a9805", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "92786d92", "metadata": {}, "source": [ "\n", "\n", "

ลักษณะการทำงานของ Comprehension

\n", "\n", "

Comprehension เป็นรูปแบบการสร้างสมาชิกในลิสท์ประเภทหนึ่งโดยจะใช้การวนซ้ำแบบ for และการสร้างเงื่อนไข if รวมเข้าด้วยกัน โดยมีรูปแบบการเขียนดังรูป


\n", "\n", "
\n", "
\n", " \n", "
รูปแบบการใช้งาน comprehension เบื้องต้น
\n", "
\n", "

\n", "\n", "

โดยที่ f(x) แทน นิพจน์ของตัวแปร x sequence แทน ข้อมูลที่เป็นลำดับ comprehension จะแทน x ด้วยสมาชิกใน sequence แล้วคืนค่า f(x) ภายใต้เงื่อนไขที่ condition เป็นจริงเท่านั้น อาจเป็นเท็จก็จะไม่ดำเนินการใด ๆ ทำให้เราสามารถเขียนสมาชิกในลิสท์ได้กระชับมาขึ้น อีกทั้งเรายังสามารถนำการวนซ้ำแบบ for มาซ้อนกันเพื่อสร้างลิสท์ที่มีความซับซ้อนได้มากยิ่งขึ้นดังรูปค่าล่าง



\n", "\n", "
\n", "
\n", " \n", "
รูปแบบการใช้งาน comprehension แบบสมบูรณ์
\n", "
\n", "
" ] }, { "cell_type": "code", "execution_count": null, "id": "1de3db9f", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "b99aa419", "metadata": {}, "source": [ "\n", "\n", "

ตัวอย่างการทำงานของ Comprehension

\n", "\n", "

หากเราต้องการสร้างลิสท์ใหม่ที่มาจากลิสท์เดิมที่เรามีอยู่แล้ว เช่นบวก 10 ให้กับสมาชิกแต่ละตัวในลิสท์ เราอาจจะใช้การวนซ้ำแบบ for ได้ดังนี้

" ] }, { "cell_type": "code", "execution_count": 81, "id": "4f0ea3af", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[11, 12, 13, 14]" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L = [1, 2, 3, 4]\n", "for i in range(len(L)):\n", " L[i] += 10\n", "L" ] }, { "cell_type": "markdown", "id": "57ef669c", "metadata": {}, "source": [ "

ในกรณีนี้เราจะต้องเขียนคำสั่งที่ยาว แต่เราสามารถเขียนชุดคำสั่งที่ได้ผลลัพธ์เดียวกันโดยใช้ comprehension ดังนี้

" ] }, { "cell_type": "code", "execution_count": 82, "id": "673210ec", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[11, 12, 13, 14]" ] }, "execution_count": 82, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L = [1, 2, 3, 4]\n", "[x + 10 for x in L]" ] }, { "cell_type": "markdown", "id": "bfb2d1c6", "metadata": {}, "source": [ "

นอกเหนือไปจากลิสท์แล้ว comprehension ยังสามารถประยุกต์ใช้ได้กับข้อมูลที่เป็นลำดับได้หมด ดังตัวอย่างต่อไปนี้

" ] }, { "cell_type": "code", "execution_count": 83, "id": "aa19e8d2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['aX', 'aY', 'aZ', 'bX', 'bY', 'bZ', 'cX', 'cY', 'cZ']" ] }, "execution_count": 83, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[x + y for x in 'abc' for y in 'XYZ']" ] }, { "cell_type": "code", "execution_count": 84, "id": "2586be45", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['spam', 'ni']" ] }, "execution_count": 84, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[x for x in ['spam', '', 'ni'] if bool(x)]" ] }, { "cell_type": "code", "execution_count": null, "id": "7216f4ff", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "ce799c7d", "metadata": {}, "source": [ "\n", "\n", "

Function และการใช้งาน

\n", "\n", "

ในหัวข้อนี้เราจะศึกษาการสร้างฟังก์ชัน ซึ่งมีรูปแบบการสร้างหลัก ได้แก่ การเขียนที่เป็นแบบ precedural programming และ functional programming ข้อดีของการสร้างฟังก์ชันมีดังนี้

\n", "\n", "\n", "\n", "

การสร้างฟังก์ชันด้วย def

\n", "\n", "

การสร้างฟังก์ชันด้วยคำสั่ง def มีรูปแบบดังนี้

" ] }, { "cell_type": "markdown", "id": "ddc71585", "metadata": {}, "source": [ "\n", " def function_name(arguments):\n", "
\n", " \n", " statements\n", "
\n", " \n", " return result\n", " " ] }, { "cell_type": "markdown", "id": "3ebf72ae", "metadata": {}, "source": [ "

โดยที่ function_name แทน ชื่อฟังก์ชันที่เราใช้เรียกงาน arguments แทน ค่า input ที่ใส่เข้าไปในฟังก์ชัน statements แทนชุดคำสั่งในฟังก์ชัน สำหรับคำสั่ง return จะมีหรือไม่มีก็ได้ แต่หากมีจะเป็นการคืนค่า result กลับไปยังต้นทาง

\n", "\n", "

หลังจากชื่อฟังก์ชันจะต่อทางด้วย : เพื่อเพิ่มระดับของ block และแสดงชุดคำสั่งที่เป็นของฟังก์ชันโดยการย่อหน้า

\n", "\n", "\n", "

การสร้างฟังก์ชันด้วย lambda

\n", "\n", "

การสร้างฟังก์ชันด้วยคำสั่ง lambda เป็นการสร้างฟังก์ชันโดยไม่เพิ่มระดับของ block โดยที่สามารถสร้างได้ในระดับเดียวกับ block ปัจจุบัน ซึ่งมีประโยชน์ในการส่งฟังก์ชันเป็น argument ของฟังก์ชันอื่น ๆ โดยมีรูปแบบการทำงานดังนี้

" ] }, { "cell_type": "markdown", "id": "83b9f925", "metadata": {}, "source": [ "\n", " lambda vars: \n", " expressions\n", " " ] }, { "cell_type": "markdown", "id": "613d8a22", "metadata": {}, "source": [ "

โดยที่ vars แทน ตัวแปรในฟังก์ชันซึ่งอาจจะมีตัวเดียว หรือหลายตัวแปรก็ได้ ส่วน expressions แทนนิพจน์ของตัวแปร function_name

" ] }, { "cell_type": "markdown", "id": "113a092d", "metadata": {}, "source": [ "\n", "\n", "

ตัวอย่างการใช้ Function

\n", "\n", "

ต่อไปนี้จะเป็นตัวอย่างการสร้างฟังก์ชันโดยผ่านคำสั่ง def

\n" ] }, { "cell_type": "code", "execution_count": 85, "id": "335b1ed7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "8" ] }, "execution_count": 85, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def times(x, y):\n", " return x * y\n", "times(2, 4)" ] }, { "cell_type": "markdown", "id": "dfa7e04c", "metadata": {}, "source": [ "

จากตัวอย่างข้างต้น เราสร้างฟังก์ชันที่มีชื่อว่า times ที่รับค่าสองค่ามีเก็บไว้ที่ตัวแปร x และ y ตามลำดับ แล้วคืนค่าผลคูณของ x และ y

\n", "\n", "

เราสามารถส่งค่าของข้อมูลใด ๆ ลงไปที่ตัวแปร x และ y ตราบเท่าที่ x * y มีความหมาย เช่น

" ] }, { "cell_type": "code", "execution_count": 86, "id": "61df6b52", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'DELPHYSDELPHYSDELPHYSDELPHYS'" ] }, "execution_count": 86, "metadata": {}, "output_type": "execute_result" } ], "source": [ "times('DELPHYS', 4)" ] }, { "cell_type": "code", "execution_count": 87, "id": "109ab649", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2, 3, 2, 3, 2, 3)" ] }, "execution_count": 87, "metadata": {}, "output_type": "execute_result" } ], "source": [ "times((2, 3), 3)" ] }, { "cell_type": "markdown", "id": "5ee18acc", "metadata": {}, "source": [ "

ตัวอย่างการใช้งานแบบอื่นเช่นการหา สมาชิกร่วมของสายอักขระ

" ] }, { "cell_type": "code", "execution_count": 88, "id": "80948660", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'A', 'G', 'K', 'N', 'O', 'R'}" ] }, "execution_count": 88, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def intersection(seq1, seq2):\n", " res = []\n", " for x in seq1:\n", " if x in seq2:\n", " res.append(x)\n", " return set(res)\n", "s1 = \"SONGKRAN\"\n", "s2 = \"LOI KRATHONG\"\n", "intersection(s1, s2)" ] }, { "cell_type": "markdown", "id": "3547af22", "metadata": {}, "source": [ "

ตัวอย่างการสร้างฟังก์ชันโดยใช้ lambda

" ] }, { "cell_type": "code", "execution_count": 89, "id": "85b2ae75", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "9" ] }, "execution_count": 89, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f = lambda x, y, z: x + y + z\n", "f(2, 3, 4)" ] }, { "cell_type": "markdown", "id": "6c379c17", "metadata": {}, "source": [ "

จากตัวอย่าง เราสร้างฟังก์ชันที่รับตัวแปรสามตัวคือ x y และ z โดยคือค่า x + y + z

" ] }, { "cell_type": "code", "execution_count": 90, "id": "ba1b360d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n", "8\n", "16\n" ] } ], "source": [ "L = [lambda x: x**2, lambda x: x**3, lambda x: x**4]\n", "for f in L:\n", " print(f(2))" ] }, { "cell_type": "code", "execution_count": 91, "id": "721f058d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "9" ] }, "execution_count": 91, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L[0](3)" ] }, { "cell_type": "code", "execution_count": null, "id": "235c5a61", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "b03758b4", "metadata": {}, "source": [ "\n", "\n", "

ตัวแปร global และ local

\n", "\n", "

ในหัวข้อนี้เรามาทำความรู้จักตัวแปร ประเภท global และตัวแปรประเภท local ก่อนที่เราจะเข้าใจเรื่องตัวแปรแบบ global และ local เราต้องเข้าใจเรื่องขอบเขตของ function ดังรูป

\n", "\n", "
\n", "
\n", " \n", "
ขอบเขตของ function และตัวแปร
\n", "
\n", "
\n", "
\n", "

จากรูปเราจะเห็นได้ว่าขอบเขตของ func1 อยู่ใน block level 1 ดังนั้นตัวแปรที่นิยามใน block level 1 จะอยู่ภายใต้ขอบเขตของ func1 เท่านั้น ในตัวอย่าง เรานิยามตัวแปร X สองตัวด้วยกันคือ ที่ block level 0 และ block level 1 โดยที่ตัวแปรทั้งสองตัวมีขอบเขตที่ไม่เหมือนกัน และในโปรแกรมภาษา Python นับเป็นตัวแปรคนล่ะตัวกัน

" ] }, { "cell_type": "code", "execution_count": 92, "id": "3ba0eeb0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n" ] } ], "source": [ "X = 1\n", "def func():\n", " X = 10\n", " return None\n", "func()\n", "print(X)" ] }, { "cell_type": "markdown", "id": "af603dc2", "metadata": {}, "source": [ "

จากตัวอย่างเราจะเห็นได้ว่าแม้เราจะเรียกฟังก์ชัน func ซึ่งแทนค่า X ด้วย 10 แต่ไม่มีผลต่อค่าของ X ที่อยู่นอกเขตของ func เลย

\n", "\n", "

เราจะสังเกตได้ว่าในตัวอย่างข้างต้น เราใช้คำสั่ง return แต่เราคืนค่าว่างเปล่าโดยใช้ None

\n", "\n", "

ในกรณีที่ func หาตัวแปรไม่เจอในขอบเขตจะไปค้นหาตัวแปรชื่อเดียวกัน จะระดับก่อนหน้านี้หนึ่งลำดับ

" ] }, { "cell_type": "code", "execution_count": 93, "id": "3cdd04fa", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "11" ] }, "execution_count": 93, "metadata": {}, "output_type": "execute_result" } ], "source": [ "X, Y = 1, 10\n", "def func():\n", " Z = X + Y\n", " return Z\n", "func()" ] }, { "cell_type": "markdown", "id": "ae5c4dbe", "metadata": {}, "source": [ "

หากเราต้องการให้ตัวแปรทำหมดที่อยู่ในแต่ละลำดับของ block เป็นตัวแปรตัวกัน เราต้องใช้คำสั่ง global ดังตัวอย่าง

" ] }, { "cell_type": "code", "execution_count": 94, "id": "287fc21a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "10" ] }, "execution_count": 94, "metadata": {}, "output_type": "execute_result" } ], "source": [ "X = 1\n", "def func():\n", " global X\n", " X = 10\n", " return X\n", "func()" ] }, { "cell_type": "code", "execution_count": null, "id": "0060247d", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "f4bcac97", "metadata": {}, "source": [ "\n", "\n", "

ลักษณะของ input argument ในฟังก์ชัน

\n", "\n", "

ในหัวข้อนี้เราจะมาศึกษาวิธีการส่งค่าไปยังฟังก์ชันที่เราเรียกว่า input arguments การส่ง input arguments ในโปรแกรมภาษา Python เป็นด้วยกัน 4 แบบ คือ

\n", "\n", "\n", "

สำหรับการส่งค่าไปยัง function แบบต่าง ๆ เราจะศึกษากันในหัวข้อถัดไป

" ] }, { "cell_type": "markdown", "id": "3f3c72fe", "metadata": {}, "source": [ "

ตัวอย่างการใช้งาน input argument

\n", "\n", "

ต่อไปจะเป็นการส่งค่า input argument ไปยังฟังก์ชันแบบต่าง ๆ

\n", "\n", "

การส่งค่าตามตำแหน่ง

" ] }, { "cell_type": "code", "execution_count": 96, "id": "0566ec9d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a 1 b 2 c 3\n" ] } ], "source": [ "def func(a, b, c):\n", " print('a', a, 'b', b, 'c', c)\n", "func(1, 2, 3)" ] }, { "cell_type": "markdown", "id": "4f69ba34", "metadata": {}, "source": [ "

ในตัวอย่างข้างต้นเป็นการส่งค่าตามตำแหน่งของตัวแปร a b และ c ที่ถูกนิยามไว้ในฟังก์ชัน

\n", "\n", "

การส่งค่าตามชื่อตัวแปร

\n", "\n", "

จากตัวอย่าง func ที่แล้วเราสามารถระบุชื่อตัวแปรได้ ดังตัวอย่าง

" ] }, { "cell_type": "code", "execution_count": 97, "id": "ce1541b4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a 1 b 3 c 2\n" ] } ], "source": [ "func(1, c=2, b=3)" ] }, { "cell_type": "markdown", "id": "84e91085", "metadata": {}, "source": [ "

จากตัวอย่างข้างต้นเราส่งค่าตามลำดับก่อน คือ ให้ a เท่ากับ 1 ส่วนค่าของ b และ c ตามชื่อตัวแปร

\n", "\n", "

ข้อควรระวังคือเราไม่สามารถส่ง input ตามชื่อ ก่อนการส่ง input ตามตำแหน่งได้

\n", "\n", "

เราสามารถตั้งค่าเริ่มต้นของ input argument ได้โดยการกำหนดไว้ในนิยามของฟังก์ชัน ดังนี้

" ] }, { "cell_type": "code", "execution_count": 98, "id": "19061333", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a 1 b 2 c 3\n" ] } ], "source": [ "def func(a=1, b=2, c=3):\n", " print('a', a, 'b', b, 'c', c)\n", "func()" ] }, { "cell_type": "markdown", "id": "87d29642", "metadata": {}, "source": [ "

จากตัวอย่างข้างต้นเราจะเห็นว่าแม้เราอาจเราไม่ใส่ค่า input อะไรลงไปฟังก์ชันก็จะเรียกค่าตั้งต้นมาใช้

" ] }, { "cell_type": "code", "execution_count": 99, "id": "b6f6fe67", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a 1 b 4 c 3\n" ] } ], "source": [ "func(b=4)" ] }, { "cell_type": "code", "execution_count": 100, "id": "b4c0b6de", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a 5 b 4 c 3\n" ] } ], "source": [ "func(b=4, a=5)" ] }, { "cell_type": "markdown", "id": "780dad3e", "metadata": {}, "source": [ "

การส่งค่าตัวแปรในลิสท์

\n", "\n", "

ในบางกรณีที่เราต้องการส่งค่า input หลาย ๆ ตัว พร้อม ๆ กันเราสามารถทำได้โดยการส่งลิสท์ของ input arguments เข้าไปโดยให้สมาชิกของลิสท์ไปแทนค่า argument ของฟังก์ชัน ดังตัวอย่าง

" ] }, { "cell_type": "code", "execution_count": 101, "id": "b942fb2f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a 1 b 6 c 2\n" ] } ], "source": [ "def func(a=1, b=2, c=3):\n", " print('a', a, 'b', b, 'c', c)\n", "func(1, *[6,2])" ] }, { "cell_type": "markdown", "id": "15e44c42", "metadata": {}, "source": [ "

จากตัวอย่างข้างต้น เราใส่ลิสท์ *[6,2] ลงไปด้วยโดยที่ใส่เครื่องหมาย * ด้วยหากไม่ใส่จะหมายความว่า b = [6,2] การใส่เครื่องหมาย * ไว้หน้าลิสท์จะสื่อความหมายว่า [b,c] = [6,2]

" ] }, { "cell_type": "code", "execution_count": 102, "id": "a3295775", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a 5 b 4 c 3\n" ] } ], "source": [ "func(*[5,4])" ] }, { "cell_type": "markdown", "id": "cb579553", "metadata": {}, "source": [ "

จากตัวอย่างนี้เราใช้การส่งค่า input แบบลิสท์ สำหรับสมาชิกของ argument ชุดแรก ส่วนสมาชิกที่เหลือจะใช้ค่าตั้งต้น

" ] }, { "cell_type": "code", "execution_count": 103, "id": "d56eafa1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a 6 b 7 c 3\n" ] } ], "source": [ "func(c=3, *[6,7])" ] }, { "cell_type": "code", "execution_count": 104, "id": "98e75066", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a 6 b 7 c 3\n" ] } ], "source": [ "func(*[6,7], c=3)" ] }, { "cell_type": "code", "execution_count": 105, "id": "b18d29b3", "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "func() got multiple values for argument 'b'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: func() got multiple values for argument 'b'" ] } ], "source": [ "func(*[6,7], b=3)" ] }, { "cell_type": "markdown", "id": "bf8e66df", "metadata": {}, "source": [ "

ในกรณีข้างต้นโปรแกรม Python จะแสดงข้อผิดพลาดเนื่องจากมีการใส่ค่า input b สองครั้ง ดังนั้นการใส่ค่า input แบบลิสท์ควรระวังเรื่องการใส่ค่า input ที่ซ้อนกัน

\n", "\n", "

การส่งค่าตัวแปรในดิกชันนารี

\n", "\n", "

การใส่ค่า input ในดิกชันนารี โดยการ map ชื่อ input กับค่าต้องใส่เครื่องหมาย ** ดังตัวอย่าง

" ] }, { "cell_type": "code", "execution_count": 106, "id": "1cffd705", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a 3 b 4 c 5\n" ] } ], "source": [ "def func(a, b, c):\n", " print('a', a, 'b', b, 'c', c)\n", "D = {'a':3, 'b':4, 'c':5}\n", "func(**D)" ] }, { "cell_type": "markdown", "id": "45f3b9db", "metadata": {}, "source": [ "

จากตัวอย่างข้างต้นเราสร้างดิกชันนารี D โดยเป็นการรวบรวมชื่อ input และ ค่าพร้อมกันแล้วส่งไปยังฟังก์ชัน

" ] }, { "cell_type": "code", "execution_count": null, "id": "057dd72b", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.10" } }, "nbformat": 4, "nbformat_minor": 5 }