การซ่อนข้อมูลใน Python: ข้อดีและข้อเสียคืออะไร [พร้อมตัวอย่างการเข้ารหัส]
เผยแพร่แล้ว: 2021-02-05สารบัญ
การซ่อนข้อมูลคืออะไร?
เป็นวิธีการที่ใช้ในการเขียนโปรแกรมเชิงวัตถุ (OOP) เพื่อซ่อนโดยมีเจตนาที่จะซ่อนข้อมูล/ข้อมูลภายในรหัสคอมพิวเตอร์ รายละเอียดอ็อบเจ็กต์ภายใน เช่น สมาชิกข้อมูล ถูกซ่อนอยู่ภายในคลาส รับประกันการเข้าถึงข้อมูลอย่าง จำกัด ให้กับสมาชิกคลาสในขณะที่ยังคงความสมบูรณ์ของวัตถุ การซ่อนข้อมูลรวมถึงกระบวนการของการรวมข้อมูลและฟังก์ชันเข้าเป็นหน่วยเดียวเพื่อปกปิดข้อมูลภายในชั้นเรียนโดยจำกัดการเข้าถึงข้อมูลจากภายนอกชั้นเรียนโดยตรง หากคุณเป็นผู้เริ่มต้นในสาขาวิทยาศาสตร์ข้อมูลและต้องการเพิ่มพูนความเชี่ยวชาญ โปรดดูหลักสูตรวิทยาศาสตร์ข้อมูลของเราจากมหาวิทยาลัยชั้นนำ
การซ่อนข้อมูลช่วยให้โปรแกรมเมอร์คอมพิวเตอร์สร้างคลาสด้วยชุดข้อมูลและฟังก์ชันเฉพาะ โดยหลีกเลี่ยงการเข้าที่ไม่จำเป็นจากคลาสอื่นในโปรแกรม การเป็นเทคนิคการพัฒนาซอฟต์แวร์ใน OOP ทำให้มั่นใจได้ว่ามีการเข้าถึงข้อมูลแบบเอกสิทธิ์เฉพาะบุคคล และป้องกันการเปลี่ยนแปลงข้อมูลโดยเจตนาหรือไม่ได้ตั้งใจ การพึ่งพาซึ่งกันและกันอย่างจำกัดในส่วนประกอบซอฟต์แวร์ช่วยลดความซับซ้อนของระบบและเพิ่มประสิทธิภาพของโปรแกรม
การซ่อนข้อมูลเรียกอีกอย่างว่าการซ่อนข้อมูลหรือการห่อหุ้มข้อมูล การห่อหุ้มข้อมูลทำขึ้นเพื่อซ่อนรายละเอียดการใช้งานแอปพลิเคชันจากผู้ใช้ เนื่องจากจุดประสงค์ที่อยู่เบื้องหลังทั้งสองอย่างเหมือนกัน การห่อหุ้มจึงเรียกอีกอย่างว่าการซ่อนข้อมูล เมื่อสมาชิกข้อมูลถูกกล่าวถึงว่าเป็นส่วนตัวในชั้นเรียน จะเข้าถึงได้เฉพาะในชั้นเรียนเดียวกันและไม่สามารถเข้าถึงได้นอกชั้นเรียนนั้น
การซ่อนข้อมูลใน Python
Python กำลังกลายเป็นภาษาโปรแกรมยอดนิยมที่ใช้ได้กับทุกภาคส่วนและมีเครื่องมือและไลบรารีการใช้งานโปรแกรมที่ใช้งานง่าย เอกสาร Python กำหนด Data Hiding เป็นการแยกไคลเอนต์จากส่วนหนึ่งของการใช้งานโปรแกรม บางอ็อบเจ็กต์ในโมดูลจะถูกเก็บไว้ภายใน มองไม่เห็น และไม่สามารถเข้าถึงได้สำหรับผู้ใช้
โมดูลในโปรแกรมเปิดเพียงพอที่จะเข้าใจวิธีใช้แอปพลิเคชัน แต่ผู้ใช้ไม่รู้ว่าแอปพลิเคชันทำงานอย่างไร ดังนั้นการซ่อนข้อมูลจึงให้การรักษาความปลอดภัยพร้อมกับหลีกเลี่ยงการพึ่งพา การซ่อนข้อมูลใน Python เป็นวิธีการป้องกันการเข้าถึงผู้ใช้เฉพาะในแอปพลิเคชัน
การซ่อนข้อมูลใน Python ทำได้โดยใช้เครื่องหมายขีดล่างคู่ก่อน (คำนำหน้า) ชื่อแอตทริบิวต์ สิ่งนี้ทำให้แอตทริบิวต์เป็นส่วนตัว/ ไม่สามารถเข้าถึงได้และซ่อนจากผู้ใช้ Python ไม่มีอะไรเป็นความลับในความหมายที่แท้จริง อย่างไรก็ตาม ชื่อของเมธอดและคุณลักษณะส่วนตัวนั้นถูกจัดการภายในและแยกไม่ออกในทันที ทำให้ไม่สามารถเข้าถึงได้ด้วยชื่อที่ระบุ
ตัวอย่างการซ่อนข้อมูลใน Python
#!/usr/bin/python
คลาส JustCounter :
__secretCount = 0
def นับ ( ตัวเอง ):
ตัวเอง . __secretCount += 1
พิมพ์ เอง . __secretCount
ตัว นับ = JustCounter ()
เคาน์เตอร์ . นับ ()
เคาน์เตอร์ . นับ ()
เคาน์เตอร์ พิมพ์ _ __secretCount
เอาท์พุต
1
2
Traceback (การโทรล่าสุดล่าสุด):
ไฟล์ “test.py” บรรทัดที่ 12 ใน <module>
เคาน์เตอร์พิมพ์.__secretCount
AttributeError: อินสแตนซ์ JustCounter ไม่มีแอตทริบิวต์ '__secretCount'
Python ภายในเปลี่ยนชื่อของสมาชิกในคลาสที่เข้าถึงโดย object._className__attrName
หากบรรทัดสุดท้ายเปลี่ยนเป็น:
………………..
เคาน์เตอร์พิมพ์._JustCounter__secretCount
จากนั้นใช้งานได้และผลลัพธ์คือ:
1
2
2

