การซ่อนข้อมูลใน 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 มีการใช้ตัวระบุการเข้าถึงที่แตกต่างกันเพื่อใช้งานสิ่งนี้