Python และวิธีการขั้นสูง ฟังก์ชัน dunder เพื่อการเขียนโปรแกรมที่ดีขึ้น

Python เป็นภาษาโปรแกรมที่ยอดเยี่ยมและเห็นได้จาก GitHubยังเป็นภาษาที่ได้รับความนิยมเป็นอันดับสองในปี 2022

ข้อดีที่น่าสนใจที่สุดของ Python คือชุมชนโปรแกรมเมอร์ขนาดใหญ่

ดูเหมือนว่า Python จะมีแพ็คเกจสำหรับทุกกรณีการใช้งาน

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

เมธอดเมธอดเป็นชุดของเมธอดล่วงหน้าdefinites ใน Python ที่มีคุณสมบัติวากยสัมพันธ์พิเศษ พวกเขาจำได้ง่ายด้วยเครื่องหมายขีดกลางสองตัวที่จุดเริ่มต้นและจุดสิ้นสุด เช่น __init__, __call__, __len__ …เป็นต้น

วิธีการวิเศษ

เมธอดเมธอดอนุญาตให้ออบเจกต์แบบกำหนดเองทำงานคล้ายกับประเภท Python ในตัว

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

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

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

__ในนั้น__

บางทีอาจเป็นฟังก์ชันพื้นฐานที่สุดของทั้งหมด นี่เป็นเมธอดวิเศษที่ Python เรียกใช้โดยอัตโนมัติเมื่อใดก็ตามที่เราสร้าง (หรือตามชื่อที่แนะนำ ให้เริ่มต้น) วัตถุใหม่__init__

คลาสพิซซ่า:
    def __init__(ตัวเอง, ขนาด, ท็อปปิ้ง):
        self.size = ขนาด
        self.toppings = ท็อปปิ้ง

#มาทำพิซซ่ากันเถอะ
my_pizza = พิซซ่า('ใหญ่', ['เปปเปอร์โรนี', 'เห็ด'])

พิมพ์ (my_pizza.size) # สิ่งนี้จะพิมพ์: ใหญ่
พิมพ์(my_pizza.toppings) # สิ่งนี้จะพิมพ์: ['pepperoni', 'mushrooms']

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

ที่นี่ใช้เพื่อแสดงอินสแตนซ์ของคลาส ดังนั้นเมื่อเราเขียน self.size = size เรากำลังพูดว่า "เฮ้ วัตถุพิซซ่านี้มีขนาดแอตทริบิวต์ sizeและฉันต้องการให้เป็นขนาดใดก็ตามที่ฉันให้ไว้เมื่อฉันสร้างวัตถุ”

__str__ และ __repr__

__Str__

นี่เป็นวิธีการวิเศษของ Python ที่ช่วยให้เราทำได้ definish คำอธิบายสำหรับรายการที่กำหนดเองของเรา

เมื่อคุณพิมพ์วัตถุหรือแปลงเป็นสตริงโดยใช้ str(), Python ตรวจสอบว่าคุณมีหรือไม่ defiฉันได้คิดวิธีการ __str__ สำหรับคลาสของวัตถุนั้น

ถ้าเป็นเช่นนั้น ให้ใช้วิธีการนั้นเพื่อแปลงวัตถุเป็นสตริง

เราสามารถขยายตัวอย่าง Pizza ของเราเพื่อรวมฟังก์ชัน __str__ ดังต่อไปนี้:

class Pizza: def __init__(self, size, toppings): self.size = size self.toppings = toppings def __str__(self): return f"A {self.size} pizza with {', '.join(self.toppings) )}" my_pizza = Pizza('large', ['pepperoni', 'mushrooms']) print(my_pizza) # สิ่งนี้จะพิมพ์: พิซซ่าขนาดใหญ่ที่มีเปปเปอร์โรนีและเห็ด

__repr__

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

ถ้าคุณโทร repr() บนวัตถุหรือคุณเพียงแค่พิมพ์ชื่อวัตถุลงในคอนโซล Python จะค้นหาวิธีการ __repr__.

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

นี่คือวิธีที่เราทำได้ defiเสร็จ __repr__ สำหรับตัวอย่างพิซซ่าของเรา:

คลาสพิซซ่า:
    def __init__(ตัวเอง, ขนาด, ท็อปปิ้ง):
        self.size = ขนาด
        self.toppings = ท็อปปิ้ง

    def __repr__(ตัวเอง):
        กลับ f"พิซซ่า ('{self.size}', {self.toppings})"

my_pizza = พิซซ่า('ใหญ่', ['เปปเปอร์โรนี', 'เห็ด'])
พิมพ์ (repr (my_pizza)) # สิ่งนี้จะพิมพ์: พิซซ่า ('ใหญ่', ['เปปเปอร์โรนี', 'เห็ด'])

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

__เพิ่ม__

ใน Python เราทุกคนทราบดีว่าการบวกเลขโดยใช้โอเปอเรเตอร์นั้นเป็นไปได้ +ในฐานะที่เป็น 3 + 5.

แต่ถ้าเราต้องการเพิ่มอินสแตนซ์ของออบเจกต์ที่กำหนดเองล่ะ

ฟังก์ชั่นดันเดอร์ __add__ มันทำให้เราทำอย่างนั้นได้ มันทำให้เรามีความสามารถในการ definish พฤติกรรมของผู้ปฏิบัติงาน + ในรายการส่วนตัวของเรา

เพื่อความสอดคล้องกัน สมมติว่าเราต้องการ defiจบพฤติกรรมของ + ในตัวอย่างพิซซ่าของเรา สมมติว่าเมื่อใดก็ตามที่เราเพิ่มพิซซ่าสองหน้าขึ้นไป ระบบจะรวมท็อปปิ้งทั้งหมดเข้าด้วยกันโดยอัตโนมัติ นี่คือสิ่งที่อาจมีลักษณะดังนี้:

