{ "cells": [ { "cell_type": "markdown", "id": "87e10d87-8cdb-4019-8fb8-b91ad1dc124b", "metadata": {}, "source": [ "![](images/python_with_Birds.gif)\n" ] }, { "cell_type": "markdown", "id": "d8e1d91d-38aa-4b67-b97a-31c808b530f8", "metadata": { "tags": [] }, "source": [ "# คลาสและออบเจ็ค (Object Oriented Programming (OOP) in Python)\n", "**40** minutes\n", "\n", " **วัตถุประสงค์**\n", "\n", "\n", " หลังจากทำทำแล็บ นศ.จะสามารถ \n", "\n", "\n", "\n", "\n", "* ใช้งานคลาสและออบเจ็กต์ได้\n", "* กำหนดแอตทริบิวต์และเมธอดของคลาสได้\n", "* Import Matplotlib และ Requests เพื่อพล็อตกราฟและดึงข้อมูลจากหน้าเว็บไซต์อย่างง่ายได้\n" ] }, { "cell_type": "markdown", "id": "2212312f-0b57-49b5-9cf0-40241961b506", "metadata": {}, "source": [ "Ref:\n", "* https://docs.python.org/3/tutorial/classes.html" ] }, { "cell_type": "markdown", "id": "e625bdee-4559-4e9f-b219-eebf05dab471", "metadata": {}, "source": [ "## คลาสและออบเจ็กต์ (Classes☀︎ & Objects☀︎)\n", "\n", "การเขียนโปรแกรมเชิงวัตถุ (OOP) * เป็นเรื่องที่สำคัญมากๆ เป็นแนวคิดที่ใช้กันอย่างแพร่หลายในการเขียนโปรแกรมภาษาสมัยใหม่เกือบทั้งหมด (ยกเว้นภาษา C) \n", "ข้อดีของการเขียนโปรแกรมแบบ OOP คือ ช่วยให้ผู้เขียนโปรแกรมสามารถเปลี่ยนแปลงแก้ไขโค้ดที่เขียนมาแล้วได้อย่างง่ายๆ และโค้ดที่เขียนขึ้นมายังสามารถนำไปใช้ในโปรแกรมที่เขียนขึ้นใหม่ได้ โดยอาจแก้ไขเพียงเล็กน้อยหรือไม่แก้ไขเลย (Reusable) จึงทำให้ OOP เหมาะกับเขียนโปรแกรมขนาดใหญ่และยังช่วยให้โปรแกรมเมอร์ทำงานร่วมกันได้อย่างมีประสิทธิภาพ\n", "\n", "* วิธีการเขียนโปรแกรมเชิงวัตถุ (OOP) ถูกคิดค้นในปี 1967 โดย Dr. Kristen Nygaard ชาวนอร์เวย์ (ภาษา Simula-67) ปัจจุบันหลายภาษารองรับ OOP เช่น JAVA และ Ruby เป็น OOP 100%, Python รองรับการเขียนโปรแกรมทั้งแบบเชิงฟังก์ชันและแบบ OOP, Fortran และ MATLAB เป็นแบบเชิงฟังก์ชันเป็นหลัก บางส่วนเพิ่งแก้ไขเป็น OOP, C เป็นภาษาแบบเชิงฟังก์ชัน 100% ส่วน C++ เป็น C ที่เพิ่ม OOP เข้าไป. \n", "\n", "ภาษา Python รองรับทั้งการเขียนโปรแกรมเชิงวัตถุ (Object-Oriented Programming (OOP)) และเชิงฟังก์ชัน (Functional programming หรือ Structure/Procedure Programming) เพื่อให้นักพัฒนามีทางเลือกในการทำงานในสภาพแวดล้อมที่แตกต่างกัน\n", "\n", "OOP เป็นวิธีการเขียนโปรแกรมโดยมองสิ่งต่างๆ ในระบบเป็น**วัตถุหรือออบเจ็กต์ (Object หรือ Instance of class)** แต่ละวัตถุจะมีความเป็นเอกเทศหรือมีความสมบูรณ์ในตัวเอง กล่าวคือมีทั้ง ข้อมูล (Data) ที่แสดงคุณลักษณะของวัตถุ (Attributes (Variables)) และ เมทธอด (Methods (Functions))☀︎ ที่ใช้ในการเข้าถึงและจัดการกับตัวข้อมูลของวัตถุ (จากนี้ไปจะเรียกทับศัพท์ว่า *ออบเจ็กต์* ) การเขียนโปรแกรมโดยใช้ออบเจ็กต์ทำให้การแลกเปลี่ยนข้อมูลและการติดต่อสื่อสารระหว่างกันทำได้ง่าย และสิ่งที่สำคัญที่สุดคือ ออบเจ็กที่สร้างขึ้นมาแล้วสามารถนำโค้ดของโปรแกรมกลับมาใช้ใหม่ได้อีก (Reusable)\n", "\n", "ในภาษาคอมฯ ก่อนจะสร้างอออบเจ็กต์ขึ้นมาใช้ จำเป็นต้องมีการออกแบบออบเจ็กต์ขึ้นมาก่อน เหมือนกับการสร้างบ้าน ก่อนจะสร้างบ้านสถาปนิกต้องทำการออกแบบโครงสร้างของบ้านลงกระดาษพิมพ์เขียว (Blueprint) หลังจากนั้นวิศวกรจึงนำกระดาษพิมพ์เขียวไปสร้างบ้าน กระดาษพิมพ์เขียวเพียงแผ่นเดียว สามารถนำไปสร้างบ้านได้หลายๆ หลัง ในมุมมองของการเขียนโปรแกรมแบบ OOP กระดาษพิมพ์เขียวก็คือ **คลาส (Class)** และบ้านที่ถูกสร้างขึ้นก็คือ **ออบเจ็กต์ (Object)**\n" ] }, { "cell_type": "markdown", "id": "ac454e04-4e6e-40bf-a272-bf8062a42fc7", "metadata": {}, "source": [ "## ปูพื้นก่อนสร้างคลาส" ] }, { "cell_type": "markdown", "id": "85c3279c-0744-414d-8219-58ce5ec1df60", "metadata": {}, "source": [ "ในขั้นตอนแรก เราจะสร้างคลาส (Class) ขึ้นมา 2 คลาส คือ \n", "- คลาสวงกลม (Circle) และ\n", "- คลาสสี่เหลี่ยมผืนผ้า (Regtangle) \n", "\n", "ในการสร้างคลาส เราต้องกำหนดข้อมูลทั้งหมดที่ประกอบขึ้นเป็นคลาส ซึ่งเราเรียกข้อมูลที่เป็นส่วนประกอบของคลาสนี้ว่า **คุณลักษณะ**หรือ**แอตทริบิวต์ (Attributes (Variables))☀︎** ของวัตถุ\n", "\n", "เราจะใช้กระดาษพิมพ์เขียวสร้างออบเจ็กต์วงกลมและสี่เหลี่ยมผืนผ้า (รูปด้านล่าง)\n", "ในกระดาษพิมพ์เขียวมี 2 คลาส คือ คลาสวงกลมและคลาสสี่เหลี่ยมผืนผ้า แต่ละคลาสจะมีแอตทริบิวต์หรือมีคุณลักษณะเฉพาะตัวของมันเอง คลาสวงกลม Class Circle มีแอตทริบิวต์ radius และ color ส่วนคลาสสี่เหลี่ยมผืนผ้า Class Regtangle มีแอตทริบิวต์ height,width และ color\n", "\n", "\n", "**☀︎คำศัพท์ที่เกี่ยวข้อง**\n", "\n", "* *คลาส (Class)* คือ ประเภทข้อมูลที่กำหนดขึ้นโดยผู้ใช้ (User-defined type) เป็นเสมือนกระดาษพิมพ์เขียว (ต้นแบบ) ที่ใช้ในสร้างออบเจ็คต์ หรือกล่าวอีกนัยหนึ่งก็คือ คลาสคือประเภทข้อมูล (type) ของออบเจ็คต์นั่นเอง\n", "\n", "* *ออบเจ็คต์ (Object หรือ Instance)* คือ สิ่งที่ใช้งานได้จริงๆ ถูกสร้างขึ้นมาจากคลาส\n", "\n", "* *แอตทริบิวต์ (Attributes/Instance attributes)* คือ ข้อมูล (หรือคุณลักษณะ) ที่เป็นสมาชิก (หรือเป็นส่วนประกอบ) ของแต่ละออบเจ็คต์ โดยมักจะกำหนดไว้ในเมธอด \\__init\\__ ของคลาส (Object Content: Data and Attributes)\n", "\n", "* *เมธอด (Method)* คือ ฟังก์ชันการทำงานหรือจัดการข้อมูลที่กำหนดไว้ในคลาส (Methods are functions that are bundled with objects.)\n" ] }, { "cell_type": "markdown", "id": "acdd8dbe-75a1-4673-84d0-c92052a596ad", "metadata": {}, "source": [ "**☀︎คำศัพท์ที่เกี่ยวข้อง (Supplement)**\n", "\n", "* *คลาสแอตทริบิวต์ (class attributes)* คือ ตัวแปรที่ประกาศไว้ภายในคลาส ซึ่งจะแชร์ข้อมูลกับออบเจ็คทุกตัวที่ถูกสร้างขึ้นจากคลาสนั้นๆ โดยจะกำหนดไว้ภายนอกเมธอด \\__init\\__ ของคลาส\n" ] }, { "cell_type": "markdown", "id": "8892a083-335d-4db2-a2f2-88f27702834f", "metadata": {}, "source": [ "![](images/classesclass.png)\n" ] }, { "cell_type": "markdown", "id": "bc981677-9c1c-44a1-b41a-d8a23059f392", "metadata": {}, "source": [ "### ออบเจ็คต์ & แอตทริบิวต์ (Objects and Attributes)\n" ] }, { "cell_type": "markdown", "id": "f503bf13-035e-47ef-8663-fa69c55260c0", "metadata": {}, "source": [ "คลาสจะประกอบไปด้วยสมาชิกสองประเภท คือ **แอตทริบิวต์หรือคุณลักษณะ** (ซึ่งก็คือตัวแปรของคลาส) ใช้ในการเก็บข้อมูลที่ประกอบขึ้นเป็นคลาสนั้นๆ และ **เมธอด (methods)** เป็นฟังก์ชันการทำงานหรือจัดการข้อมูลภายในคลาสนั้นๆ\n", "\n", "\n", "ออบเจ็กต์เป็นตัวแทนของคลาสที่ใช้งานได้จริงๆ (ต่างกับคลาสที่เป็นเพรียงต้นแบบ)\n", "\n", "\n", "ในรูปด้านล่างเป็นรูปของวงกลม 3 วงที่สร้างขึ้นจากคลาสวงกลม แต่ละวงมีชื่อเรียก 'Red circle', 'Yellow circle', และ 'Green circle' โดยทั้ง 3 มีลักษณะเดียวกันคือเป็นวงกลม **แต่**มีข้อมูลประจำตัวหรือคุณลักษณะ (แอตทริบิวต์) radius และ color ที่แตกต่างกัน\n", "\n", "แอตทริบิวต์เป็นตัวแปรของคลาส ณ ที่นี้คือ radius และ color ซึ่งเป็นข้อมูลสาธารณะสามารถเข้าถึงข้อมูลได้จากภายนอกคลาสได้\n", "\n", "ข้อมูลของออบเจ็กต์สามารถเข้าถึงได้ด้วยการเขียนเครื่องหมายจุด (**.**) ต่อท้ายชื่อของออบเจ็กต์ (เป็นการบอกว่าเป็นข้อมูลของออบเจ็กต์นั้นๆ) ซึ่งจะกล่าวถึงต่อไป\n" ] }, { "cell_type": "markdown", "id": "eef6a4e8-2845-4e55-aa4f-cfaf67e76603", "metadata": {}, "source": [ "![](images/classesobj.png)\n" ] }, { "cell_type": "markdown", "id": "8663c3b8-4a0a-4a4e-b8c9-1917a3783263", "metadata": {}, "source": [ "(รูป) ข้อมูลประจำตัวหรือแอตทริบิวต์ที่ต่างกัน เช่น สี (Red , Yellow และ Green )" ] }, { "cell_type": "markdown", "id": "531847e0-3322-4eab-bda4-d9703de82108", "metadata": {}, "source": [ "### ออบเจ็คต์ & เมธอด (Objects and Method)" ] }, { "cell_type": "markdown", "id": "7746aa6f-e987-48d2-a22c-3abc46a5e693", "metadata": {}, "source": [ "เมธอด (Method) คือฟังก์ชันการทำงานหรือจัดการข้อมูลในคลาส (เมธอดนั้นคล้ายกับฟังก์ชัน (Functions) แต่ในบริบทของการเขียนโปรแกรมเชิงวัตถุแล้วเราจะเรียกว่า \"เมธอด (Method)\" แทน เพราะว่ามันถูกประกาศอยู่ภายในคลาส!) \n", "เราสามารถใช้เมธอดเปลี่ยนข้อมูลประจำตัวหรือแอตทริบิวต์ของออบเจ็กต์ เช่น หากเราต้องการเพิ่มรัศมีให้กับวงกลม เราก็แค่สร้างเมธอดที่ชื่อ **add_radius(r)** เพื่อปรับรัศมีให้เพิ่มขึ้นอีก **r** หน่วย เป็นต้น \n", "\n", "ออบเจ็กต์จะเรียกใช้เมธอดได้ด้วยการเขียนเครื่องหมายจุด (**.**) ต่อท้ายชื่อของออบเจ็กต์ (เป็นการบอกว่าออบเจ็กต์นั้นผู้เรียกนั่นเอง)\n" ] }, { "cell_type": "markdown", "id": "a18c2c3c-0d9d-4934-820b-f225f1418218", "metadata": {}, "source": [ "![](images/ClassesMethod.png) \n" ] }, { "cell_type": "markdown", "id": "6d4241f2-7753-42e7-ac76-3573b0509c95", "metadata": {}, "source": [ "(รุป) ออบเจ็กต์เรียกเมธอด add_raius( )" ] }, { "cell_type": "markdown", "id": "45a93ec5-23d0-48e5-8ef5-8eee12e9f36e", "metadata": {}, "source": [ "
\n" ] }, { "cell_type": "markdown", "id": "55fbc885-fbe7-442c-820c-4a9897700af6", "metadata": {}, "source": [ "## การสร้างคลาส -- คลาสวงกลม (Circle Class) สำหรับออบเจ็กต์วงกลม" ] }, { "cell_type": "markdown", "id": "735ca63c-775f-4404-818c-86dcf50d8ad1", "metadata": {}, "source": [ "ก่อนที่จะอธิบายการสร้างคลาสวงกลม ให้ import **Module (โมดูล)**☀︎ ที่ใช้ในการวาดรูปให้เข้ามาในโปรแกรมก่อน\n" ] }, { "cell_type": "markdown", "id": "c3709fcb-3135-4f13-8950-d755f7bf66f0", "metadata": {}, "source": [ "☀︎**โมดูล (Module) หรือ แพคเกจ (Package) หรือ ไลบรารี่ (Library)** เปรียบเสมือนโปรแกรมสำเร็จรูป (อาจจะมีแค่หนึ่งไฟล์หรือสิบไฟล์หรือมากถึงร้อยไฟล์ก็ได้) ที่เก็บฟังก์ชัน คลาส ตัวแปรและค่าพิเศษต่างๆ เฉพาะทางไว้ \n", "\n", "โมดูลของไพธอนมีทั้งที่ถูกพัฒนาโดยผู้พัฒนาหลัก (Core Developer) และผู้ใช้งานทั่วไป โดยจะถูกอัพโหลดขึ้นไปเก็บไว้ในเซอร์เวอร์ [Python Package Index (เรียกย่อๆว่า \"PyPI\"; the official 3rd-party software repository!)](https://pypi.org/) หรือไม่ก็เซอร์เวอร์ของ [Anaconda Cloud](https://anaconda.org/anaconda-server) \n", "ประโยชน์ของโมดูล คือผู้ใช้งานไม่จำเป็นที่จะต้องสร้างโมดูล (ฟังก์ชั่นหรือคลาส) ขึ้นมาใหม่เองทั้งหมด แต่สามารถนำโมดูลที่ถูกพัฒนาไว้อยู่แล้วมาใช้งานได้เลย\n", "\n", "* โมดูลที่เป็น 3rd-party สามารถติดตั้ง (Install) ได้เองโดยใช้คำสั่งต่อไปนี้\n", " - pip install ชื่อของโมดูล สำหรับคนที่ใช้ไพธอนของ Python.org\n", " - conda install ชื่อของโมดูล สำหรับคนที่ใช้ไพธอนของ Anaconda\n", " \n", " (ยกเลิกการติดตั้ง (Unininstall) ก็สามารถทำได้โดยใช้คำสั่ง uninstall )" ] }, { "cell_type": "markdown", "id": "bbe30af6-1240-4132-9a2b-31308ff8039b", "metadata": {}, "source": [ "*ตัวอย่างของโมดูลยอดนิยมที่ผู้เขียนไพธอนทั่วไปนิยมใช้ (แยกตามประเภทของการใช้งาน) มีดังต่อไปนี้*\n", " \n", "* การจัดการข้อมูลและวิเคราะห์ข้อมูล (รูปแบบตาราง) (Data Manipulation): Pandas \n", "* การดึงข้อมูลจาก web (Web Scraping): Requests, Selenium, Beautiful Soup, lxml\n", "* การคำนวณทางคณิตศาสตร์และสถิติ (Mathematics and Statistics): NumPy (คำนวน Vector และ Matrix), SciPy\n", "* การสร้างแบบจำลองทางคณิตศาตร์สำหรับเรียนรู้ของเครื่องจักร (Machine Learning Framework): Scikit-Learn\n", "* การสร้างแบบจำลองสำหรับการเรียนรู้เชิงลึก(Deep learning): TensorFlow, Keras (High-level interface of TensorFlow), PyTorch\n", "* การแสดงผลข้อมูล/พล็อตกราฟ (Data Visualization): Matplotlib, Seaborn, ggplot\n", "* การสร้าง GUI (Graphical User Interface/Front-ends/User interface): TKinter (TKinter + ttk), Streamlit (Web Application)" ] }, { "cell_type": "markdown", "id": "93010b4d-f609-4820-844a-1d496b6a4a5b", "metadata": {}, "source": [ "ณ ที่นี้เราจะใช้ matplotlib ในการวาดรูป (พล็อตกราฟ)" ] }, { "cell_type": "code", "execution_count": 1, "id": "3666faf1-9f79-48e8-985f-3fdebf78e9b6", "metadata": {}, "outputs": [], "source": [ "# Import the library\n", "\n", "import matplotlib.pyplot as plt\n", "# %matplotlib inline # Using this command ensures that Jupyter Notebooks show your plots. " ] }, { "cell_type": "markdown", "id": "ecdc0713-5462-4c30-b3eb-7c0f35b172f7", "metadata": {}, "source": [ "
\n", "\n", "**Note:**\n", "**[Magic Commands](https://ipython.readthedocs.io/en/stable/interactive/magics.html) ☜** \n", "%matplotlib inline เป็นคำสั่งที่ใช้เฉพาะในกรณีที่รันภายใต้ IPython (Interactive Python) เช่น Jupyter notebook, JupyterLab, Google Colaboratory (Colab) เมื่อรันคำสั่งนี้ จะทำให้ผลลัพธ์ของการพล็อตแสดงในเซลล์เอาต์พุตและบันทึกเก็บในโน้ตได้\n", " \n", "Magic Commands อื่นๆ เช่น %system date (ดูรายละเอียดในลิงค์ข้างบน)\n", "\n", "
" ] }, { "cell_type": "markdown", "id": "f18e82ae-587b-437e-ba6b-73d9946a9368", "metadata": {}, "source": [ "ในสร้างคลาส เราจะใช้คีย์เวิร์ด class ตามด้วยชื่อของคลาส ClassName และปิดท้ายชื่อด้วยเครื่องหมาย colon (:) ดังแสดงในรูปด้านล่าง เพื่อบอกว่าจะเริ่มบล็อกคำสั่งของคลาสแล้ว\n", "บล็อกคำสั่งของคลาสจะเป็นคำสั่งที่เกี่ยวกับการกำหนดตัวแปรและเมธอดของคลาสโดยจะอยู่เยื้องย่อหน้าเข้าไป (Indentation) \n", "\n", "การตั้งชื่อคลาสจะใช้กฎเดียวกับการตั้งชื่อของตัวแปร เราสามารถตั้งชื่อของคลาสเป็นอะไรก็ได้ แต่ควรตั้งชื่อที่สื่อความหมาย และ...**มักตั้งชื่อคลาสที่ขึ้นต้นด้วยตัวพิมพ์ใหญ่และเป็นสไตล์แบบหลังอูฐ (CamelCase)** \n", "\n", "\n", "\n", "ในขณะที่ ชื่อเมธอดมักจะตั้งชื่อให้ขึ้นต้นด้วยตัวอังกฤษพิมพ์เล็กและมักเป็นเป็นกริยา เช่น add..., get... \n", "\n", "__คลาสจะต้องถูกรันก่อนที่จะมีการเรียกใช้ เช่นเดียวกับฟังก์ชั่น__\n", "\n", "\n", "**Class syntax:**\n", "```\n", "class ClassName:\n", " def method_name1(self, arg1, arg2, ..)\n", " \n", " def method_name2(self, arg1, arg2, ..)\n", " .\n", " .\n", " .\n", " .\n", " ```\n", "\n", "\n", "ตัวอย่างการประกาศคลาส Circle" ] }, { "cell_type": "markdown", "id": "e68d86c4-5769-4f16-9091-8aa089d0aa3b", "metadata": {}, "source": [ "![](images/ClassesDefine.png)\n" ] }, { "cell_type": "markdown", "id": "1b6fc916-a3fc-4897-8f8f-25d81921052e", "metadata": {}, "source": [ "ภายในคลาส Circle มีเมธอดพิเศษที่เรียกว่า *คอนสตรักเตอร์ (Constructor)☀︎* \\_\\_init\\_\\_( ) ซึ่งเป็นเมธอดที่จะถูกเรียกอัตโนมัติเมื่อมีการสร้างออบเจ็กต์ มักจะใช้กำหนดแอตทริบิวต์และค่าเริ่มต้นให้กับออบเจ็คที่สร้างขึ้น **พารามิเตอร์แรก**ของเมธอด \\_\\_init\\_\\_( ) จะเป็น **self เสมอ** ซึ่ง**เป็นตัวแปรที่ใช้ในการอ้างถึงออบเจ็คที่ถูกสร้างขณะนั้น** คลาสที่ประกาศขึ้นนี้มีสองแอตทริบิวต์คือ radius และ color ใช้สำหรับเก็บค่ารัศมีและสีของแต่ละออบเจ็กต์ (วงกลม) เราสามารถเข้าถึงแอตทริบิวต์ radius ได้โดยใช้ syntax self.radius และเข้าถึงแอตทริบิวต์ color ได้โดยเขียน self.color \n", "\n", "นอกจากนี้ เรายังมีเมธอด add_radius( ) ที่มีพารามิเตอร์เป็น r เมธอดนี้จะบวกเพิ่ม r ให้กับแอตทริบิวต์ radius\n" ] }, { "cell_type": "markdown", "id": "e76c1f40-e223-4fae-8741-eafff3342b3c", "metadata": {}, "source": [ "☀︎ **คำศัพท์ที่เกี่ยวข้อง**\n", "* **คอนสตรักเตอร์ (Constructor)** หมายถึง เมธอดหรือฟังก์ชันแรกที่ถูกเรียกใช้ทุกครั้งโดยอัตโนมัติเมื่อมีการสร้างออบเจ็กต์ เพื่อกำหนดแอตทริบิวต์/ค่าเริ่มต้นให้กับออบเจ็คที่สร้างขึ้น \n", "การสร้างคอนสตรัคเตอร์ในภาษาไพธอนจะใช้คำสั่ง \\_\\_init\\_\\_( ) (ขีดล่าง \\_ สองขีด ทั้งหน้าและหลัง!)\n", "\n", "* **ดีสตรัคเตอร์ (Destructor)** หมายถึง เมธอดหรือฟังก์ชันที่ถูกเรียกใช้โดยอัตโนมัติเมื่อมีการลบออบเจ็กต์ หรือออบเจ็กต์ที่ประกาศไว้หมดอายุการใช้งาน เพือจัดการทําลายคอนสตรักเตอร์ (ล้างตัวแปรและคืนหน่วยความจำสู่ระบบ) การสร้างดีสตรัคเตอร์ในภาษาไพธอนจะใช้คำสั่ง \\_\\_del\\_\\_( )\n" ] }, { "cell_type": "markdown", "id": "0a0a3832-f641-4793-b005-bbbd1b0a1f22", "metadata": {}, "source": [ "![](images/ClassesCircle.png)\n" ] }, { "cell_type": "markdown", "id": "c440af5d-69b1-48bc-90ba-451712aaf44e", "metadata": {}, "source": [ "เราเขียนเมธอด drawCircle( ) เพิ่มเข้าไปในคลาสเพื่อแสดงภาพของวงกลม และกำหนดค่ารัศมีเริ่มต้นเป็น 3 และสีเริ่มต้นเป็นสีน้ำเงิน" ] }, { "cell_type": "code", "execution_count": 2, "id": "5ee2b43b-d3ba-460e-a518-e21894cf64f1", "metadata": {}, "outputs": [], "source": [ "# Create a class Circle\n", "# class Circle(object): # Python 2\n", "\n", "class Circle:\n", " \"\"\"\n", " The class Circle has the attribute radius and color, \n", " the method add_radius(r) to increases the radius by r, \n", " the method drawCircle() to display the image of a circle.\n", " \n", " \"\"\"\n", " # Constructor\n", " def __init__(self, radius=3, color='blue'):\n", " self.radius = radius\n", " self.color = color \n", " \n", " # Method\n", " def add_radius(self, r):\n", " self.radius = self.radius + r\n", " return(self.radius)\n", " \n", " # Method\n", " def drawCircle(self):\n", " plt.gca().add_patch(plt.Circle((0, 0), radius=self.radius, fc=self.color)) # Add the patch to the Axes\n", " plt.axis('scaled') # Setting the axis to “scaled” ensures that you can see the added shape properly. \n", " plt.show() " ] }, { "cell_type": "markdown", "id": "6e29b564-29dc-4c4f-b3f0-b787ba3410f7", "metadata": {}, "source": [ "เมื่อกำหนดคลาสเสร็จ ต่อไปเราจะนำคลาสไปสร้างออบเจ็กต์" ] }, { "cell_type": "markdown", "id": "5c217e4b-a769-4096-b99f-b7f774c4b87a", "metadata": {}, "source": [ "___\n" ] }, { "cell_type": "markdown", "id": "c4ceecd0-e02e-4b36-a5c3-2e905ce9c74c", "metadata": {}, "source": [ "**ตัวอย่างการใช้ Matplotlib**" ] }, { "cell_type": "code", "execution_count": 3, "id": "1e8ba63a-2763-40e4-820d-480e9923cc93", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "\n", "# plot is a versatile function, and will take an arbitrary number of arguments. \n", "# For example, to plot x versus y, you can write:\n", "plt.plot([1, 2, 3, 4], [1, 4, 9, 16])\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 4, "id": "cae4a419-aec6-442d-91da-56bd1df9860c", "metadata": {}, "outputs": [], "source": [ "# To plot f1(t) = t, f2(t) = t^2, f3(t) = t^3\n", "# t = range(0, 5, 0.2) # If you use range() with float step argument, you will get a TypeError 'float' object cannot be interpreted as an integer.\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "f93a3e6c-12b1-439d-8e36-21dfbe1944e4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8, 2. , 2.2, 2.4,\n", " 2.6, 2.8, 3. , 3.2, 3.4, 3.6, 3.8, 4. , 4.2, 4.4, 4.6, 4.8])" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Use NumPy’s arange() orlinspace() functions to use decimal numbers in a start, \n", "# stop and step argument to produce a range of floating-point numbers.\n", "\n", "import numpy as np\n", "\n", "t = np.arange(0., 5., 0.2)\n", "t" ] }, { "cell_type": "code", "execution_count": 6, "id": "7644a61f-5aae-4625-acfc-67209b29af58", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# evenly sampled time at 200ms intervals\n", "t = np.arange(0., 5., 0.2)\n", "\n", "# red dashes, blue squares and green triangles\n", "plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "30c114d4-eb22-412d-9c60-85d4b11dddf6", "metadata": {}, "source": [ "
\n", "\n", "รายละเอียดการใช้ Matplotlib ดูเพิ่มเติมที่ [Matplotlib Tutorials](https://matplotlib.org/stable/tutorials/index.html)\n", "\n", "
" ] }, { "cell_type": "markdown", "id": "e021bd2c-5442-4837-9dba-4402814d8199", "metadata": {}, "source": [ "## การสร้างตัวแปรออบเจ็กต์จากคลาส" ] }, { "cell_type": "markdown", "id": "16361995-af3f-405a-aa04-587d15005eb6", "metadata": {}, "source": [ "สร้างตัวแปรออบเจ็กต์ RedCircle จากคลาส Circle" ] }, { "cell_type": "code", "execution_count": 7, "id": "63287bdb-a2ca-4c5a-8816-89fb8363edb1", "metadata": {}, "outputs": [], "source": [ "# Create an object RedCircle\n", "\n", "RedCircle = Circle(10, 'red')" ] }, { "cell_type": "markdown", "id": "3836089a-8b2b-469d-b58a-efc54f5eccd1", "metadata": {}, "source": [ "เราสามารถใช้ฟังก์ชัน dir( ) เพื่อรับลิสต์ของเมธอดทั้งหมดที่มีอยู่ในออบเจ็กต์ หลายเมธอดของออบเจ็กต์เป็นดีฟอลต์เมธอดของไพธอน\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "2d3f0440-cb15-419f-baef-0e23c650ca5e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['__class__',\n", " '__delattr__',\n", " '__dict__',\n", " '__dir__',\n", " '__doc__',\n", " '__eq__',\n", " '__format__',\n", " '__ge__',\n", " '__getattribute__',\n", " '__gt__',\n", " '__hash__',\n", " '__init__',\n", " '__init_subclass__',\n", " '__le__',\n", " '__lt__',\n", " '__module__',\n", " '__ne__',\n", " '__new__',\n", " '__reduce__',\n", " '__reduce_ex__',\n", " '__repr__',\n", " '__setattr__',\n", " '__sizeof__',\n", " '__str__',\n", " '__subclasshook__',\n", " '__weakref__',\n", " 'add_radius',\n", " 'color',\n", " 'drawCircle',\n", " 'radius']" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Find out the methods can be used on the object RedCircle\n", "\n", "dir(RedCircle)" ] }, { "cell_type": "markdown", "id": "425618cf-9eda-4861-a06a-971c27d06a16", "metadata": {}, "source": [ "ในภาษา Python สามารถตรวจสอบ attributes ภายในออบเจ็กต์ได้ โดยใช้คำสั่ง \\__dict\\__( ) \n", "\n", "ดูการใช้งาน Docstrings ได้โดยใช้คำสั่ง \\__doc\\__( )\n", "(การประกาศ Docstrings ใช้ triple single quotes ('''...''') หรือ triple double quotes (\"\"\"...\"\"\") เหมือนฟังก์ชัน)" ] }, { "cell_type": "code", "execution_count": 9, "id": "23252d7a-02f1-438d-9291-244dc33aaba2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'radius': 10, 'color': 'red'}\n", "\n", " The class Circle has the attribute radius and color, \n", " the method add_radius(r) to increases the radius by r, \n", " the method drawCircle() to display the image of a circle.\n", " \n", " \n" ] } ], "source": [ "print(RedCircle.__dict__) # {'radius': 10, 'color': 'red'}\n", "print(RedCircle.__doc__) # Class Docstrings" ] }, { "cell_type": "code", "execution_count": 10, "id": "e47ddfb4-3de5-44b1-aae5-23baf011acb6", "metadata": {}, "outputs": [], "source": [ "# Create one more object RedCircle\n", "\n", "GreenCircle = Circle(20, 'green')" ] }, { "cell_type": "markdown", "id": "cf10e19e-2022-4398-ab18-4b6c34d23ac6", "metadata": {}, "source": [ "คลาสหนึ่งคลาสสามารถนำไปสร้างเป็นออบเจ็คกี่อันก็ได้ ซึ่งถือว่าเป็นแนวคิดที่สำคัญของการเขียนโปรแกรมเชิงวัตุในการนำโค้ดกลับมาใช้ซ้ำได้" ] }, { "cell_type": "markdown", "id": "f12eabec-45b1-48eb-bc88-09aa6730cbf6", "metadata": {}, "source": [ "ตามที่ได้กล่าวไว้ตอนต้นๆ ว่า แอตทริบิวต์เป็นตัวแปรของคลาส (ณ ที่นี้คือ radius และ color) เป็นข้อมูลสาธารณะ ดังนั้นเราสามารถเข้าถึงข้อมูลจากภายนอกคลาสได้" ] }, { "cell_type": "code", "execution_count": 11, "id": "21b17141-7202-4b9c-ba4e-6e543976218e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "10" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Print the object attribute radius\n", "\n", "RedCircle.radius" ] }, { "cell_type": "code", "execution_count": 12, "id": "78df2654-df71-4337-95da-71174da111da", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'red'" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Print the object attribute color\n", "\n", "RedCircle.color" ] }, { "cell_type": "markdown", "id": "f0bb27cd-6a79-4aeb-a6d2-330b76ac09fd", "metadata": {}, "source": [ "และสามารถเปลี่ยนค่าของแอตทริบิวต์ได้เช่นกัน" ] }, { "cell_type": "code", "execution_count": 13, "id": "9f2bcdab-d24e-4d45-8dde-492032617e8f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Set the object attribute radius\n", "\n", "RedCircle.radius = 1\n", "RedCircle.radius" ] }, { "cell_type": "markdown", "id": "4571793f-a78f-44cd-9873-10319d930aea", "metadata": {}, "source": [ "ลองวาดออบเจ็กต์นี้โดยเรียกเมธอด drawCircle():\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "5d06e6f0-bec6-461b-9284-834abad8ac86", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Call the method drawCircle\n", "\n", "RedCircle.drawCircle()" ] }, { "cell_type": "markdown", "id": "f8e7a326-5ece-41ca-b3c6-535dbcfd7f0d", "metadata": {}, "source": [ "เราสามารถเพิ่มรัศมีของวงกลมได้โดยใช้เมธอด add_radius(). ลองเพิ่มรัศมีอีก 2 หน่วย แล้วเพิ่มต่ออีก 5 หน่วย ดูว่าสุดท้ายรัศมีจะเป็นเท่าไหร่" ] }, { "cell_type": "code", "execution_count": 15, "id": "ff66b0d5-dd7e-4350-816d-cc24f4909878", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Radius of object: 1\n", "Radius of object of after applying the method add_radius(2): 3\n", "Radius of object of after applying the method add_radius(5): 8\n" ] } ], "source": [ "# Use method to change the object attribute radius\n", "\n", "print('Radius of object:',RedCircle.radius)\n", "RedCircle.add_radius(2)\n", "print('Radius of object of after applying the method add_radius(2):',RedCircle.radius)\n", "RedCircle.add_radius(5)\n", "print('Radius of object of after applying the method add_radius(5):',RedCircle.radius)" ] }, { "cell_type": "markdown", "id": "a09794aa-6500-497b-8eec-888976eb886f", "metadata": {}, "source": [ "เรามาสร้างวงกลมสีน้ำเงินเพิ่มอีกอัน \n", "\n", "เนื่องจากสีเริ่มต้นเป็นสีน้ำเงินอยู่แล้ว จึงแค่ส่งอาร์กิวเมนต์ radius ตามที่ต้องการ\n" ] }, { "cell_type": "code", "execution_count": 16, "id": "a87e9c4c-44f7-4f55-85ab-a9dcec19bdf8", "metadata": {}, "outputs": [], "source": [ "# Create a blue circle with a given radius\n", "\n", "# BlueCircle = Circle(100)\n", "BlueCircle = Circle(radius=100)" ] }, { "cell_type": "markdown", "id": "02846792-6b11-451b-936c-083be934e24e", "metadata": {}, "source": [ "เช่นเดียวกับก่อนหน้า เราสามารถเข้าถึงข้อมูลของออบเจ็กต์โดยใช้เครื่องหมายจุด (**.**) ต่อท้ายชื่อของออบเจ็กต์" ] }, { "cell_type": "code", "execution_count": 17, "id": "65fbeab9-d7d4-4897-97d3-9eec39b12220", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "100" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Print the object attribute radius\n", "\n", "BlueCircle.radius" ] }, { "cell_type": "code", "execution_count": 18, "id": "b6cfa9d8-b995-4af1-8493-31a94ef5b81d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'blue'" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Print the object attribute color\n", "\n", "BlueCircle.color" ] }, { "cell_type": "markdown", "id": "c11a3f9a-30b9-41f2-80c1-97001e4ce797", "metadata": {}, "source": [ "แน่นอน ทุกออบเจ็กต์ที่สร้างขึ้นมาสามารถเรียกใช้เมธอด drawCircle() ได้\n" ] }, { "cell_type": "code", "execution_count": 19, "id": "dd354da1-ebc8-44ad-8fb3-108904d4516c", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Call the method drawCircle\n", "\n", "BlueCircle.drawCircle()" ] }, { "cell_type": "markdown", "id": "adefe7b9-ed65-4f32-9f8a-2a0674aa7c3d", "metadata": {}, "source": [ "ดูที่สเกล มีขนาดต่างกับ RedCircle" ] }, { "cell_type": "markdown", "id": "c1315675-259c-457a-89c9-6c6c3b5b8d04", "metadata": {}, "source": [ "
\n" ] }, { "cell_type": "markdown", "id": "d0f17342-c261-4ae4-ad37-984d81dec37d", "metadata": {}, "source": [ "## คลาสสี่เหลี่ยมผืนผ้า (Rectangle Class)\n" ] }, { "cell_type": "markdown", "id": "1763941a-bb30-4ce7-85cd-10b7f5383b95", "metadata": {}, "source": [ "สร้างคลาสสี่เหลี่ยมผืนผ้า Class Regtangle โดยให้มีแอตทริบิวต์ height, width และ color และมีเมธอด\n", "สำหรับวาดรูปออบเจ็กต์สี่เหลี่ยมผืนผ้า" ] }, { "cell_type": "code", "execution_count": 20, "id": "af75b87f-ef99-431c-8ce0-a1e7fba645e0", "metadata": {}, "outputs": [], "source": [ "# Create a new Rectangle class for creating a rectangle object\n", "class Rectangle:\n", " \n", " # Constructor\n", " def __init__(self, width=2, height=3, color='red'):\n", " self.height = height \n", " self.width = width\n", " self.color = color\n", " \n", " # Method\n", " def drawRectangle(self):\n", " plt.gca().add_patch(plt.Rectangle((0, 0), self.width, self.height ,fc=self.color))\n", " plt.axis('scaled') \n", " plt.show()\n", " " ] }, { "cell_type": "markdown", "id": "945c515f-e741-47b4-ba60-aa072d83b34f", "metadata": {}, "source": [ "สร้างตัวแปรออบเจ็กต์สี่เหลี่ยมผืนผ้า SkinnyBlueRectangle มีความกว้าง (width) 2 และความสูง (height) และสีน้ำเงิน (blue)\n" ] }, { "cell_type": "code", "execution_count": 21, "id": "97986a00-eaeb-4b26-ab60-ed7aad66e2f5", "metadata": {}, "outputs": [], "source": [ "# Create a new object rectangle\n", "\n", "SkinnyBlueRectangle = Rectangle(2, 10, 'blue')" ] }, { "cell_type": "markdown", "id": "61ecdfe5-43f3-44e7-901d-b1f6312780d5", "metadata": {}, "source": [ "เช่นเดียวกับก่อนหน้า เราสามารถเข้าถึงข้อมูลของออบเจ็กต์โดยใช้เครื่องหมายจุด (**.**) ต่อท้ายชื่อของออบเจ็กต์" ] }, { "cell_type": "code", "execution_count": 22, "id": "51b996a8-49aa-4c54-8098-0ddbbd9f2a82", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "10" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Print the object attribute height\n", "\n", "SkinnyBlueRectangle.height " ] }, { "cell_type": "code", "execution_count": 23, "id": "b9f85c1c-d359-4468-812f-cf6f6847f307", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Print the object attribute width\n", "\n", "SkinnyBlueRectangle.width" ] }, { "cell_type": "code", "execution_count": 24, "id": "f6ebab70-3ffa-465f-90e4-cc2f4e2ac86c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'blue'" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Print the object attribute color\n", "\n", "SkinnyBlueRectangle.color" ] }, { "cell_type": "markdown", "id": "4382923e-25a8-4cf2-9706-eb0325a230b6", "metadata": {}, "source": [ "สามารถวาดออบเจ็กต์ SkinnyBlueRectangle ได้" ] }, { "cell_type": "code", "execution_count": 25, "id": "17b56957-6a6b-4767-bd30-95450a77319a", "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Use the drawRectangle method to draw the shape\n", "\n", "SkinnyBlueRectangle.drawRectangle()" ] }, { "cell_type": "markdown", "id": "450dbf9d-ec4b-46e5-911d-708e9ab06524", "metadata": {}, "source": [ "ลองสร้างออบเจ็กต์สี่เหลี่ยมผืนผ้าอีกอัน FatYellowRectangle\n" ] }, { "cell_type": "code", "execution_count": 26, "id": "8cb3986d-4b28-4916-a8dc-a00172777e5c", "metadata": {}, "outputs": [], "source": [ "# Create a new object rectangle\n", "\n", "FatYellowRectangle = Rectangle(20, 5, 'yellow')" ] }, { "cell_type": "markdown", "id": "9329faa7-785d-4ad4-8c76-124508792b1d", "metadata": {}, "source": [ "เข้าถึงข้อมูลของออบเจ็กต์โดยใช้เครื่องหมายจุด (**.**) ต่อท้ายชื่อของออบเจ็กต์\n" ] }, { "cell_type": "code", "execution_count": 27, "id": "b3ec7033-c776-4066-ae34-ade74cb8934a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Print the object attribute height\n", "\n", "FatYellowRectangle.height " ] }, { "cell_type": "code", "execution_count": 28, "id": "7ba1b741-6d05-4dbf-b569-3b905831d40d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "20" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Print the object attribute width\n", "\n", "FatYellowRectangle.width" ] }, { "cell_type": "code", "execution_count": 29, "id": "9ea02751-85bf-4176-ab4c-4e1ed9ebc26e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'yellow'" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Print the object attribute color\n", "\n", "FatYellowRectangle.color" ] }, { "cell_type": "code", "execution_count": 30, "id": "90d5c7b4-6d2f-4649-b351-ef68d55fbd02", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Use the drawRectangle method to draw the shape\n", "\n", "FatYellowRectangle.drawRectangle()" ] }, { "cell_type": "markdown", "id": "c3f629b7-0a5b-4914-92ed-f1a94b282775", "metadata": {}, "source": [ "---\n" ] }, { "cell_type": "markdown", "id": "42ef59c3-2837-47cf-ae7c-c3e561aac05c", "metadata": { "tags": [] }, "source": [ "## [Exercises] - Class OKOKOK\n" ] }, { "cell_type": "markdown", "id": "bc2e57db-2fdd-48df-bed8-62923bb9e8fd", "metadata": { "tags": [] }, "source": [ "1) จากคลาส ForEver ต่อไปนี้???\n", "\n", "```python\n", "class HelloForEver:\n", " def readline(self):\n", " return 'Hello.\\n'\n", "```\n", "\n", "ถ้าสร้างตัวแแปรออบเจ็กต์ f ขึ้นมา จากนั้นรันตามโค้ตต่อไปนี้ ผลลัพธ์จะเป็นอย่างไร?\n", "\n", "```python\n", "f = HelloForEver()\n", "\n", "print(f.readline())\n", "print(f.readline())\n", "print(f.readline())\n", "print(f.readline())\n", "```" ] }, { "cell_type": "code", "execution_count": 31, "id": "3b517043-411e-4d35-b664-9616764e781f", "metadata": { "id": "o0YNMNxQPCfp", "tags": [] }, "outputs": [], "source": [ "# Write your code below. Don't forget to press Shift+Enter to execute the cell\n" ] }, { "cell_type": "markdown", "id": "c3e1fae2-464c-4b54-bf8e-a7339a69a9c1", "metadata": { "tags": [] }, "source": [ "2) จากคลาส HelloFile ต่อไปนี้???\n", "\n", "```python\n", "class HelloFile:\n", " def __init__(self, n):\n", " self.n = n\n", " def readline(self):\n", " if self.n == 0: \n", " return ''\n", " self.n = self.n - 1 \n", " return 'Hello.\\n'\n", "```\n", "\n", "ถ้าสร้างตัวแแปรออบเจ็กต์ f ขึ้นมา หลังจากนั้นรันตามโค้ตต่อไปนี้ ผลลัพธ์จะเป็นอย่างไร?\n", "\n", "```python\n", "f = HelloFile(3)\n", "\n", "print(f.n)\n", "print(f.readline())\n", "print(f.readline())\n", "print(f.n)\n", "print(f.readline())\n", "print(f.readline())\n", "print(f.n)\n", "print(f.n)\n", "\n", "```\n" ] }, { "cell_type": "code", "execution_count": 33, "id": "e7750387-5a54-49c1-85e1-ceb4126f5d3c", "metadata": { "id": "o0YNMNxQPCfp", "tags": [] }, "outputs": [], "source": [ "# Write your code below. Don't forget to press Shift+Enter to execute the cell\n" ] }, { "cell_type": "markdown", "id": "4b6b450f-d2cf-4eec-a799-146e1526e20f", "metadata": { "tags": [] }, "source": [ "3) จงสร้างคลาส Car ที่ยังไม่มีตัวแปรและเมธอดใดๆ" ] }, { "cell_type": "code", "execution_count": 35, "id": "b10b6dd8-d8a1-4b2c-9fcf-7167f9cbde99", "metadata": { "id": "o0YNMNxQPCfp", "tags": [] }, "outputs": [], "source": [ "# Write your code below. Don't forget to press Shift+Enter to execute the cell\n" ] }, { "cell_type": "markdown", "id": "6beae5aa-7344-4711-bfc6-16f437c64d8b", "metadata": { "tags": [] }, "source": [ "4 จงสร้าคลาส Car ที่มีแอตทริบิวต์ (Attributes (Variables)) ชื่อรถ name ความเร็วสูงสุด (km/H) max_speed และอัตราการสิ้นเปลืองเชื้อเพลิง (km/L) mileage" ] }, { "cell_type": "code", "execution_count": 38, "id": "30deb334-a3a2-4c79-8eed-ede38dfa6f3d", "metadata": { "id": "o0YNMNxQPCfp", "tags": [] }, "outputs": [], "source": [ "# Write your code below. Don't forget to press Shift+Enter to execute the cell\n", "class Car:\n", " def __init__(self, name, max_speed, mileage):\n", " ### BEGIN SOLUTION\n", "\n", " pass\n", "\n", " ### END SOLUTION\n", "\n", "# modelH1 = Car('Honda City', 240, 18)\n", "# print(modelH1.name, modelH1.max_speed, modelH1.mileage)\n" ] }, { "cell_type": "markdown", "id": "222baf4f-044f-4fb4-9438-c94fc8fd17aa", "metadata": {}, "source": [ "5 จากข้อก่อนหน้า จงเปลี่ยนแอตทริบิวต์ความเร็วสูงสุดให้เป็นเมธอดความเร็วสูงสุด `max_speed()` และเปลี่ยนแอตทริบิวต์อัตราการสิ้นเปลืองเชื้อเพลิงให้เป็นเมธอดอัตราการสิ้นเปลืองเชื้อเพลิง 'mileage' แทน และเพิ่มเมธอด `description()` ส่งค่ากลับเป็นข้อความ \"รถ _name_ วิ่งที่ความเร็วสูงสุด _max_speed_ km/H มีอัตราการสิ้นเปลืองเชื้อเพลิง _mileage_ km/L\" " ] }, { "cell_type": "code", "execution_count": 41, "id": "9a65789b-9194-4a0c-9a74-60ae746b73b0", "metadata": { "id": "o0YNMNxQPCfp", "tags": [] }, "outputs": [], "source": [ "# Write your code below. Don't forget to press Shift+Enter to execute the cell\n", "class Car:\n", " ### BEGIN SOLUTION\n", "\n", " pass\n", "\n", " ### END SOLUTION\n", "\n", " \n", "# obj2 = Car(\"Honda City\")\n", "# obj2.mileage(18)\n", "# obj2.max_speed(240)\n", "# print(obj2.name, obj2.max_speed, obj2.mileage)\n", "# print(obj2.description())" ] }, { "cell_type": "markdown", "id": "474febb8-f2ed-4106-841f-b7f1871987a8", "metadata": {}, "source": [ "---" ] }, { "cell_type": "markdown", "id": "f13a54bb-4df4-4a2a-8557-4fe68a79799f", "metadata": { "id": "77G0KQCTPCfv" }, "source": [ "## Author\n", "\n", "S.C.\n", "\n", "### Change Log\n", "\n", " \n", "| Date | Version | Change Description |\n", "|---|---|---|\n", "| 25-12-2021 | 0.1 | First edition |\n", "| | | |\n", "| | | |\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel(3.8.13))", "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.8.13" } }, "nbformat": 4, "nbformat_minor": 5 }