วิธีใช้การเรียกซ้ำของ Python
การเรียกซ้ำของ Python เป็นหัวข้อที่น่ากลัวสำหรับผู้เริ่มต้น มาปัดเป่าตำนานที่ว่าการเรียกซ้ำนั้นยากด้วยการกำหนดมัน การเรียกซ้ำเป็นวิธีการเขียนโปรแกรมที่ฟังก์ชันเรียกตัวเอง
ฟังดูง่ายใช่มั้ย เมื่อคุณเข้าใจแล้ว การเรียกซ้ำไม่ใช่แนวคิดที่ยาก
ในบทช่วยสอน Python นี้ เราจะพูดถึงการเรียกซ้ำและวิธีการทำงาน เราจะอธิบายตัวอย่างการเรียกซ้ำโดยใช้ฟังก์ชันแฟกทอเรียลเพื่อช่วยคุณในการเริ่มต้นใช้วิธีการเขียนโปรแกรมนี้
การเรียกซ้ำคืออะไร
การเรียกซ้ำเป็นที่ที่คุณกำหนดบางสิ่งบางอย่างในแง่ของตัวเอง
ฟังก์ชันแบบเรียกซ้ำช่วยแก้ปัญหาด้วยการเรียกตัวเองซ้ำอีกครั้ง ลักษณะการทำงานนี้ได้รับการสนับสนุนในภาษาการเขียนโปรแกรมหลักส่วนใหญ่ เช่น Python พวกเขาเป็นส่วนสำคัญของวิทยาการคอมพิวเตอร์และวิทยาศาสตร์ข้อมูล
การเรียกซ้ำมีประโยชน์เมื่อสามารถค้นหาวิธีแก้ไขปัญหาได้โดยแยกย่อยเป็นปัญหาเล็กๆ ซึ่งทั้งหมดใช้สูตรเดียวกัน ปัญหาประเภทนี้มักเรียกว่า "อัลกอริทึมแบบเรียกซ้ำ" กุญแจสำคัญในการแก้ปัญหาอยู่ในชื่อ!
วนซ้ำกับวนซ้ำ
มีสองวิธีในการแก้ปัญหาอัลกอริทึม:วนซ้ำหรือวนซ้ำ
วิธีแก้ปัญหาแบบวนซ้ำสำหรับอัลกอริธึมถือเป็น "ทรงพลังแต่น่าเกลียด" พวกเขาทำงานให้เสร็จลุล่วง แต่พวกเขาไม่ได้ทำในลักษณะที่หรูหราที่สุดอย่างแน่นอน เพื่อให้เข้าใจอัลกอริธึมแบบเรียกซ้ำได้อย่างถูกต้อง เราต้องดูที่ฟังก์ชันการวนซ้ำ
81% ของผู้เข้าร่วมกล่าวว่าพวกเขารู้สึกมั่นใจมากขึ้นเกี่ยวกับโอกาสในการทำงานด้านเทคโนโลยีหลังจากเข้าร่วม bootcamp จับคู่กับ Bootcamp วันนี้
ผู้สำเร็จการศึกษาจากหลักสูตร bootcamp โดยเฉลี่ยใช้เวลาน้อยกว่าหกเดือนในการเปลี่ยนอาชีพ ตั้งแต่เริ่มต้น bootcamp ไปจนถึงหางานแรก
ฟังก์ชันวนซ้ำเป็นฟังก์ชันที่แก้ปัญหาโดยใช้ลูป มันจะรันโค้ดภายในลูปจนกว่าลูปนั้นจะสมบูรณ์ ฟังก์ชันแบบเรียกซ้ำคือฟังก์ชันที่แบ่งปัญหาออกเป็นส่วนเล็กๆ และแก้ปัญหาแต่ละส่วนด้วยการเรียกตัวเอง
แฟกทอเรียล:ตัวอย่างซ้ำ
แฟกทอเรียลเป็นวิธีที่ดีในการแสดงการเรียกซ้ำและการคิดแบบวนซ้ำ ในทางคณิตศาสตร์ แฟกทอเรียลคือผลรวมของตัวเลขและทุกจำนวนก่อนที่จะคูณกัน
แฟกทอเรียลของ 5 เท่ากับ 5 * 4 * 3 * 2 * 1 แฟคทอเรียลของ 2 เท่ากับ 2 * 1
ในการคำนวณแฟกทอเรียล เราสามารถเขียนฟังก์ชันวนซ้ำได้:
def factorial(number): total = 1 for n in range(1, number + 1): total = total * n return total
ฟังก์ชันนี้ใช้ for loop เพื่อวนซ้ำตัวเลขทั้งหมดในช่วง 1 และจำนวนที่เราระบุบวก 1 สำหรับการวนซ้ำแต่ละครั้ง จำนวนที่วนซ้ำซ้ำจะถูกคูณด้วยผลรวม เรียกฟังก์ชันของเราเพื่อค้นหาแฟกทอเรียล:
answer = factorial(4) print(answer)
รหัสของเราส่งคืน:24. ในการมาถึงโซลูชันนี้ รหัสของเราทำงาน:
- 1 * 1 =1
- 2 * 2 =4
- 4 * 3 =8
- 8 * 4 =24
อย่างที่คุณเห็น รหัสของเราคูณ 4 ด้วยจำนวนที่น้อยกว่านั้นและตัวมันเอง
รหัสนี้ใช้งานได้ ข้อเสียอย่างเดียวคือมันไม่หรูหราเท่าที่ควร นั่นคือจุดที่ฟังก์ชันแบบเรียกซ้ำมีประโยชน์
แฟกทอเรียล:ตัวอย่างการเรียกซ้ำ
ลองเขียนฟังก์ชันแบบเรียกซ้ำที่คำนวณแฟกทอเรียล เปิดไฟล์ Python ใหม่แล้ววางในรหัสต่อไปนี้:
def factorial(number): if number == 1: return 1 else: return (number * factorial(number - 1))
รหัสนี้ใช้วิธีเรียกซ้ำ เมื่อเรียกใช้ฟังก์ชันนี้ คำสั่ง "if" จะถูกดำเนินการ คำสั่งนี้จะตรวจสอบว่าจำนวนที่ส่งไปยังฟังก์ชันเท่ากับ 1 หรือไม่ หากเป็น ฟังก์ชันของเราจะคืนค่า 1 มิฉะนั้น แฟกทอเรียลของตัวเลขของเราจะถูกคำนวณ
การคำนวณนี้ทำงานโดยการคูณจำนวนที่ส่งไปยังฟังก์ชันด้วยแฟกทอเรียลของตัวเลขก่อนหน้า ฟังก์ชันนี้ถูกเรียกซ้ำแล้วซ้ำเล่าจนกระทั่ง “number” เท่ากับ 1 ทุกครั้งที่มีการเรียกใช้ฟังก์ชัน ค่าของ “number” จะลดลง 1
มาลองใช้โค้ดของเรากับเลข 4 กัน
answer = factorial(4) print(answer)
คำตอบ 24 ถูกส่งกลับ คำตอบของเราถูกต้อง มันเหมือนกับตัวอย่างสุดท้ายของเรา เราพบวิธีแก้ไขปัญหานี้แบบวนซ้ำแทนที่จะวนซ้ำ
คุณยังต้องการความช่วยเหลืออีกเล็กน้อยหรือไม่? มาดูอีกตัวอย่างหนึ่งของการเรียกซ้ำ
การเรียกซ้ำด้วยลำดับฟีโบนักชี
ลำดับฟีโบนักชีเป็นลำดับทางคณิตศาสตร์ โดยที่ตัวเลขแต่ละตัวเป็นผลรวมของตัวเลขสองตัวก่อนหน้า ลำดับนี้เริ่มต้นด้วย:0, 1, 1, 2, 3, 5, 8, 13 และอื่นๆ
ลำดับนี้บวกตัวเลขสองตัวเพื่อค้นหาตัวเลขถัดไป ทำให้เหมาะสำหรับการเรียกซ้ำ
เปิดไฟล์ Python แล้ววางในรหัสนี้:
def fibonacci(number): if number <= 1: return number else: return(fibonacci(number - 1) + fibonacci(number - 2))
รหัสนี้จะคำนวณผลรวมของตัวเลขสองตัวก่อนหน้าในรายการ ตราบใดที่ "ตัวเลข" มากกว่า 1 มิฉะนั้น "หมายเลขจะถูกส่งคืน" มาเรียกฟังก์ชันของเรากัน:
executions = 5
print("Fibonacci Sequence:")
for number in range(executions):
print(fibonacci(number))
ตัวแปรการดำเนินการติดตามจำนวนตัวเลขในลำดับฟีโบนักชีที่เราต้องการคำนวณ เราใช้สิ่งนี้เพื่อสร้าง for loop ซึ่งเรียก fibonacci() . ของเรา ฟังก์ชันสำหรับแต่ละตัวเลขในช่วง 1 และค่าของ "การดำเนินการ"
ก่อนที่ for loop ของเราจะเริ่ม เราพิมพ์ “Fibonacci Sequence:” ไปที่คอนโซล ในตัวอย่างนี้ ลูป "for" ของเราดำเนินการ:
fibonacci(1) fibonacci(2) fibonacci(3) fibonacci(4) fibonacci(5)
มารันโค้ดของเรากันและดูว่าเกิดอะไรขึ้น:
Fibonacci Sequence: 0 1 1 2 3
รหัสของเราคำนวณตัวเลขห้าตัวแรกในลำดับฟีโบนักชี เราสามารถคำนวณตัวเลขได้มากขึ้นโดยการเพิ่มมูลค่าของ “การดำเนินการ”
ความลึกของการเรียกซ้ำและเงื่อนไขพื้นฐาน
ฟังก์ชันแบบเรียกซ้ำต้องมีเงื่อนไขพื้นฐาน นี่เป็นเงื่อนไขที่หยุดการเรียกซ้ำเมื่อตรงตามกรณีฐานเฉพาะ หากไม่มีฟังก์ชันพื้นฐาน ลูปอนันต์จะถูกสร้างขึ้น
ฟังก์ชันแบบเรียกซ้ำสามารถดำเนินการเองได้ไม่เกิน 1,000 ครั้งโดยค่าเริ่มต้น เมื่อถึงขีดจำกัดนี้ ข้อผิดพลาดเช่นนี้จะปรากฏขึ้น:
RecursionError: maximum recursion depth exceeded
นี่คือเงื่อนไขพื้นฐานสำหรับโปรแกรมฟีโบนักชีของเรา:
... if number <= 1: return number …
เงื่อนไขนี้จะตรวจสอบว่าค่าของ “number” ในโปรแกรม fibonacci ของเรามีค่าเท่ากับหรือน้อยกว่า 1 หรือไม่ หากเป็น ค่าของ “number” จะถูกส่งกลับ มิฉะนั้น ฟังก์ชันแบบเรียกซ้ำจะเริ่มต้นขึ้น
เหตุใดฉันจึงควรใช้การเรียกซ้ำ
ข้อดีของการใช้การเรียกซ้ำบนฟังก์ชันการวนซ้ำคืออะไร ในทางเทคนิค ทั้งสองวิธีสามารถบรรลุผลลัพธ์เดียวกันได้ ข้อดีของการเรียกซ้ำคืออ่านง่ายกว่า
เมื่อคุณเห็นฟังก์ชันแบบเรียกซ้ำ จะเห็นได้ชัดว่าคำตอบของปัญหาอยู่ที่การแยกย่อยเป็นส่วนย่อยๆ แม้ว่าบางครั้งการวนซ้ำแบบวนซ้ำอาจเร็วกว่า แต่มักจะต้องการใช้ฟังก์ชันแบบเรียกซ้ำเนื่องจากความสามารถในการอ่านได้
เนื่องจากฟังก์ชันแบบเรียกซ้ำนั้นอ่านง่ายกว่า จึงง่ายต่อการบำรุงรักษาและดีบัก สิ่งนี้มีประโยชน์อย่างยิ่งเมื่อคุณกำลังเขียนอัลกอริธึมที่ซับซ้อนซึ่งอาจเข้าใจยาก
บทสรุป
ฟังก์ชันแบบเรียกซ้ำคือฟังก์ชันที่เรียกตัวเองเพื่อค้นหาวิธีแก้ไขปัญหา
ฟังก์ชันแบบเรียกซ้ำจะแบ่งปัญหาออกเป็นหลายส่วนและแก้ปัญหาได้หนึ่งส่วนต่อการทำซ้ำ ฟังก์ชันแบบเรียกซ้ำมักใช้ในการคำนวณแฟกทอเรียลและตัวเลขในลำดับฟีโบนักชี พวกเขายังใช้ในอัลกอริธึมจำนวนหนึ่ง
ตอนนี้คุณพร้อมที่จะเริ่มทำงานกับฟังก์ชันแบบเรียกซ้ำใน Python แล้ว