คลาสพิซซ่า:
    def __init__(ตัวเอง, ขนาด, ท็อปปิ้ง):
        self.size = ขนาด
        self.toppings = ท็อปปิ้ง

    def __add__(ตัวเอง, อื่นๆ):
        ถ้าไม่ใช่อินสแตนซ์ (อื่น ๆ, พิซซ่า):
            เพิ่ม TypeError ("คุณสามารถเพิ่มพิซซ่าอื่นเท่านั้น!")
        new_toppings = self.toppings + other.toppings
        คืนพิซซ่า(self.size, new_toppings)

#มาสร้างพิซซ่าสองถาดกันเถอะ
pizza1 = พิซซ่า ('ใหญ่', ['เปปเปอร์โรนี', 'เห็ด'])
pizza2 = พิซซ่า ('ใหญ่', ['มะกอก', 'สับปะรด'])

#และตอนนี้มา "เพิ่ม" กัน
combination_pizza = พิซซ่า 1 + พิซซ่า 2

พิมพ์(combined_pizza.toppings) # สิ่งนี้จะพิมพ์: ['pepperoni', 'mushrooms', 'olive', 'pineapple']

ในทำนองเดียวกันกับดันเดอร์ __add__เรายังสามารถ defiจบฟังก์ชันเลขคณิตอื่นๆ เช่น __sub__ (โดยการลบโดยใช้ตัวดำเนินการ -) และ __mul__ (สำหรับการคูณโดยใช้ตัวดำเนินการ *).

__เลน__

วิธีการอันเดอร์นี้ช่วยให้เราสามารถ defiทำหน้าที่อะไรให้เสร็จ len() จะต้องกลับมาสำหรับรายการที่กำหนดเองของเรา

ไพธอนใช้ len() เพื่อดูความยาวหรือขนาดของโครงสร้างข้อมูล เช่น รายการหรือสตริง

ในบริบทของตัวอย่างของเรา เราสามารถพูดได้ว่า "ความยาว" ของพิซซ่าคือจำนวนของท็อปปิ้งที่มี นี่คือวิธีที่เราสามารถนำไปใช้ได้:

คลาสพิซซ่า:
    def __init__(ตัวเอง, ขนาด, ท็อปปิ้ง):
        self.size = ขนาด
        self.toppings = ท็อปปิ้ง

    def __len__(ตัวเอง):
        กลับเลนส์(self.toppings)

#มาสร้างพิซซ่ากันเถอะ
my_pizza = พิซซ่า ('ใหญ่', ['เปปเปอร์โรนี', 'เห็ด', 'มะกอก'])

พิมพ์(len(my_pizza)) # สิ่งนี้จะพิมพ์: 3

ในเมธอด __len__ เราจะคืนค่าความยาวของรายการเท่านั้น toppings. ตอนนี้ len(my_pizza) มันจะบอกเราว่ามีกี่ท็อปปิ้ง my_pizza.

__อิเตอร์__

เมธอด dunder นี้ทำให้อ็อบเจกต์สามารถวนซ้ำได้ เช่น สามารถใช้ใน for loop ได้

ในการทำเช่นนี้เรายังต้องทำ defiเสร็จสิ้นการทำงาน __next__,สิ่งนี้ใช้สำหรับ definish ลักษณะการทำงานที่ควรคืนค่าถัดไปในการวนซ้ำ นอกจากนี้ยังควรส่งสัญญาณการวนซ้ำในกรณีที่ไม่มีองค์ประกอบเพิ่มเติมในลำดับ เรามักจะบรรลุผลสำเร็จโดยการส่งข้อยกเว้น StopIteration.

สำหรับตัวอย่างพิซซ่าของเรา สมมติว่าเราต้องการทำซ้ำท็อปปิ้ง เราสามารถทำซ้ำคลาสพิซซ่าของเราได้ definendo วิธีการ __iter__:

คลาสพิซซ่า:
    def __init__(ตัวเอง, ขนาด, ท็อปปิ้ง):
        self.size = ขนาด
        self.toppings = ท็อปปิ้ง

    def __iter__(ตัวเอง):
        ตนเอง.n = 0
        คืนตัวเอง

    def __next__(ตัวเอง):
        ถ้า self.n < len(self.toppings):
            ผลลัพธ์ = self.toppings[self.n]
            ตนเอง.n += 1
            ส่งคืนผลลัพธ์
        อื่น:
            เพิ่ม StopIteration

#มาสร้างพิซซ่ากันเถอะ
my_pizza = พิซซ่า ('ใหญ่', ['เปปเปอร์โรนี', 'เห็ด', 'มะกอก'])

#และตอนนี้เรามาทบทวนกันอีกครั้ง
สำหรับท็อปปิ้งใน my_pizza:
    พิมพ์ (ท็อปปิ้ง)

ในกรณีนี้ สำหรับการโทรแบบวนซ้ำ __iter__ซึ่งเริ่มต้นตัวนับ (self.n) และส่งคืนวัตถุพิซซ่าเอง (self).

จากนั้นสำหรับการโทรวนซ้ำ __next__ เพื่อให้ได้แต่ละท็อปปิ้งตามลำดับ

เมื่อ __next__ คืนเครื่องปรุงรสทั้งหมด StopIteration มันพ่นข้อยกเว้นและ for วนรอบรู้ว่าไม่มีท็อปปิ้งอีกแล้วดังนั้นจะยกเลิกกระบวนการวนซ้ำ

Ercole Palmeri