เครื่องกำเนิดใน Python?

เครื่องกำเนิดไฟฟ้าเป็นส่วนสำคัญของ python นับตั้งแต่เปิดตัวด้วย PEP 255

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

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

เราสามารถใช้ตัวสร้างตามตัววนซ้ำหรือสามารถเรียกได้อย่างชัดเจนโดยใช้คำหลัก "ถัดไป"

โดยทั่วไปแล้วตัวสร้างใน Python:

• กำหนดด้วยคีย์เวิร์ด def
• ใช้คีย์เวิร์ดผลตอบแทน
• อาจมีคำหลักที่ให้ผลตอบแทนหลายคำ
• ส่งคืนตัววนซ้ำ

เครื่องกำเนิดไฟฟ้าพร้อมตัววนซ้ำ

def generator_thr_iter():
   yield 'xyz'
   yield 246
   yield 40.50
for i in generator_thr_iter():
   print(i)

ผลลัพธ์

xyz
246
40.5

ตัวสร้างโดยใช้ตัวถัดไป

def generator_thr_iter():
   yield 'xyz'
   yield 246
   yield 40.50
>>> g = generator_thr_iter()
>>> g.__next__()
'xyz'
>>> g.__next__()
246
>>> g.__next__()
40.5
>>> g.__next__()
Traceback (most recent call last):
File "<pyshell#39>", line 1, in <module>
g.__next__()
StopIteration

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

โปรแกรมพิมพ์กำลังสองของตัวเลขตั้งแต่ 1 ถึง n

พิจารณาว่าเราต้องการคำนวณกำลังสองของตัวเลขตั้งแต่ 1 ถึง n โดยที่ n เป็นจำนวนที่มาก โดยการสร้างรายการตัวเลขที่ไม่เกิน 'n' จะกินพื้นที่หน่วยความจำของระบบทั้งหมด

หากไม่มีตัวสร้าง แนวทางของเราจะเป็นอย่างไร -

>>> n= 200000000000
>>> number_list = range(1, n+1)
>>> for i in number_list:
   print(i*i)

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

โปรแกรมกำเนิดของเราเหมือนกันจะเป็น -

def num_generator(n):
num =1
while True:
   yield num
   if num == n:
      return
   else:
      num += 1
for i in num_generator(200000000000):
   print (i*i)

ดังนั้นในแนวทางข้างต้น เมื่อ for loop ถูกเตรียมใช้งานครั้งแรก num_generator จะถูกเรียกและค่าของ n =200000000000 จะถูกเก็บไว้ในหน่วยความจำและ num=1 จะถูกเตรียมใช้งานและถูกป้อนเข้าไปใน while loop ซึ่งจะวนซ้ำตลอดไป จากนั้นพบจำนวนผลผลิต ในเวลานี้ลูป while ถูกตรึงและตัวแปรโลคัลทั้งหมดจะถูกเก็บไว้ในหน่วยความจำ เนื่องจาก num=1 ผลลัพธ์ num จะถูกส่งกลับไปยังลูป for และถูกกำหนดให้กับ I โดยที่ 1(i*i) ถูกพิมพ์และทำการเรียก num_generator ครั้งต่อไป

ตอนนี้การดำเนินการเริ่มต้นจากจุดที่มันถูกตรึงไว้ก่อนหน้านี้ดังนั้นจึงดำเนินการบรรทัด num ==n (1 ==200000000000) ซึ่งเป็นเท็จ ดังนั้น num +=1 จะถูกดำเนินการซึ่งมาถึง num =2 และ while loop คือ ดำเนินการอีกครั้งและดำเนินการต่อไป

ในที่สุดในขณะที่ดำเนินการวนซ้ำจนถึง n=2000000000000 เมื่อได้รับ 200000000000 แล้วบรรทัดถัดไป 'num ==n'(2000000000000 ==200000000000) จะถูกดำเนินการ เนื่องจากมันเป็นความจริง คำสั่ง return จะถูกดำเนินการ

ดังนั้นเมื่อตัวสร้างดำเนินการคำสั่ง return หรือพบข้อยกเว้นหรือถึงจุดสิ้นสุดของตัวสร้าง ข้อยกเว้น "StopIteration" จะถูกยกขึ้นและการวนซ้ำของ for loop จะหยุดลงชั่วขณะ ดังนั้นข้างต้น เราสามารถพิมพ์กำลังสองของตัวเลขได้มากถึง 2000000000000 โดยไม่ต้องสร้างรายการตัวเลขจำนวนมากซึ่งจะมีหน่วยความจำระบบขนาดใหญ่ครอบครอง

พิจารณาสถานการณ์ข้างต้น เราอาจใช้ตัวสร้างในแนวปฏิบัติด้านการเขียนโปรแกรมประจำวันของเราเพื่อสร้างโปรแกรมที่มีประสิทธิภาพมากขึ้น>