Python Recursive Function Concept: บทช่วยสอน Python สำหรับผู้เริ่มต้น

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

การเรียกซ้ำของ Python คือ อะไร

ใน Python กลุ่มของคำสั่งที่เกี่ยวข้องที่ทำงานเฉพาะเรียกว่า 'ฟังก์ชัน' ดังนั้น ฟังก์ชันจะแบ่งโปรแกรมของคุณออกเป็นชิ้นเล็กๆ และเป็นความรู้ทั่วไปที่ฟังก์ชันสามารถเรียกใช้ฟังก์ชันอื่นๆ ใน Python ได้

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

ให้เราเข้าไปดูรายละเอียดเกี่ยวกับฟังก์ชันแบบเรียกซ้ำเพื่อให้เข้าใจการทำงานอย่างชัดเจน

ฟังก์ชันแบบเรียกซ้ำ

เรารู้ว่า ฟังก์ชันเรียกซ้ำใน Python เรียกตัวเองว่าถูกกำหนดผ่านนิพจน์การอ้างอิงตนเอง กล่าวคือ ในแง่ของตัวมันเอง มันยังคงทำงานซ้ำๆ จนกว่าจะตรงตามเงื่อนไขเฉพาะเพื่อคืนค่าหรือผลลัพธ์ ให้เราดูตัวอย่างเพื่อเรียนรู้วิธีการทำงาน

อ่านเพิ่มเติม: คำถามและคำตอบสัมภาษณ์ Python

สมมติว่าคุณต้องการหาแฟกทอเรียลของจำนวนเต็ม แฟกทอเรียลไม่ใช่แค่ผลคูณของจำนวนทั้งหมด เริ่มจาก 1 ถึงจำนวนเต็มนั้น ตัวอย่างเช่น แฟกทอเรียลของ 5 (เขียนเป็น 5!) จะเป็น 1*2*3*4*5*6 นั่นคือ 720 เรามีฟังก์ชันเรียกซ้ำ calc_factorial(x) ซึ่งกำหนดไว้ดังนี้:

def calc_factorial(x):

#ฟังก์ชันเรียกซ้ำเพื่อค้นหาแฟกทอเรียลของจำนวนเต็ม

ถ้า x == 1:

กลับ 1

อื่น

ผลตอบแทน (x * calc_factorial(x-1))

จะเกิดอะไรขึ้นถ้าคุณเรียกฟังก์ชันนี้ด้วยจำนวนเต็มบวกเช่น 4? การเรียกใช้ฟังก์ชันแต่ละครั้งจะเพิ่มสแต็กเฟรมจนกว่าเราจะไปถึงกรณีฐาน (เมื่อจำนวนลดลงเหลือ 1) จำเป็นต้องมีเงื่อนไขพื้นฐานเพื่อให้การเรียกซ้ำสิ้นสุดลงและไม่ดำเนินต่อไปอย่างไม่มีกำหนด ดังนั้น ในกรณีที่กำหนด ค่า 24 จะถูกส่งกลับหลังจากการเรียกครั้งที่สี่

การนำ R ecursive Function ไปใช้ใน Python

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

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

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

อ่าน: เงินเดือนนักพัฒนา Python ในอินเดีย

รักษารัฐ

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

ตัวอย่างเช่น หากคุณใช้การเรียกซ้ำเพื่อคำนวณ 1+2+3+4+…….+10 ในที่นี้ ตัวเลขปัจจุบันที่คุณกำลังบวกและผลรวมที่สะสมจนถึงจุดนั้นจะสร้างสถานะที่คุณต้องรักษาไว้ การรักษาสถานะเกี่ยวข้องกับการส่งสถานะปัจจุบันที่อัพเดตเป็นอาร์กิวเมนต์ผ่านการเรียกแต่ละครั้ง นี่คือวิธีที่คุณสามารถทำได้

def sum_numbers (current_number, สะสม_sum)

#เคสฐาน

#คืนสถานะสุดท้าย

ถ้าตัวเลขปัจจุบัน==11:

ผลตอบแทนที่สะสม_sum

#เคสแบบเรียกซ้ำ

#เธรดสถานะผ่านการโทรซ้ำ

อื่น:

ส่งคืน sum_numbers (current_number + 1, สะสม_sum + current_number)

อีกทางหนึ่ง คุณสามารถใช้สถานะที่ไม่แน่นอนทั่วโลก เพื่อรักษาสถานะโดยใช้วิธีนี้ คุณต้องรักษาสถานะไว้ในขอบเขตส่วนกลาง

current_number = 1

สะสม_sum = 0

def sum_numbers():

ทั่วโลก current_number

สะสมทั่วโลก_sum

#เคสฐาน

ถ้า current_number==11

ผลตอบแทนที่สะสม_sum

#เคสแบบเรียกซ้ำ

อื่น:

สะสม_sum = สะสม_ผลรวม + ปัจจุบัน_จำนวน

current_number = current_number + 1

ส่งคืน sum_numbers()

โครงสร้างข้อมูลแบบเรียกซ้ำ

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

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

การเรียกซ้ำในการคำนวณฟีโบนักชี

นักคณิตศาสตร์ชาวอิตาลี Fibonacci ได้กำหนดตัวเลขฟีโบนักชีในศตวรรษที่ 13 เพื่อจำลองการเติบโตของประชากรกระต่าย เขาอนุมานได้ว่าเริ่มจากกระต่ายคู่หนึ่งในปีแรก จำนวนคู่กระต่ายที่เกิดในปีนั้น ๆ เท่ากับจำนวนคู่กระต่ายที่เกิดในแต่ละสองปีที่ผ่านมา สามารถเขียนได้ดังนี้: Fn = Fn-1 + Fn-2 (กรณีพื้นฐาน: F0=1 และ F1=1)

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

อ่านเพิ่มเติม: เครื่องมือ Python 10 อันดับแรกที่นักพัฒนา Python ทุกคนควรรู้

ข้อดีและข้อเสียของการเรียกซ้ำ

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

ห่อ

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

หากคุณอยากเรียนรู้เกี่ยวกับวิทยาศาสตร์ข้อมูล ให้ลองดูประกาศนียบัตร PG ด้านวิทยาศาสตร์ข้อมูลของ IIIT-B และ upGrad ซึ่งสร้างขึ้นสำหรับมืออาชีพด้านการทำงานและเสนอกรณีศึกษาและโครงการมากกว่า 10 รายการ เวิร์กช็อปภาคปฏิบัติจริง การให้คำปรึกษากับผู้เชี่ยวชาญในอุตสาหกรรม 1- on-1 กับที่ปรึกษาในอุตสาหกรรม การเรียนรู้มากกว่า 400 ชั่วโมงและความช่วยเหลือด้านงานกับบริษัทชั้นนำ