ทุกสิ่งที่คุณต้องการรู้เกี่ยวกับการเรียกซ้ำใน Python

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

• การเรียกซ้ำใน Python คืออะไร?
• เงื่อนไขการสิ้นสุด
• ขีด จำกัด การเรียกซ้ำของ Python
• แบนรายการด้วยการเรียกซ้ำ
• ข้อดีของการเรียกซ้ำ
• ข้อเสียของการเรียกซ้ำ

การเรียกซ้ำใน Python คืออะไร?

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

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

java วิธีการโคลนวัตถุ

• น! = n * (n-1) * (n-2) และอื่น ๆ
• 2! = 2 * (2-1)
• หนึ่ง! = 1
• 0! = 0
• 4! = 4 * 3!
• 3! = 3 * 2!
• 2! = 2 * 1!

การแทนที่ค่าข้างต้นจะทำให้เกิดนิพจน์ต่อไปนี้

• 4! = 4 * 3 * 2 * 1

เราต้องกำหนดฟังก์ชันสมมติว่า fact (n) ซึ่งรับจำนวนเต็มบวกหรือ 0 เป็นพารามิเตอร์และส่งกลับแฟคทอเรียลที่ n เราจะทำได้อย่างไรโดยใช้การเรียกซ้ำ

มาดูกันโดยใช้การเรียกซ้ำเราจำเป็นต้องตรวจสอบสมการต่อไปนี้

• น! = n. (n-1). (n-2) & hellip3.2.1

• น! = n. (n-1)! # เราสามารถเขียนข้อความข้างต้นใหม่ได้ในบรรทัดนี้

• ตอนนี้ถ้าเราผ่าน 2 เป็นพารามิเตอร์เราจะได้รับ:

  • 2! = 2.1! = 2

• ในทำนองเดียวกันถ้าเราผ่าน 1 เราจะได้รับ:

  • หนึ่ง! = 1.0! = 1

• แต่ถ้าเราผ่าน 0 มันจะแตก

  • 0! = 0. (- 1)! และที่นี่ไม่ได้กำหนดแฟกทอเรียลสำหรับ -1 ดังนั้นจึงใช้ได้กับค่า> 0 เท่านั้น

• เราจึงต้องเขียนสองกรณี

  • 1. น! = n. (n-1)! ถ้า n> = 1

  • 2. 1 ถ้า n = 0

นี่คือคำตอบที่สมบูรณ์สำหรับจำนวนเต็มบวกและ 0 ทั้งหมด

เงื่อนไขการสิ้นสุด

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

เงื่อนไขแฟกทอเรียล:

• แฟกทอเรียลของ n = n * (n-1) ตราบใดที่ n มีค่ามากกว่า 1
• 1 ถ้า n = 0

เราจะแปลงเงื่อนไขแฟกทอเรียลข้างต้นในรหัสหลาม:

def fact (n): ถ้า n == 1: return n else: return n * fact (n-1)

ลองยกตัวอย่างสมมติว่าเราต้องการหาแฟกทอเรียลของ 4:

fact (4) # นี่จะคืนค่า 4 * fact (3) ไปเรื่อย ๆ จนถึง n == 1

 เอาท์พุต: 24

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

ขีด จำกัด การเรียกซ้ำของ Python

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

นำเข้า sys sys.getrecursionlimit ()

 เอาท์พุต: 1,000

คุณยังสามารถเปลี่ยนขีด จำกัด โดยใช้ functionetrecursionlimit () ของโมดูล sys ตามความต้องการของคุณตอนนี้เรามาสร้างฟังก์ชันที่เรียกตัวเองซ้ำ ๆ จนกว่าจะเกินขีด จำกัด และตรวจสอบสิ่งที่เกิดขึ้น:

def recursive (): recursive () ถ้า __name__ == '__main__': recursive ()

หากคุณรันโค้ดด้านบนคุณจะได้รับข้อยกเว้นรันไทม์: RuntimeError: เกินความลึกของการเรียกซ้ำสูงสุด Python ป้องกันไม่ให้คุณสร้างฟังก์ชันที่ลงท้ายด้วยการวนซ้ำที่ไม่มีวันสิ้นสุด

แบนรายการด้วยการเรียกซ้ำ

สิ่งอื่น ๆ ที่คุณสามารถทำได้โดยใช้การเรียกซ้ำยกเว้นแฟกทอเรียลสมมติว่าคุณต้องการสร้างซิงเกิลจากรายการที่ซ้อนกันสามารถทำได้โดยใช้โค้ดด้านล่าง:

def flatten (a_list, flat_list = none): ถ้า flat_list ไม่มี: flat_list = [] สำหรับรายการใน a_list: if isinstance (item, list): flatten (item, flat_list) else: flat_list.append (item) ส่งคืน flat_list ถ้า __name__ == '__main__': ซ้อนกัน = [1,2,3, [4,5], 6] x = แผ่ (ซ้อน) พิมพ์ (x)

 เอาท์พุต: [1,2,3,4,5,6]

การรันโค้ดด้านบนจะทำให้เกิดรายการเดียวแทนที่จะเป็นรายการจำนวนเต็มที่มีรายการจำนวนเต็มซึ่งเราใช้เป็นอินพุต คุณสามารถทำสิ่งเดียวกันโดยใช้วิธีอื่นได้เช่นกัน Python มีสิ่งที่เรียกว่า itertools.chain () คุณสามารถตรวจสอบรหัสที่ใช้ในการสร้างห่วงโซ่ฟังก์ชัน () ซึ่งเป็นวิธีการอื่นในการทำสิ่งเดียวกันกับที่เราทำ

ข้อดีของการเรียกซ้ำ

• รหัสมีความสะอาดและสวยงามในฟังก์ชันเรียกซ้ำ

• งานคอมโพสิตสามารถแบ่งออกเป็นปัญหาย่อยที่ง่ายกว่าโดยใช้การเรียกซ้ำ

• การสร้างลำดับทำได้ง่ายกว่าด้วยการเรียกซ้ำมากกว่าการใช้การวนซ้ำแบบซ้อน

ข้อเสียของการเรียกซ้ำ

• การปฏิบัติตามตรรกะเบื้องหลังฟังก์ชันเรียกซ้ำอาจทำได้ยากในบางครั้ง

• การโทรซ้ำมีราคาแพง (ไม่มีประสิทธิภาพ) เนื่องจากใช้หน่วยความจำและเวลามาก

• ฟังก์ชันแบบเรียกซ้ำยากที่จะแก้ไขข้อบกพร่อง

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