ข้อดีของการซ่อนข้อมูล
- ออบเจ็กต์ภายในคลาสถูกตัดการเชื่อมต่อจากข้อมูลที่ไม่เกี่ยวข้อง
- มันเพิ่มความปลอดภัยให้กับแฮกเกอร์ที่ไม่สามารถเข้าถึงข้อมูลที่เป็นความลับ
- ป้องกันไม่ให้โปรแกรมเมอร์เชื่อมโยงข้อมูลที่ไม่ถูกต้องโดยไม่ได้ตั้งใจ หากโปรแกรมเมอร์เชื่อมโยงข้อมูลนี้ในโค้ด จะแสดงเฉพาะข้อผิดพลาดโดยระบุการแก้ไขในข้อผิดพลาด
- แยกวัตถุออกเป็นแนวคิดพื้นฐานของ OOP
- ช่วยป้องกันความเสียหายต่อข้อมูลที่ระเหยได้โดยการซ่อนไม่ให้เปิดเผยต่อ สาธารณะ
ข้อเสียของการซ่อนข้อมูล
- บางครั้งอาจบังคับให้โปรแกรมเมอร์ใช้การเข้ารหัสพิเศษ
- การเชื่อมโยงระหว่างข้อมูลที่มองเห็นได้และมองไม่เห็นทำให้วัตถุทำงานเร็วขึ้น แต่การซ่อนข้อมูลจะป้องกันการเชื่อมโยงนี้
- การซ่อนข้อมูลอาจทำให้โปรแกรมเมอร์ยากขึ้นและจำเป็นต้องเขียนโค้ดยาวๆ เพื่อสร้างเอฟเฟกต์ในข้อมูลที่ซ่อนอยู่
ดังนั้น การซ่อนข้อมูลจึงมีประโยชน์ใน Python เมื่อพูดถึงความเป็นส่วนตัวและความปลอดภัยของข้อมูลเฉพาะภายในแอปพลิเคชัน มันเพิ่มงานสำหรับโปรแกรมเมอร์ในขณะที่เชื่อมโยงข้อมูลที่ซ่อนอยู่ในรหัส แต่ข้อดีที่มีให้นั้นหลีกเลี่ยงไม่ได้อย่างแท้จริง
อ่านเพิ่มเติม: คำถามและคำตอบสัมภาษณ์ Python
บทสรุป
ในการเข้าร่วมหลักสูตรออนไลน์ Python ของเราฟรี คุณต้องทำตามขั้นตอนเหล่านี้:
- ไปที่หน้าเริ่มต้นของเรา
- เลือกหลักสูตร "Python for Data Science"
- คลิกลงทะเบียน
- เสร็จสิ้นขั้นตอนการลงทะเบียน
แค่นั้นแหละ. คุณสามารถเรียนรู้ Python ออนไลน์ได้ฟรีผ่านโปรแกรม upStart ที่เพิ่งเปิดตัวใหม่และเริ่มต้นเส้นทางวิทยาศาสตร์ข้อมูลของคุณ คุณต้องลงทุนเพียง 30 นาทีต่อวันเป็นเวลาสองสามสัปดาห์ โปรแกรมนี้ไม่ต้องใช้เงินลงทุน
ลงทะเบียนวันนี้และเริ่มต้น
หากคุณมีคำถามหรือข้อเสนอแนะเกี่ยวกับหัวข้อนี้ โปรดแจ้งให้เราทราบในความคิดเห็นด้านล่าง เราชอบที่จะได้ยินจากคุณ
หากคุณอยากเรียนรู้เกี่ยวกับวิทยาศาสตร์ข้อมูล ลองดูโปรแกรม Executive PG ของ IIIT-B & upGrad ใน Data Science ซึ่งสร้างขึ้นสำหรับมืออาชีพที่ทำงานและมีกรณีศึกษาและโครงการมากกว่า 10 รายการ เวิร์กช็อปภาคปฏิบัติจริง การให้คำปรึกษากับผู้เชี่ยวชาญในอุตสาหกรรม 1 -on-1 พร้อมที่ปรึกษาในอุตสาหกรรม การเรียนรู้มากกว่า 400 ชั่วโมงและความช่วยเหลือด้านงานกับบริษัทชั้นนำ
ข้อมูลที่ซ่อนอยู่ใน Python คืออะไร?
การซ่อนข้อมูลเป็นหนึ่งในแนวคิดหลักของการเขียนโปรแกรมเชิงวัตถุ ซึ่งจำกัดการเข้าถึงข้อมูลจากโลกภายนอก รายละเอียดต่างๆ เช่น สมาชิกของข้อมูลจะถูกซ่อนไว้โดยใช้ตัวระบุการเข้าถึงแบบ "ส่วนตัว" พิจารณาตัวอย่างต่อไปนี้เพื่อความเข้าใจที่ดีขึ้น
สมมติว่าเรามีคลาสชื่อ myClass และสมาชิกส่วนตัวชื่อ __privateCounter ภายในคลาสนี้ เรามีฟังก์ชันที่เรียกว่า myFunc ซึ่งเพิ่มค่าของ __privateCounter ขึ้น 1 และพิมพ์ออกมา นอกคลาส เราได้สร้างอ็อบเจ็กต์ของคลาสและเรียก myFunc โดยใช้อ็อบเจกต์นี้ ตอนนี้ ถ้าเราพยายามพิมพ์ __privateCounter โดยใช้วัตถุนี้ มันจะเกิดข้อผิดพลาด
ในตัวอย่างข้างต้น “__privateCounter” เป็นสมาชิกส่วนตัวของคลาส “myClass” ตามค่าเริ่มต้น เนื่องจากเราได้ทำการซ่อนข้อมูลไว้ จึงไม่สามารถเข้าถึงได้จากภายนอกคลาสที่ประกาศไว้ ในการเข้าถึงสมาชิกส่วนตัว เราต้องกำหนดฟังก์ชันสมาชิก ซึ่งในกรณีนี้คือ “myFunc”
การปกปิดข้อมูลมีข้อดีและข้อเสียอย่างไร?
แม้ว่าการซ่อนข้อมูลจะเป็นแนวคิดหลักของ OOP และมีข้อดีหลายประการ แต่ก็มีข้อเสียอยู่บ้างเช่นกัน ต่อไปนี้เป็นข้อดีและข้อเสียที่สำคัญที่สุดบางประการของการซ่อนข้อมูลใน Python:
ข้อดี
1. ช่วยป้องกันการใช้ในทางที่ผิดและการจัดการข้อมูลที่มีความผันผวนโดยการประกาศให้เป็นข้อมูลส่วนตัว
2. สมาชิกของข้อมูลในชั้นเรียนจะถูกลบออกจากข้อมูลที่ไม่เกี่ยวข้อง
3. แยกวัตถุออกเป็นแนวคิดพื้นฐานของ OOP
ข้อเสีย
1. โปรแกรมเมอร์มักถูกบังคับให้เขียนโค้ดยาวๆ เพื่อปกป้องข้อมูลที่ระเหยจากลูกค้า
2. ออบเจ็กต์ทำงานค่อนข้างช้ากว่าเนื่องจากความเชื่อมโยงระหว่างข้อมูลที่มองเห็นได้และข้อมูลที่มองไม่เห็นทำให้ทำงานได้อย่างรวดเร็ว และการซ่อนข้อมูลป้องกันการเชื่อมโยงนี้
การซ่อนข้อมูลแตกต่างจากการแยกข้อมูลอย่างไร
การซ่อนข้อมูลสนับสนุนแนวคิดในการจำกัดข้อมูลเพื่อไม่ให้บุคคลภายนอกเข้าถึงหรือแก้ไขได้ ตัวอย่างเช่น รายละเอียดเงินเดือนของพนักงานถูกซ่อนจากพนักงานคนอื่น ใน Python ทำได้โดยใช้ “ตัวแก้ไขการเข้าถึงส่วนตัว”
การแยกข้อมูลหมายถึงแนวคิดในการปกปิดการนำไปปฏิบัติภายในและแสดงเฉพาะคุณลักษณะต่อโลกภายนอกเท่านั้น ตัวอย่างเช่น ในเครื่องคิดเลข คุณจะเห็นเฉพาะการดำเนินการที่ดำเนินการโดยเครื่องคิดเลขเท่านั้น อย่างไรก็ตาม คุณจะไม่เห็นการทำงานภายในของการดำเนินการเหล่านี้ ใน Python มีการใช้ตัวระบุการเข้าถึงที่แตกต่างกันเพื่อใช้งานสิ่งนี้