ไม่เป็นไร.
รายชื่อจำนวนมากนี้ถูกป้อนลงในหน่วยความจำในที่สุด
แต่จำเงื่อนไขสำคัญของเรา
จำได้ไหมว่าฉันพูดว่ารายการเป็นแบบวนซ้ำได้?
iterable คืออะไร?
iterable คืออ็อบเจกต์ใดๆ ใน Python ที่เราสามารถวนซ้ำได้ภายใต้ประทุน
มันมีวิธีการป้อนคนโง่
ดังนั้นเมื่อวัตถุถูกสร้างขึ้น ตัวแก้ไขนี้ทำให้เรามีวัตถุที่วนซ้ำได้ซึ่งสามารถวนซ้ำเพื่อวนซ้ำบางสิ่งหรือการวนซ้ำคือการนำรายการจากการที่
iterable ทำอะไรกับสิ่งนั้นแล้วไปที่วัตถุถัดไป
สิ่งที่เราใช้การวนซ้ำ เช่น for loops หรือ while loops เราเรียกว่าการวนซ้ำนั้น
มันเป็นกระบวนการเอง
และเครื่องกำเนิดไฟฟ้า
ทำซ้ำได้จริง
นั่นคือทุกสิ่งที่เป็นเครื่องกำเนิดสามารถทำซ้ำได้
คุณสามารถวนซ้ำได้ แต่ไม่ใช่ทุกสิ่งที่ทำซ้ำได้คือตัวสร้าง
ตัวอย่างเช่น ช่วงเป็นตัวสร้าง
สิ่งนั้นจะเป็นการทำซ้ำได้เสมอ
แต่รายการเป็นแบบวนซ้ำได้ แต่ไม่ใช่ตัวสร้าง
ดังนั้นเครื่องกำเนิดจึงเป็นสับเซตของ iterable
ฉันรู้ว่ามันเป็นคำพูดมากมาย
หวังว่าคุณจะยังอยู่กับฉัน
ความแตกต่างระหว่างตัวสร้างและการวนซ้ำแบบปกติคือวิธีที่เรานำไปใช้
ให้ฉันแสดงวิธีทั่วไปในการสร้างเครื่องกำเนิดไฟฟ้า
มาล้างรหัสนี้และกำหนดตัวสร้างของเราเอง
และเครื่องกำเนิดไฟฟ้ามักจะทำหน้าที่เหมือนกับช่วงที่เป็นฟังก์ชัน
เครื่องกำเนิดไฟฟ้ามักจะถูกสร้างขึ้นด้วยวิธีนี้
สมมุติว่าฟังก์ชันตัวสร้าง
และฟังก์ชันตัวสร้างนี้จะมีสี่ลูปที่จะวนซ้ำในช่วงเหมือนที่เคยมีมา
แต่ความแตกต่างที่นี่ จริง ๆ แล้วเรานำโค้ดที่เรามีก่อนหน้านี้กลับมา
เธอจะแสดงความคิดเห็นนี้เพื่อให้เราเห็นในแง่ของความแตกต่าง
ฟังก์ชันเครื่องกำเนิดไฟฟ้าจะไปที่
สมมติว่าสร้างหลายรายการเหล่านี้
แต่แทนที่จะส่งคืนเหมือนในฟังก์ชันปกติ เราจะใช้คำหลักที่เรียกว่าผลตอบแทน
และที่นี่เราจะให้ผล I ดังนั้นรายการ
สังเกตความแตกต่างที่นี่
ทีนี้ ถ้าเราต้องการ เหมือนกับที่นี่ เราสามารถส่งต่อตัวเลขได้
แบบนี้.
แต่แทนที่จะกลับ
และต่อท้ายรายการนี้และสร้างข้อมูลทั้งหมดนี้ เราจะใช้ eald
แล้วฮิลด์ทำอะไร?
คุณเห็นไหมว่า Hield หยุดฟังก์ชันชั่วคราวและกลับมาทำงานเมื่อเราทำอะไรกับมัน ซึ่งเรียกว่าถัดไป ซึ่งเป็นสิ่งที่เราจะพูดถึงในไม่ช้า
ดังนั้น Hield จึงพูดว่า เฮ้ หยุดฟังก์ชันชั่วคราว แค่ Hield ฉันให้ I และเมื่อคุณบอกให้ฉันทำต่อไปอีก
ฉันจะไปต่อ
แล้วเราจะทำสิ่งนี้ได้อย่างไร?
ฉันสามารถพูดได้สำหรับรายการในฟังก์ชันตัวสร้าง
ฉันกำลังจะไป.
พิมพ์.
รายการ.
ทีนี้ สิ่งที่จะเกิดขึ้นคือ เราจะวนรอบฟังก์ชันตัวสร้าง และเราจะให้มันไปยังฟังก์ชันตัวสร้าง
สมมุติว่า 1,000 สำหรับตอนนี้
และเราจะพิมพ์แต่ละรายการในฟังก์ชันตัวสร้าง เพราะนี่คือการทำซ้ำได้
มันจะวิ่งและมันจะวนซ้ำ
และสำหรับทุกรายการในจำนวนนี้เพื่อให้เป็นช่วง เราจะให้ค่า Y ดังนั้นมันจะวนซ้ำและวนซ้ำ
และเมื่อเรากลับมา เราก็วนซ้ำ
เราจะเรียกใช้สิ่งนี้และผลตอบแทน
กลับมาวิ่งอีกครั้ง
ให้ฉันแสดงให้คุณเห็นว่าฉันหมายถึงอะไร
ฉันจะแสดงความคิดเห็นนี้ แสดงความคิดเห็นนี้เช่นกัน
และเพียงแค่คลิกเรียกใช้ที่นี่
คุณเห็นไหม
สิ่งที่เราเพิ่งทำที่นี่คล้ายกับข้างล่างนี้ แต่แทนที่จะต้องสร้างรายการนั้นในหน่วยความจำ
มันก็แค่ไปทีละรายการ
เรามีเพียงหนึ่งรายการในความทรงจำ
และเราใช้มันอย่างที่เราต้องการ
ในกรณีของเรา ทั้งหมดที่เราทำคือรายการพิมพ์
มาสำรวจคีย์เวิร์ดนี้กันอีกสักหน่อย
มันทำอะไรได้บ้าง?
สมมติว่าเราต้องการคูณนี่ด้วยสอง เหมือนกับที่เราทำในตัวอย่างเดิมของเราที่มีรายการ
แต่ตอนนี้ แทนที่จะทำโฟร์ลูป เรามาเรียกใช้ฟังก์ชันกันดีกว่า
และพูดว่า gee เท่ากับฟังก์ชันตัวสร้าง และเราจะให้ 100
ตอนนี้ถ้าฉันพิมพ์ G และฉันคลิกเรียกใช้
คุณเห็นว่า?
ฉันได้รับวัตถุกำเนิด
และจำไว้ว่านี่เป็นเพียงวิธีมาตรฐานใน Python ที่เราสามารถสร้างฟังก์ชันตัวสร้างโดยใช้ช่วงและคีย์เวิร์ดของผลตอบแทน
แต่คีย์เวิร์ดนี้ให้พลังแก่เราบ้างเพราะว่าถ้าผมเพิ่งกลับมาที่นี่
เราจะไม่ได้อะไรเป็นพิเศษ
แท้จริงแล้ว เราแค่จะได้รับค่าแทนโดยใช้คีย์เวิร์ดผลตอบแทน
สิ่งที่เราทำได้คือเปลี่ยนสิ่งนี้ให้เป็นฟังก์ชันตัวสร้างที่ทำได้ดี
นี้ฉันสามารถพูดต่อไป g.
ตอนนี้ถ้าฉันพิมพ์ G ถัดไปที่นี่และฉันคลิกเรียกใช้
ฉันได้รับศูนย์
แต่นี่เป็นส่วนที่เจ๋ง
ถ้าฉันทำ G ถัดไปสองครั้งแล้วหนึ่งครั้งที่นี่และพิมพ์ออกมา
ฉันได้รับสำหรับ
ทำไมถึงเป็นอย่างนั้น?
จำคำสำคัญหยุดการทำงานชั่วคราว
สิ่งที่เกิดขึ้นที่นี่คือ ฉันรันฟังก์ชันด้วย 100
รายการแรกในช่วง 100 เป็นศูนย์
ถูกต้อง.
ที่นี่ก่อนที่ฉันจะสามารถเรียกใช้สิ่งนี้ได้ มันบอกว่า เฮ้ นี่คือฟังก์ชันตัวสร้าง แต่ครั้งแรกที่คุณเรียกใช้มัน
ให้ผลลัพธ์เป็นศูนย์คูณสองครั้งเพื่อให้ในครั้งแรกที่เราเรียกใช้ฟังก์ชันนี้และฉันคลิกเรียกใช้
เราจะตรวจสอบให้แน่ใจว่าเราเปลี่ยนเป็น I
นี่ก็แค่ศูนย์
ถ้าฉันเรียกใช้อีกครั้งเช่นนี้แสดงว่าเรามี
ตอนนี้ฉันต้องการให้คุณทำซ้ำและไปที่หนึ่ง
ดังนั้นหนึ่งคูณสอง
นั่นคืออะไร?
อืม หนึ่งคูณสอง
ให้ฉันแก้ไขที่
แบบนี้.
ตรวจสอบให้แน่ใจว่านี่คือฉัน ฉันได้สองเพราะหนึ่งคูณสองเป็นสอง
ถ้าฉันเรียกใช้อีกครั้งและฉันคลิกเรียกใช้
ฉันได้รับสำหรับ
คุณเห็น.
Hield อย่างที่ฉันพูดไปก่อนหน้านี้ หยุดฟังก์ชันชั่วคราวและกลับมาที่ฟังก์ชันเมื่อเรียกใช้ next
ดังนั้นหากมีคีย์เวิร์ดให้ผลตอบแทน มันจะกลายเป็นตัวสร้าง
มันติดตามสถานะนี้ สิ่งที่เราเรียกว่าค่า และมันเก็บเฉพาะข้อมูลล่าสุดในหน่วยความจำ
ตัวอย่างเช่น เพราะมันจำได้ เพราะในบรรทัดที่ 14 ถ้าฉันพิมพ์ต่อไป G
มันจำได้ว่าก่อนหน้านี้ฉันเป็นแบบนี้
สำหรับ.
ตอนนี้ แม้ว่าโค้ดชิ้นนี้จะรันไปแล้ว แต่ถ้ารันออนไลน์ บรรทัดที่ 14
ฉันได้รับหก?
เพราะสามคูณสองเป็นหก จำไว้ เพราะมันคูณด้วยสอง.
เลยขอถามแบบนี้
ถ้าสมมุติว่าผมทำช่วงหนึ่งตรงนี้
และคุณรู้อะไรไหม
ลองลบคูณด้วยสองกัน
หากฉันทำเช่นนี้และวิ่งต่อไปมากกว่าหนึ่งครั้ง จะเกิดอะไรขึ้นถ้าฉันคลิก เรียกใช้ที่นี่
ฉันได้รับหยุด
การวนซ้ำ
คุณเห็นไหม ต่อไปสามารถเรียกได้หลายครั้งตามที่เราต้องการ
หลายครั้งจนช่วงนี้หมดเขต
และเมื่อเรามีสินค้าเกินจำนวนในช่วงนั้น
เราได้รับข้อผิดพลาดการหยุดการวนซ้ำ
เพื่อแจ้งให้เราทราบว่า เฮ้ คุณโทรต่อไปไม่ได้แล้ว
เราถึงจุดสิ้นสุดของบรรทัดแล้ว และเมื่อเราใช้สำหรับลูปที่มีช่วง จริงๆ แล้วมันจะตรวจพบสิ่งนี้ภายใต้ประทุนสำหรับคุณ
ดังนั้นเราจึงสามารถเรียกใช้ฟังก์ชันแบบนี้ได้ โดยที่เราใช้ range แม้ว่า range จะเป็นตัวสร้าง
แต่ for loop จะแจ้งโดยอัตโนมัติว่า เฮ้ ฉันจะหยุดการวนซ้ำทันทีที่เจอการวนซ้ำแบบหยุดนี้
ซ่อนตัวจากเราในฐานะผู้ใช้
ตอนนี้ แนวคิดเรื่องเครื่องกำเนิดไฟฟ้านี้ค่อนข้างเข้าใจยาก โดยเฉพาะในตอนแรก
คุณอาจต้องดูสองสามครั้ง แต่ในวิดีโอถัดไป ฉันต้องการโน้มน้าวให้คุณเห็นว่าวิดีโอเหล่านี้ทรงพลังเพียงใด
เจอกันใหม่ตอนหน้าค่ะ