ตนเองคืออะไรใน Python: ตัวอย่างในโลกแห่งความเป็นจริง

เมื่อเขียนคลาสใน Python คุณมักจะพบกับคำว่า'self.'It เป็นแนวคิดสำคัญที่ผู้เริ่มต้นต้องเข้าใจเมื่อเจาะลึกลงไปในคุณสมบัติเชิงวัตถุในภาษาโปรแกรม Python

พารามิเตอร์selfอ้างถึงอินสแตนซ์ปัจจุบันของคลาส คุณสามารถใช้เพื่อเข้าถึงแอตทริบิวต์และเมธอดที่เป็นของคลาสนั้น

ในบทช่วยสอน Python นี้ เราจะสำรวจว่าselfตัวแปรมีบทบาทสำคัญอย่างไรในคลาส Python selfนอกจากนี้ เราจะแสดงวิธีรักษาความ ชัดเจนของโค้ด ความเป็นโมดูลาร์ และการนำกลับมาใช้ใหม่ผ่านการใช้

สารบัญ

• ทำความเข้าใจตนเองใน Python
  • การเขียนโปรแกรมเชิงวัตถุใน Python
  • บทบาทของ Python Self
• การทำงานกับตนเอง
  • การเริ่มต้นวัตถุด้วย '__init__()'
  • การใช้ตนเองในวิธีการ
• กรณีการใช้งานด้วยตนเองทั่วไป
  • การเข้าถึงแอตทริบิวต์ของคลาส
  • วิธีการเรียกคลาส
• วิธีปฏิบัติตนที่ดีที่สุด
  • จะใช้ตนเองที่ไหน
  • อนุสัญญาการตั้งชื่อสำหรับตนเอง
• ที่ไม่ควรใช้เอง
• บทสรุป

ทำความเข้าใจตนเองใน Python

Python เป็น ภาษา การเขียนโปรแกรมเชิงวัตถุ (OOP)ที่อาศัยคลาสและอ็อบเจกต์อย่างมาก ดังนั้นก่อนที่จะลงลึกถึงselfพารามิเตอร์ เราต้องเข้าใจก่อนว่าการเขียนโปรแกรมเชิงวัตถุคืออะไร

การเขียนโปรแกรมเชิงวัตถุใน Python

การเขียนชอล์ค – OOP, การเขียนโปรแกรมเชิงวัตถุ " data-medium-file="https://blog.enterprisedna.co/wp-content/uploads/2023/04/istockphoto-147480805-612x612-1-300x200.jpg" data- ไฟล์ขนาดใหญ่="https://blog.enterprisedna.co/wp-content/uploads/2023/04/istockphoto-147480805-612x612-1.jpg" decoding="async" loading="lazy" src="https: //blog.enterprisedna.co/wp-content/uploads/2023/04/istockphoto-147480805-612x612-1.jpg" alt="Self ใน Python คืออะไร" class="wp-image-206807" width=" 709" height="472" srcset="https://blog.enterprisedna.co/wp-content/uploads/2023/04/istockphoto-147480805-612x612-1.jpg 612w, https://blog.enterprisedna.co /wp-content/uploads/2023/04/istockphoto-147480805-612x612-1-300x200.jpg 300w, https://blog.enterprisedna.co/wp-content/uploads/2023/04/istockphoto-147480805-612x612-1-560x372.jpg 560w" size="(max-width: 709px) 100vw, 709px">

การเขียนโปรแกรมเชิงวัตถุช่วยให้โปรแกรมเมอร์สร้างแบบจำลองแนวคิดและความสัมพันธ์ในโลกแห่งความเป็นจริงผ่านการใช้คลาสและวัตถุ ส่งผลให้โค้ดมีโครงสร้างมากขึ้น ใช้ซ้ำได้ และปรับขนาดได้

คิดว่าคลาสเป็นเทมเพลตสำหรับสร้างออบเจกต์ที่มีคุณสมบัติและเมธอดที่กำหนดไว้ล่วงหน้า นอกจากนี้ ออบเจกต์ยังเป็นตัวอย่างของคลาสที่เก็บค่าของตัวเองสำหรับแอตทริบิวต์และมีสิทธิ์เข้าถึงฟังก์ชันคลาส

แนวคิดทั้งสองนี้เป็นส่วนสำคัญในแอปพลิ เคชัน Python จำนวนมาก คุณสามารถดูทั้งคลาสและออบเจกต์ในวิดีโอนี้เกี่ยวกับวิธีสร้างข้อมูลอย่างง่ายดายด้วย Python Faker Library

