คู่มือฉบับสมบูรณ์เกี่ยวกับแนวคิด OOPs ใน Python
เผยแพร่แล้ว: 2020-10-22การเขียนโปรแกรมเชิงวัตถุหรือ OOP เป็นส่วนสำคัญของโลกซอฟต์แวร์มาระยะหนึ่งแล้ว เป็นกระบวนทัศน์การเขียนโปรแกรมที่ยอดเยี่ยมที่มีระดับความเป็นอิสระและช่วยเพิ่มความสำเร็จในการเขียนโปรแกรมสำหรับนักพัฒนา
มีแนวคิดและหลักการพื้นฐานบางประการที่นักพัฒนาทุกคนควรรู้ พวกเขาขับเคลื่อนสมมติฐานในการพัฒนาแอปพลิเคชันโดยใช้โมเดลนี้
ในที่นี้ เราจะมาดูแนวคิด OOP ที่สำคัญแต่เป็นพื้นฐาน ใน Python แนวคิดเหล่านี้ขับเคลื่อนโปรแกรมเมอร์ให้บรรลุผลลัพธ์ที่ดีขึ้น ตลอดจนสร้างแบบจำลองแอปของตนในรูปแบบที่สมบูรณ์ยิ่งขึ้น
สารบัญ
การเขียนโปรแกรมเชิงวัตถุคืออะไร?
สำหรับผู้ที่ไม่ได้ฝึกหัด นี่คือที่ที่เราจะเริ่มต้นการปฐมนิเทศของเรา มาทำความเข้าใจ OOP แบบคนธรรมดาเพื่อทำความเข้าใจอย่างลึกซึ้งว่าเราจะดำเนินการอย่างไร
ในโครงสร้างการเขียนโปรแกรมนี้ คุณสามารถรวมสิ่งต่าง ๆ ที่มีคุณสมบัติหรือลักษณะการทำงานที่คล้ายคลึงกันเป็นอ็อบเจ็กต์เดียวได้อย่างง่ายดาย หากคุณกำลังพูดถึงข้อมูลประชากร นั่นจะกลายเป็นอ็อบเจ็กต์เดียวสำหรับโมเดลการเขียนโปรแกรมนี้ ในทำนองเดียวกัน หากคุณกำลังพูดถึงการกระทำที่ต้องทำ สิ่งนั้นจะกลายเป็นอีกเรื่องหนึ่ง
เป็นวัตถุทั้งหมดที่มีข้อมูลดิบ โซลูชันซอฟต์แวร์ของคุณจะตั้งโปรแกรมวัตถุเหล่านี้ในลักษณะที่บรรลุเป้าหมายร่วมกัน ออบเจ็กต์เหล่านี้จะดำเนินการบางอย่างร่วมกันตามที่คุณตั้งโปรแกรมไว้ และส่งมอบผลลัพธ์
ตัวอย่างที่ดีที่จะช่วยให้เข้าใจถึงสิ่งนี้คือโปรแกรมอีเมล
สมมติว่าคุณมีหนึ่งออบเจ็กต์ที่มีเนื้อหาอีเมล เช่น ชื่อผู้รับและหัวเรื่อง มีวัตถุที่สองที่ให้รายละเอียดไฟล์แนบและส่งอีเมล คุณจะออกแบบโปรแกรมที่จะรวมออบเจ็กต์เหล่านี้โดยอัตโนมัติ ตรวจสอบให้แน่ใจว่าอีเมลที่เขียนครบถ้วนพร้อมไฟล์แนบที่ต้องการ และส่งไปยังผู้รับ
นี่คือวิธีการทำงานของ OOP อย่างไรก็ตาม แนวคิดบางอย่างขับเคลื่อนสิ่งนี้ไปสู่การปฏิบัติ มาดูแนวคิดเหล่านี้และวิธีใช้งานกัน
อ่าน: Python เป็นภาษาเชิงวัตถุหรือไม่
จะกำหนดคลาสได้อย่างไร?
คลาสคือสิ่งที่กำหนดทุกอ็อบเจกต์ และเป็นส่วนสำคัญของ แนวคิด OOPs ใน Python สมมติว่าคุณมีสิ่งของสี่อย่าง เช่น ตา หู ปาก และจมูก เหล่านี้เป็นส่วนหนึ่งของใบหน้าซึ่งเป็นชั้นเรียน
มาเริ่มกันด้วยวิธีการกำหนดคลาสกัน
สมมติว่าคุณกำลังพูดถึงชั้นเรียนที่เรียกว่าอีเมล
อีเมลของชั้นเรียน:
ผ่าน
นี่คือวิธีการกำหนดคลาส ใช้ “pass” เพื่อที่ว่าเมื่อคุณรันโค้ดในคอมไพเลอร์ จะไม่มีบั๊กออกมา
การกำหนดคลาสเท่านั้นอาจไม่ช่วยคุณได้มาก คุณต้องเพิ่มคุณสมบัติบางอย่างเพื่อทำให้น่าสนใจและโค้ดมีประโยชน์ ดังนั้น คุณต้องเพิ่มวัตถุในชั้นเรียนของคุณ
เมธอด ._init_() คือสิ่งที่จะพิสูจน์ได้ว่ามีประโยชน์เมื่อกำหนดคุณสมบัติภายในคลาส
เพื่อให้แน่ใจว่าทุกครั้งที่คุณสร้างวัตถุใหม่สำหรับคลาส เมธอดนี้จะตั้งค่าพารามิเตอร์เป็นสถานะเริ่มต้น ดังนั้น การเริ่มต้นวัตถุใหม่ทุกครั้ง
พารามิเตอร์แรกสำหรับวิธีนี้จะเป็นตัวเองเสมอ แม้ว่าคุณจะกำหนดพารามิเตอร์หลายตัวให้กับมันก็ตาม
แล้วจะเกิดอะไรขึ้นในกรณีนี้? สมมติว่าคุณสร้างชั้นเรียนใหม่ อินสแตนซ์ถูกโอนไปยังพารามิเตอร์ตนเอง เป็นผลให้ ._init_() สามารถกำหนดคุณสมบัติใหม่ให้กับวัตถุที่กำหนดได้
หากคุณยังคงไตร่ตรองถึงวิธีการใช้งาน มาทำความเข้าใจผ่านตัวอย่างกัน
อีเมลของชั้นเรียน:
def ._init_(ตัวเอง, ชื่อ, ผู้รับ, ที่อยู่):
self.name = ชื่อ
self.recipient = ผู้รับ
self.address = ที่อยู่
มาทำลายรหัสนี้เพื่อความเข้าใจที่ดีขึ้น
การเยื้องที่แสดงในโค้ดด้านบนเป็นสิ่งสำคัญ คุณควรจับคู่สิ่งเดียวกันเมื่อเขียนโปรแกรมของคุณโดยใช้ OOPs ใน Python มาทำความเข้าใจตัวแปรตนเองในโค้ดด้านบนกัน
self.name สร้างแอตทริบิวต์ที่เรียกว่าชื่อ ค่าของพารามิเตอร์ name ถูกกำหนดให้กับแอตทริบิวต์นี้ ในทำนองเดียวกัน คุณลักษณะและค่าต่างๆ ถูกกำหนดให้กับตัวแปรอื่นๆ ด้วย
คุณลักษณะเหล่านี้เรียกว่าอินสแตนซ์ คุณจะต้องระบุค่าของทุกแอตทริบิวต์ที่กล่าวถึงภายในอินสแตนซ์เฉพาะ สมมติว่ามีอีเมลสองประเภท – ยินดีต้อนรับและดูแล ผู้รับอีเมลจะแตกต่างกันสำหรับทั้งสองกรณี (อีเมลต้อนรับและดูแลอีเมล)
ในทางกลับกัน คุณลักษณะของคลาสนั้นแตกต่างกัน พวกเขาจะมีค่าเดียวกันสำหรับอินสแตนซ์ของคลาสทั้งหมด ตัวอย่างเช่น อีเมลเหล่านี้เป็นอีเมลขาเข้าทั้งหมด นี่คือแอตทริบิวต์คลาสที่คุณสามารถกำหนดได้
อีเมลของชั้นเรียน:
#คุณสมบัติของคลาส
อีเมล: "อีเมลขาเข้า"

