ในบรรดานักพัฒนา การเขียนโปรแกรมเชิงวัตถุดึงดูดผู้ติดตามจำนวนมาก ภาษาคอมพิวเตอร์ยอดนิยม Python ก็ยึดตามกระบวนทัศน์เชิงวัตถุเช่นกัน
มันเกี่ยวข้องกับการกำหนดวัตถุและคลาสใน Python ซึ่งเป็นพื้นฐานสำหรับหลักการ OOP ในบทช่วยสอนเกี่ยวกับ “การเขียนโปรแกรมเชิงวัตถุใน Python” นี้ คุณจะได้เรียนรู้วิธีประกาศคลาส Python, สร้างวัตถุจากพวกมัน และใช้เทคนิค OOP สี่เทคนิค
ดังนั้นสิ่งแรกก่อน
การเขียนโปรแกรมเชิงวัตถุคืออะไร?
จุดสนใจหลักของการเขียนโปรแกรมเชิงวัตถุ (OOP) คือการสร้าง "วัตถุ" ชุดของตัวแปรและฟังก์ชันที่เชื่อมต่อถึงกันประกอบเป็นอ็อบเจ็กต์
ตัวแปรเหล่านี้มักถูกเรียกว่าแอตทริบิวต์ของวัตถุ และพฤติกรรมมักเรียกว่าฟังก์ชัน รายการเหล่านี้ทำให้แอปพลิเคชันมีโครงสร้างที่มีประสิทธิภาพและเข้าใจได้มากขึ้น รถยนต์เป็นตัวอย่างของสิ่งของ
หากรถยนต์เป็นสิ่งของ คุณลักษณะของมันจะรวมถึงสิ่งต่าง ๆ เช่น สี รุ่น ราคา ยี่ห้อ ฯลฯ นอกจากนี้ มันจะเร่งความเร็ว ช้าลง และเปลี่ยนเกียร์
อีกตัวอย่างหนึ่ง: หากเราคิดว่าสุนัขเป็นสิ่งของ คุณลักษณะบางอย่างของสุนัขอาจเป็นสี สายพันธุ์ ชื่อ น้ำหนัก ฯลฯ และเขาจะเคลื่อนไหวไปมา เห่า เล่น ฯลฯ
เนื่องจากมันรวมเอาแนวคิดในโลกแห่งความเป็นจริง เช่น ออบเจ็กต์ การซ่อน การสืบทอด ฯลฯ เข้าไว้ในการเขียนโปรแกรม การเขียนโปรแกรมเชิงวัตถุจึงเป็นที่รู้จักกันดี เนื่องจากคล้ายกับสถานการณ์ในโลกแห่งความเป็นจริง การสร้างภาพข้อมูลจึงง่ายขึ้น
แนวคิดการเขียนโปรแกรมเชิงวัตถุ
คลาสและอ็อบเจ็กต์ใน Python
เช่นเดียวกับภาษาเชิงวัตถุอื่น ๆ Python ช่วยให้คุณสามารถออกแบบคลาสเพื่อสร้างวัตถุ ชนิดข้อมูลที่นิยมมากที่สุดใน Python รวมถึงสตริง รายการ พจนานุกรม และอ็อบเจ็กต์อื่นๆ เป็นคลาสที่มีอยู่แล้วภายใน
คลาสคือกลุ่มของเมธอดที่เชื่อมโยงและตัวแปรอินสแตนซ์ที่กำหนดวัตถุบางประเภท คลาสอาจถูกมองว่าเป็นโมเดลหรือเทมเพลตสำหรับออบเจกต์ ตัวแปรที่ประกอบเป็นคลาสเรียกว่าแอตทริบิวต์
อ็อบเจ็กต์เป็นสมาชิกของคลาสที่มีชุดของแอ็ตทริบิวต์ที่กำหนดไว้ ด้วยเหตุนี้ คุณสามารถสร้างวัตถุจำนวนเท่าใดก็ได้โดยใช้คลาสเดียวกัน
คลาส Python ถูกกำหนดโดยใช้คำว่า class ซึ่งตามด้วยชื่อคลาสและโคลอน ภาพประกอบของคลาสนกแก้วอาจเป็น:
ที่นี่เราประกาศคลาส Parrot ว่างโดยใช้คีย์เวิร์ดคลาส เราสร้างอินสแตนซ์จากคลาส อินสแตนซ์คืออ็อบเจ็กต์เฉพาะที่สร้างจากคลาสใดคลาสหนึ่ง 'pass' มักใช้เป็นรหัสแทนซึ่งเราอาจละทิ้งการใช้งานไปชั่วขณะ เราสามารถรันโค้ด Python ได้โดยไม่ทำให้เกิดข้อผิดพลาดโดยใช้คีย์เวิร์ด “pass”
การสร้างอินสแตนซ์ของคลาสส่งผลให้วัตถุ (ตัวอย่าง) เฉพาะคำอธิบายของวัตถุเท่านั้นที่กำหนดเมื่อสร้างคลาส เป็นผลให้ไม่มีการจัดสรรพื้นที่เก็บข้อมูลหรือ RAM
ตัวอย่างของวัตถุคลาสนกแก้วคือ:
Obj เป็นอ็อบเจ็กต์คลาส Parrot ในกรณีนี้
สมมติว่าเรารู้ข้อมูลเฉพาะเกี่ยวกับนกแก้ว ตอนนี้เราจะสาธิตวิธีสร้างคลาสนกแก้วและวัตถุ
วิธีการพิเศษ ( __init__ )
เมธอดที่เรียกว่า init กำหนดคุณลักษณะที่ทุกอ็อบเจ็กต์ Parrot ต้องมี () เมื่อมีการสร้างอ็อบเจ็กต์ Parrot ขึ้น ฟังก์ชัน __init__ จะสร้างสถานะเริ่มต้นของอ็อบเจ็กต์โดยกำหนดค่าที่เราจัดหาให้ภายในคุณสมบัติของอ็อบเจ็กต์
ดังนั้น แต่ละอินสแตนซ์ใหม่ของคลาสจะเริ่มต้นโดยใช้ __init__() แม้ว่า __init__() จะยอมรับพารามิเตอร์จำนวนเท่าใดก็ได้ แต่ self จะเป็นพารามิเตอร์แรกเสมอ
การอ้างอิงถึงอินสแตนซ์คลาสที่ใช้งานอยู่จะรวมอยู่ในอาร์กิวเมนต์ตนเอง พารามิเตอร์ตนเองซึ่งเชื่อมโยงไปยังที่อยู่ของวัตถุปัจจุบันของคลาสและทำให้เราสามารถเข้าถึงข้อมูลตัวแปร (ของวัตถุ) ได้หมายความว่า
1 ตัวอย่าง
เราสร้างคลาสที่เรียกว่า Parrot ในรหัสด้านบน ถัดไป คุณสมบัติจะถูกกำหนด คุณสมบัติของสิ่งของคือคุณสมบัติของมัน ฟังก์ชัน __init__ ของคลาสคือตำแหน่งที่ระบุคุณลักษณะเหล่านี้
เมื่อมีการสร้างอ็อบเจ็กต์ วิธีการ initializer จะเรียกว่า initializer จากนั้น อินสแตนซ์ของคลาส Parrot จะถูกสร้างขึ้น Blaze และ Wonda ในตัวอย่างนี้เป็นข้อมูลอ้างอิง (ค่า) ไปยังวัตถุใหม่ของเรา __class .species ทำให้เราสามารถเข้าถึงแอตทริบิวต์ของคลาสได้
ทุกอินสแตนซ์ของคลาสมีลักษณะเหมือนกัน คุณสมบัติของอินสแตนซ์ยังสามารถเข้าถึงได้โดยใช้ blaze.name และ blaze.age อินสแตนซ์ทั้งหมดของคลาสมีแอตทริบิวต์ของอินสแตนซ์ที่ไม่ซ้ำกัน
2 ตัวอย่าง
วิธีการ
ฟังก์ชันที่กำหนดไว้ภายในเนื้อหาของคลาสเรียกว่าเมธอด ใช้เพื่อระบุว่ารายการจะมีพฤติกรรมอย่างไร
สองวิธีคือ sing() และ dance ถูกกำหนดไว้ในแอปพลิเคชั่นดังกล่าว () เนื่องจากถูกเรียกใช้บนวัตถุอินสแตนซ์ เช่น เปลวไฟ สิ่งเหล่านี้จึงถูกอ้างถึงเป็นวิธีการของอินสแตนซ์
พื้นฐานของแนวคิด OOPS
แนวคิดหลักสี่ประการของการเขียนโปรแกรมเชิงวัตถุคือ:
- มรดก
- encapsulation
- ความหลากหลาย
- สิ่งที่เป็นนามธรรม
มรดก
ผู้คนมักบอกเด็กแรกเกิดว่าพวกเขามีลักษณะใบหน้าที่คล้ายกับพ่อแม่ของพวกเขาหรือว่าพวกเขามีลักษณะเฉพาะที่สืบทอดมาจากพ่อแม่ของพวกเขา
เป็นไปได้ว่าคุณยังสังเกตเห็นว่าคุณมีลักษณะบางอย่างร่วมกับพ่อแม่ของคุณ สถานการณ์ในโลกแห่งความเป็นจริงค่อนข้างคล้ายกับมรดกเช่นกัน
อย่างไรก็ตาม ในกรณีนี้ คุณลักษณะ "คลาสหลัก" จะถูกส่งต่อไปยัง "คลาสย่อย" ลักษณะเหล่านี้เรียกว่า "คุณสมบัติ" และ "วิธีการ" ในบริบทนี้
คลาสสามารถรับเมธอดและคุณลักษณะจากคลาสอื่นโดยใช้เทคนิคที่เรียกว่าการสืบทอด การสืบทอดเป็นกระบวนการของคลาสลูกที่ได้รับคุณสมบัติของคลาสพาเรนต์
ตัวอย่าง:
คลาสหลัก Human สืบทอดโดยคลาสย่อย Boy ในตัวอย่างด้านบน เนื่องจาก Boy สืบทอดมาจาก Human เราจึงสามารถเข้าถึงวิธีการและคุณลักษณะทั้งหมดได้เมื่อเราสร้างอินสแตนซ์ของคลาส Boy
ในคลาส Boy มีการกำหนดวิธีการที่เรียกว่า schoolName ออบเจ็กต์คลาสหลักไม่สามารถเข้าถึงเมธอด schoolName อย่างไรก็ตาม สามารถเรียกเมธอด schoolName ได้โดยการสร้างอ็อบเจ็กต์คลาสลูก (Boy)
encapsulation
การให้ทุกตัวแปรในการเข้าถึงทั่วโลกของโปรแกรมไม่ใช่การเคลื่อนไหวที่ฉลาดเมื่อทำงานกับคลาสและการจัดการข้อมูลที่ละเอียดอ่อน
โดยไม่ให้โปรแกรมเข้าถึงตัวแปรเหล่านั้นได้อย่างสมบูรณ์ การห่อหุ้มให้กลไกสำหรับเราในการรับตัวแปรที่จำเป็น
เมธอดที่กำหนดไว้อย่างชัดแจ้งเพื่อวัตถุประสงค์สามารถใช้ในการอัปเดต แก้ไข หรือลบข้อมูลออกจากตัวแปรได้ วิธีการเขียนโปรแกรมนี้มีข้อดีของการรักษาความปลอดภัยที่เพิ่มขึ้นและการควบคุมการป้อนข้อมูล
ดูว่าสามารถเข้าถึงตัวแปรได้เร็วแค่ไหนในการสาธิตด้านล่าง:
ความหลากหลาย
สมมติว่าคุณกำลังใช้โทรศัพท์เพื่อเรียกดู ฟีด Instagram. เมื่อคุณรู้สึกอยากฟังเพลง คุณเข้าถึง Spotify และเริ่มเล่นเพลงโปรดของคุณ
ผ่านไประยะหนึ่ง คุณได้รับสาย คุณจึงหยุดสิ่งที่คุณกำลังทำในพื้นหลังไว้ชั่วคราวเพื่อรับสาย เพื่อนของคุณโทรมาและขอให้คุณส่งข้อความถึงหมายเลขโทรศัพท์ของใครบางคน
ดังนั้นคุณจึงส่งหมายเลขโทรศัพท์ให้เขาทาง SMS และทำงานของคุณต่อไป คุณหยิบอะไรขึ้นมา? ด้วยอุปกรณ์เพียงเครื่องเดียว—โทรศัพท์มือถือของคุณ—คุณสามารถท่องผ่านฟีด ฟังเพลง รับสายและโทรออก และส่งข้อความ
ดังนั้นความหลากหลายจึงเปรียบได้กับสิ่งนั้น Poly หมายถึงจำนวนมากและ morph หมายถึงรูปแบบที่แตกต่างกัน ดังนั้นความหลากหลายโดยรวมจึงหมายถึงบางสิ่งที่มีรูปแบบที่หลากหลาย
หรือ “บางสิ่ง” ที่สามารถแสดงพฤติกรรมได้หลากหลายขึ้นอยู่กับสถานการณ์ ใน OOPS ความหลากหลายจะอธิบายฟังก์ชันที่มีชื่อเหมือนกันแต่มีพฤติกรรมที่แตกต่างกัน อีกวิธีหนึ่งคือ ลายเซ็นฟังก์ชันอื่นที่มีชื่อฟังก์ชันเดียวกัน (พารามิเตอร์ส่งผ่านไปยังฟังก์ชัน)
ตัวอย่าง:
ในที่นี้ เราสามารถใช้ตัวแปร Animal เพื่อวนซ้ำวัตถุของ Zebra และ Rabbit โดยใช้วิธีการอินสแตนซ์ตามลำดับ ด้วยเหตุนี้ พฤติกรรม (color() & eats()) ของทั้งม้าลายและกระต่ายจึงถูกแสดงด้วยตัวแปรเดียวที่เรียกว่าสัตว์ จึงเป็นการปฏิบัติตามกฎพหุสัณฐาน
สิ่งที่เป็นนามธรรม
คุณมักจะใช้แล็ปท็อป โทรศัพท์ หรือแท็บเล็ตเพื่ออ่านเนื้อหานี้ ขณะอ่าน คุณอาจกำลังจดบันทึก ขีดเส้นใต้ข้อความสำคัญ และอาจจัดเก็บข้อมูลบางอย่างในไฟล์ส่วนตัวของคุณ
สิ่งที่คุณสามารถมองเห็นได้เมื่ออ่านข้อความนี้คือ "หน้าจอ" ที่มีข้อมูลที่แสดงให้คุณเห็น คุณเพียงแค่เห็นแป้นของแป้นพิมพ์ขณะที่คุณพิมพ์ คุณจึงไม่ต้องกังวลกับรายละเอียดปลีกย่อยภายใน เช่น การกดแป้นจะทำให้คำนั้นปรากฏบนหน้าจอได้อย่างไร
อีกวิธีหนึ่งคือ การกดปุ่มบนหน้าจอของคุณสามารถเปิดแท็บใหม่ได้อย่างไร
ดังนั้น อะไรก็ตามที่เราสังเกตได้ในสถานการณ์นี้เป็นนามธรรม เราสามารถเห็นผลลัพธ์ที่มันสร้างขึ้นเท่านั้น ไม่ใช่ความซับซ้อนภายใน (ซึ่งจริงๆ แล้วสำคัญสำหรับเรา)
ในทำนองเดียวกัน นามธรรมจะเปิดเผยเฉพาะฟังก์ชันที่ทุกอย่างมีอยู่ในขณะที่ปกปิดการใช้งานหรือรายละเอียดภายใน
วัตถุประสงค์หลักของ Abstraction คือการปกปิดข้อมูลเบื้องหลังและการนำข้อมูลที่ไม่เกี่ยวข้องไปใช้ เพื่อให้ผู้คนเห็นเฉพาะสิ่งที่พวกเขาต้องการเห็นเท่านั้น ช่วยในการจัดการความซับซ้อนของรหัส
ตัวอย่าง:
มีคลาสนามธรรมเกี่ยวกับรถยนต์อยู่ที่นี่ เพราะมันสืบทอดมาจากคลาสนามธรรม ABC จึงเป็นนามธรรม เนื่องจากวิธีการที่เป็นนามธรรมไม่ได้กำหนดไว้หรือว่างไว้ คลาส Vehicle มีวิธีการที่เป็นนามธรรมที่เรียกว่า no of wheel ที่ไม่มีคำจำกัดความ
พวกเขาคาดหวังคลาสที่สืบทอดคลาสนามธรรมเพื่อให้การดำเนินการของเมธอด
ประโยชน์ของแนวคิด OOPS
- การห่อหุ้มจะทำให้มีความปลอดภัยสูงและความเป็นส่วนตัวของข้อมูล
- ความยืดหยุ่นในการมี polymorphic รุ่นเดียวกันหลายรุ่น
- ความซับซ้อนของโค้ดระดับสูงลดลงตามนามธรรม
- แทนที่จะกรองโค้ดหลายร้อยบรรทัดเพื่อค้นหาปัญหาเดียว โมดูลาร์ของการเขียนโปรแกรมทำให้การดีบักทำได้ง่าย
- การใช้รหัสซ้ำเกิดจากการสืบทอดคุณสมบัติของคลาสพาเรนต์ของคลาสลูก
- การแก้ปัญหาอย่างมีประสิทธิภาพเป็นไปได้เพราะเราสร้างคลาสที่ดำเนินการที่จำเป็นสำหรับปัญหาย่อยแต่ละข้อ ปัญหาต่อไปนี้สามารถแก้ไขได้อย่างรวดเร็วยิ่งขึ้นเนื่องจากเราสามารถนำคลาสเหล่านั้นกลับมาใช้ใหม่ได้
สรุป
โดยสรุป เราได้เรียนรู้เกี่ยวกับแนวคิด OOPS ใน Python ซึ่งเป็นกระบวนทัศน์การเขียนโปรแกรมที่ร้อนแรงที่สุดในขณะนี้
หลังจากอ่านสิ่งนี้ คุณต้องตระหนักว่ากระบวนทัศน์ OOPS เกี่ยวข้องกับแนวคิดของคลาสและวัตถุทั้งหมด และแนวคิด OOPS เช่น การห่อหุ้ม ความหลากหลาย การสืบทอด และนามธรรม
เขียนความเห็น