บทบาทของ Python Self

Self เป็นการอ้างอิงถึงอินสแตนซ์ของคลาสใน Python อนุญาตให้คุณเข้าถึงและแก้ไขแอตทริบิวต์และเมธอดของคลาสภายในขอบเขตของมันเอง

นี่คือประเด็นสำคัญบางประการเกี่ยวกับการใช้งานself ใน Python:

• Selfไม่ใช่คำหลักที่สงวนไว้ในไวยากรณ์ของ Python คุณสามารถใช้ชื่ออื่นเพื่อระบุคลาสอินสแตนซ์ แต่selfเป็นแบบแผนที่ใช้กันอย่างแพร่หลายและยอมรับโดยโปรแกรมเมอร์ Python
• Selfถูกใช้เป็นพารามิเตอร์ตัวแรกในเมธอดอินสแตนซ์เพื่ออ้างอิงอินสแตนซ์ปัจจุบันของคลาส
• คุณสามารถใช้selfเพื่อแยกความแตกต่างระหว่างแอตทริบิวต์ของอินสแตนซ์และตัวแปรในเครื่อง ทำให้โค้ดของคุณสามารถอ่านได้มากขึ้นและบั๊กน้อยลง
• เมื่อเรียกใช้เมธอดอินสแตนซ์ Python จะส่งอินสแตนซ์เป็นพารามิเตอร์แรกโดยอัตโนมัติ
• คุณต้องประกาศselfพารามิเตอร์ใน__init__() ตัวสร้างและตัวสร้างฟังก์ชันที่ตามมาทั้งหมดในคลาสของคุณ หากไม่ทำเช่นนั้นจะทำให้โปรแกรมของคุณโยนไฟล์typeerror.
  
  คุณสามารถดูตัวอย่างข้อผิดพลาดด้านล่าง:

class Person: def __init__(self): print('welcome') def show_person(): print('I love pandas.') a = Person() b = a.show_person() Traceback (most recent call last): File "person.py", line 10, in trill = b.show_person() ^^^^^^^^^^^^^^^^^^ TypeError: Person.show_person() takes 0 positional arguments but 1 was given

หมายเหตุ:คุณสามารถใช้self พารามิเตอร์ในฟังก์ชันได้โดยใช้คุณลักษณะวิธีการแบบคงที่ที่ Python 3 มีให้ เราจะลงรายละเอียดเพิ่มเติมในหัวข้อถัดไป

การทำงานกับตนเอง

การเรียนรู้วิธีใช้self เป็นสิ่งสำคัญมากในการสร้างคลาสใน Python ในส่วนนี้ คุณจะได้เรียนรู้วิธีใช้self ในสถานการณ์ต่างๆ เมื่อทำงานกับคลาสและออบเจกต์

การเริ่มต้นวัตถุด้วย '__init__()'

เมื่อสร้างอินสแตนซ์ใหม่ของคลาส__init__() เมธอดจะถูกเรียกเพื่อเริ่มต้นแอตทริบิวต์ของออบเจกต์ เมธอด__init__() เป็นตัวสร้างคลาสและรับพารามิเตอร์self เป็นอาร์กิวเมนต์แรก

พารามิเตอร์selfถูกใช้ในวิธีนี้เพื่อเชื่อมโยงแอตทริบิวต์ของอินสแตนซ์กับอาร์กิวเมนต์ที่กำหนด

นี่คือตัวอย่าง:

class Person: def __init__(self, name, age): self.name = name self.age = age person1 = Person("Alice", 30)

ในตัวอย่างนี้วิธีการใช้, และเป็นพารามิเตอร์ระหว่างการเริ่มต้นของวัตถุ พารามิเตอร์อ้างอิงถึงอินสแตนซ์ของคลาส ทำให้คุณสามารถตั้งค่าและแอตทริบิวต์สำหรับออบเจกต์เฉพาะที่กำลังสร้างได้ init selfnameageself nameage

การใช้ตนเองในวิธีการ

เมื่อกำหนดเมธอดอินสแตนซ์ในคลาส คุณควรรวมself เป็นพารามิเตอร์แรก ซึ่งช่วยให้คุณเข้าถึงแอตทริบิวต์ของอินสแตนซ์และเมธอดอื่นๆ ภายในคลาสได้

มาขยายความจากตัวอย่างก่อนหน้านี้:

class Person: def __init__(self, name, age): self.name = name self.age = age def introduce(self): print("Hello, my name is " + self.name + " and I'm " + str(self.age) + " years old.") person1 = Person("Alice", 30) person1.introduce()

ในตัวอย่างนี้introduce()เมธอดรวมselfเป็นพารามิเตอร์แรก ซึ่งช่วยให้คุณเข้าถึงแอตทริบิวต์ชื่อและอายุของวัตถุ และสร้างการแนะนำส่วนบุคคลได้

เมื่อเรียกใช้เมธอดในโค้ดของคุณ คุณไม่จำเป็นต้องส่งพารามิเตอร์ self อย่างชัดเจน Python จะดูแลโดยอัตโนมัติ

เมื่อปฏิบัติตามคำแนะนำเหล่านี้และเข้าใจจุดประสงค์ของselfPython ผู้เริ่มต้นจะสามารถทำงานกับคลาสและออบเจกต์ได้อย่างมีประสิทธิภาพ ซึ่งช่วยให้พวกเขาสร้างโค้ดที่มีโครงสร้างดีซึ่งอ่านและบำรุงรักษาได้ง่าย

กรณีการใช้งานด้วยตนเองทั่วไป

คุณสามารถใช้ คีย์เวิร์ดในโค้ด Python ได้หลายวิธี เมื่อเข้าใจกรณีการใช้งานเหล่านี้ คุณจะสามารถใช้งานได้อย่างมีประสิทธิภาพในโปรแกรมของคุณ self self

ลองดูบางส่วนของพวกเขา:

การเข้าถึงแอตทริบิวต์ของคลาส

การใช้งานหลักอย่างหนึ่งselfคือการเข้าถึงแอตทริบิวต์ของอินสแตนซ์ภายในคลาส แอตทริบิวต์ของอินสแตนซ์มีความเฉพาะเจาะจงกับวัตถุที่สร้างจากคลาสและเก็บข้อมูลของวัตถุ

การใช้selfช่วยให้คุณจัดการหรือเข้าถึงแอตทริบิวต์เหล่านี้ภายในเมธอดคลาส ลองดูตัวอย่าง:

class Dog: def __init__(self, name, age): self.name = name self.age = age def display_name(self): print("The dog's name is:", self.name)

ในตัวอย่างนี้ เราเคยself เข้าถึงแอตทริบิวต์ name ของ Dog object ภายในdisplay_name เมธอด

วิธีการเรียกคลาส

อีกกรณีการใช้งานทั่วไปselfคือการเรียกเมธอดคลาสอื่นจากภายในเมธอดอินสแตนซ์ ซึ่งช่วยให้คุณนำโค้ดกลับมาใช้ใหม่ ลดความซับซ้อน และปรับปรุงความสามารถในการอ่าน

จำเป็นอย่างยิ่งที่จะใช้selfเมื่ออ้างถึงเมธอดอื่น เนื่องจากทำให้มั่นใจว่าเมธอดที่ถูกต้องถูกเรียกใช้สำหรับอินสแตนซ์เฉพาะ พิจารณาตัวอย่างต่อไปนี้:

class Bird: def __init__(self, species, color): self.species = species self.color = color def show_species(self): print("The bird species is:", self.species) def show_info(self): self.show_species() print("The bird color is:", self.color)

ในตัวอย่างข้างต้น เราใช้selfเรียกshow_speciesเมธอดจากภายในshow_infoเมธอด สิ่งนี้ทำให้เราสามารถแสดงสายพันธุ์และสีของนกได้ในการโทรเพียงครั้งเดียว

สุดท้าย อย่าลืมใช้selfเมื่อเข้าถึงแอตทริบิวต์ของอินสแตนซ์และเรียกใช้เมธอดคลาส เมื่อคุณเข้าใจกรณีการใช้งานเหล่านี้แล้ว คุณจะสามารถเขียนโค้ด Python ที่มีประสิทธิภาพและเป็นระเบียบมากขึ้นได้

วิธีปฏิบัติตนที่ดีที่สุด

เมื่อทำงานกับself,มีข้อตกลงบางประการที่คุณต้องปฏิบัติตามเพื่อหลีกเลี่ยงปัญหาและจุดบกพร่องในโค้ดของคุณ นี่คือบางส่วนของพวกเขา

จะใช้ตนเองที่ไหน