def ._init_(ตัวเอง, ชื่อ, ผู้รับ, ที่อยู่):
self.name = ชื่อ
self.recipient = ผู้รับ
self.address = ที่อยู่
เรียนรู้เกี่ยวกับ: วิธีเขียนโค้ด คอมไพล์ และรัน Java Projects
การทำความเข้าใจตัวแปรคลาสและอินสแตนซ์
มาดูตัวอย่างข้างต้นที่เราได้สร้างแอตทริบิวต์คลาสรวมถึงตัวแปรอินสแตนซ์สองตัวเพื่อทำความเข้าใจ OOP ใน Python ให้ดีขึ้น
อีเมลของชั้นเรียน:
อีเมล: "อีเมลขาเข้า"
def ._init_(ตัวเอง, ชื่อ, ผู้รับ, ที่อยู่):
self.name = ชื่อ
self.recipient = ผู้รับ
self.address = ที่อยู่
มาพูดถึงการสร้างอินสแตนซ์ของวัตถุภายในคลาสนี้ คุณต้องตั้งค่าสำหรับแต่ละวัตถุเหล่านี้ นี่จะเป็นค่าเริ่มต้นสำหรับทุกอ็อบเจ็กต์ ตามที่กล่าวไว้ในส่วนก่อนหน้าของคู่มือนี้ ในกรณีที่คุณไม่กำหนดค่าให้กับวัตถุเหล่านี้ คุณจะได้รับ TypeError
>>> อีเมล์ ()
Traceback (การโทรล่าสุดล่าสุด):
ไฟล์ “<pyshell#6>” บรรทัดที่ 1 ใน <module>
อีเมล ()
TypeError: __init__() ไม่มีอาร์กิวเมนต์ตำแหน่ง 4 รายการ: 'name', 'recipient' และ 'address'
เราสามารถเพิ่มมูลค่าได้ทันทีหลังชื่อชั้น
Nurture Email = อีเมล (Nurture, David, [email protected])
อีเมลต้อนรับ = อีเมล (ยินดีต้อนรับ, เดซี่, [email protected])
ด้วยรหัสข้างต้น เราได้สร้างสองอินสแตนซ์สำหรับอีเมลดูแลและอีเมลต้อนรับ ลองตรวจสอบ __init__() ที่กำหนดไว้หลังอินสแตนซ์ของคลาสสำหรับโค้ดข้างต้น เราเห็นพารามิเตอร์สี่ประการรวมถึงตัวเองด้วย อย่างไรก็ตาม ไม่มีการกล่าวถึงตัวแปรสำหรับตนเอง มาทำความเข้าใจว่าทำไม?
ดังนั้น เมื่อใดก็ตามที่คุณสร้างวัตถุใหม่ภายในชั้นเรียน แสดงว่าคุณกำลังสร้างอินสแตนซ์ของชั้นเรียน คุณจะกำหนดที่อยู่หน่วยความจำในขณะที่ทำสิ่งนี้ ซึ่งตัวแปรจะถูกเก็บไว้ ทันทีที่คุณสร้างอินสแตนซ์ของวัตถุใหม่ Python จะสร้างอินสแตนซ์โดยอัตโนมัติ และจะถูกส่งต่อไปยังตัวแปรตัวแรกในเมธอด .__init__() ส่งผลให้ตนเองถูกเอาออกด้วยวิธีนี้
ด้วยตัวแปรคลาส คุณสามารถมั่นใจได้ว่าทุกอินสแตนซ์ที่คุณสร้างมีตัวแปรหรือค่าที่เกี่ยวข้อง วิธีนี้จะช่วยให้มั่นใจได้ถึงผลลัพธ์ที่รวดเร็วและง่ายขึ้น และทำให้ได้ข้อสรุปที่ปลอดภัยยิ่งขึ้นสำหรับการเขียนโปรแกรมของคุณ
ยังอ่าน: ต้องอ่าน 47 OOPS คำถามและคำตอบสัมภาษณ์สำหรับ Freshers & ผู้มีประสบการณ์
สรุป
เราเข้าใจแง่มุมต่างๆ ของการสร้างคลาส วัตถุ และเมธอดโดยใช้โมเดลการเขียนโปรแกรม Python OOPs ที่นี่ นอกเหนือจากนี้ เรายังเข้าใจแนวคิดต่างๆ เช่น อินสแตนซ์และการสร้างอินสแตนซ์ ซึ่งเป็นส่วนสำคัญของการเขียนโปรแกรม OOP ใน Python ต่อไป คุณจะต้องเข้าใจหลักการที่ควบคุมอินสแตนซ์และคลาสเหล่านี้ เช่น การสืบทอด ความหลากหลาย นามธรรม และการห่อหุ้ม เป็นแนวคิด OOP หลัก ใน Python ที่ขับเคลื่อนแอปพลิเคชันของคุณและผลลัพธ์
ในการก้าวต่อไปใน Python funnel คุณต้องมีพื้นฐานที่ชัดเจนและรูท ดังนั้น ดำดิ่งลงไปในชั้นเรียนและทำความเข้าใจวิธีการทำงาน ลองใช้ตัวแปรเหล่านี้สักหน่อย และทำความเข้าใจผลลัพธ์ก่อนที่คุณจะสามารถตั้งค่าแอปพลิเคชันของคุณได้
หากคุณอยากรู้เกี่ยวกับการเรียนรู้วิทยาศาสตร์ข้อมูลเพื่อก้าวไปสู่ความก้าวหน้าทางเทคโนโลยีอย่างรวดเร็ว ให้ลองดูประกาศนียบัตร PG ด้านวิทยาศาสตร์ข้อมูลของ Grad & IIIT-B และเพิ่มทักษะให้กับตัวเองเพื่ออนาคต
เหตุใดเราจึงใช้ OOP
Object-Oriented Programming (OOP) เป็นเฟรมเวิร์กการเขียนโปรแกรมที่อาศัยการพัฒนา 'อ็อบเจ็กต์' ที่นำกลับมาใช้ใหม่ได้ โดยมีคุณลักษณะและพฤติกรรมที่สามารถดำเนินการ จัดการ และจัดแพ็คเกจได้ Python รองรับทั้ง OOP และเฟรมเวิร์กอื่นๆ ใน Python คุณสามารถบรรลุ OOP โดยใช้คลาส Python มีคุณสมบัติตามปกติของการเขียนโปรแกรมเชิงวัตถุ นักพัฒนาใช้ OOP ในแอปพลิเคชัน Python เนื่องจากทำให้โค้ดใช้ซ้ำได้มากขึ้น และทำงานกับโปรแกรมขนาดใหญ่ได้ง่ายขึ้น เนื่องจากคลาสสามารถกำหนดได้เพียงครั้งเดียวและใช้งานได้หลายครั้ง ระบบ OOP จึงป้องกันไม่ให้คุณสร้างโค้ดซ้ำ ด้วยเหตุนี้ OOP ทำให้ง่ายต่อการปฏิบัติตามแนวคิด 'Don't Repeat Yourself' (DRY)
คลาสคืออะไร?
คลาส Python นั้นคล้ายกับพิมพ์เขียวสำหรับสร้างวัตถุใหม่ วัตถุคือสิ่งที่คุณต้องการแก้ไขหรือเปลี่ยนแปลงขณะเข้ารหัส เมื่อเราสร้างคลาสอ็อบเจ็กต์ ซึ่งเกิดขึ้นเมื่อเรากำหนดตัวแปร ออบเจ็กต์ใหม่จะถูกสร้างขึ้นตั้งแต่เริ่มต้น คลาสอ็อบเจ็กต์สามารถนำกลับมาใช้ใหม่ได้หลายครั้งตามต้องการ คลาสใช้ในการสร้างแต่ละรายการ พิจารณาว่านี่เป็นแบบแผนสำหรับรายการบางประเภท คลาสแสดงรายการแอตทริบิวต์ที่จำเป็นสำหรับวัตถุประเภทนั้น แต่ไม่ได้กำหนดค่าให้กับวัตถุเหล่านั้น คลาสยังระบุวิธีการที่ใช้ร่วมกันโดยอ็อบเจ็กต์ทั้งหมดที่เป็นประเภทเดียวกัน
ตัวแปรอินสแตนซ์คืออะไร?
อินสแตนซ์คลาสเป็นเจ้าของตัวแปรอินสแตนซ์ใน Python ค่าของตัวแปรอินสแตนซ์อาจเปลี่ยนแปลงตามอินสแตนซ์ที่มีการเชื่อมโยง ซึ่งแตกต่างจากตัวแปรคลาสซึ่งสามารถมีค่าได้เพียงค่าเดียวเท่านั้น ตัวแปรอินสแตนซ์ถูกประกาศในเมธอดของคลาส เมื่อเราประกาศคลาส เราอาจกำหนดค่าให้กับตัวแปรอินสแตนซ์ เมื่อเราประกาศคลาส เราให้ค่าที่เราต้องการกำหนดเป็นอาร์กิวเมนต์