เมื่อกำหนดเมธอดอินสแตนซ์ ให้ใช้selfพารามิเตอร์เป็นพารามิเตอร์แรก เสมอ ซึ่งช่วยให้คุณเข้าถึงและแก้ไขแอตทริบิวต์ของอินสแตนซ์ของวัตถุ และเรียกใช้เมธอดอินสแตนซ์อื่นๆ ภายในคลาส

สิ่งสำคัญคือต้องใช้selfเมื่อทำงานกับอินสแตนซ์ของวัตถุใน Python การใช้มันช่วยให้มั่นใจได้ถึงพฤติกรรมที่สอดคล้องกันและช่วยให้การห่อหุ้มออบเจกต์เหมาะสม

ตัวอย่างเช่น พิจารณาคลาสต่อไปนี้:

class MyClass: def __init__(self, my_var): self.my_var = my_var

ที่นี่ พารามิเตอร์ self ใช้ใน__init__ เมธอดเพื่อเริ่มต้นmy_var แอตทริบิวต์ของอินสแตนซ์วัตถุ วิธีนี้จะกลายเป็นแอตทริบิวต์เฉพาะอินสแตนซ์ my_var

เป็นผลให้สามารถเข้าถึงและแก้ไขโดยใช้การอ้างอิงตนเองในวิธีการอื่นของชั้นเรียน

อนุสัญญาการตั้งชื่อสำหรับตนเอง

แม้ว่าจะselfเป็นชื่อทั่วไปที่ใช้สำหรับอินสแตนซ์ใน Python แต่ทางเทคนิคแล้ว คุณสามารถใช้ชื่อใดก็ได้ที่คุณต้องการ อย่างไรก็ตาม ขอแนะนำอย่างยิ่งให้คุณใช้ self เพื่อความชัดเจนและสอดคล้องกับชุมชน Python ที่กว้างขึ้น

การใช้ชื่ออื่นอาจทำให้ผู้ที่อ่านและทำงานกับโค้ดของคุณเกิดความสับสน โดยเฉพาะอย่างยิ่งหากพวกเขาคุ้นเคยกับหลักการตั้งชื่อมาตรฐานในไลบรารี Python

ที่ไม่ควรใช้เอง

เราทราบแล้วว่าselfพารามิเตอร์ให้การเข้าถึงอินสแตนซ์ของวัตถุ อย่างไรก็ตาม ในบางกรณี ฟังก์ชันบางอย่างในคลาสอาจไม่จำเป็นต้องเข้าถึงอินสแตนซ์ออบเจกต์

ในสถานการณ์จำลองนี้ ไม่จำเป็นต้องใช้พารามิเตอร์ self ดังนั้น Python จึงจัดเตรียมคุณสมบัติวิธีการแบบคงที่สำหรับการข้ามพารามิเตอร์ตัวเอง:

นี่คือตัวอย่าง:

class Car: @staticmethod def print_car(): print('Vroom Vroom')

ในตัวอย่างข้างต้น@staticmethodมัณฑนากรฟังก์ชันจะแทนที่selfข้อกำหนดพารามิเตอร์ในเมธอด ด้วยวิธีนี้ ฟังก์ชันจะยังคงทำงานแม้ว่าจะไม่มีอินสแตนซ์ออบเจกต์ผ่านเข้าไป

บทสรุป

โดยสรุป พารามิเตอร์ self ใน Python หมายถึงอินสแตนซ์ของคลาสและอนุญาตให้คุณเข้าถึงแอตทริบิวต์และเมธอดของคลาส ในฐานะนักพัฒนา Python สิ่งสำคัญคือต้องเข้าใจจุดประสงค์ของตนเองและการใช้งานในคลาสและออบเจกต์

ด้วยการใช้ self อย่างสม่ำเสมอในโค้ดของคุณ คุณจะส่งเสริมความสามารถในการอ่านและการบำรุงรักษา ซึ่งจะช่วยเพิ่มคุณภาพโดยรวมของงานของคุณ

นอกจากนี้ โปรดจำไว้ว่าแม้คุณอาจเห็นคำ "self"ที่ใช้บ่อยใน Python แต่คำนี้ไม่ใช่คำหลักของ Python ที่สงวนไว้ สิ่งนี้แตกต่างจากภาษาโปรแกรมเช่นJavascript และ Javaซึ่ง"this" เป็นคำหลักที่สงวนไว้

คุณสามารถตั้งชื่อพารามิเตอร์ตัวแรกในคลาสเมธอดได้ตามต้องการ “ self“เป็นเพียงการประชุมที่ต้องการ