ยินดีต้อนรับกลับ.
ฉันต้องการให้เราเข้าใจว่าสิ่งต่าง ๆ ทำงานอย่างไรภายใต้ประทุน
ดังนั้น ผมจะแสดงให้คุณเห็นสองตัวอย่างของการปรับใช้ for loop ของเราเอง จากนั้นจึงใช้ฟังก์ชัน
range ของเราเอง
อันแรกคือ for loop ของเรา
ดังนั้นฉันจะพูดพิเศษสำหรับลูป
ภายใต้ประทุน สิ่งที่ทำคือได้รับ iterable
แล้วเราจะบอกว่าตัววนซ้ำ
จะเท่ากับ iterable ตอนนี้เพื่อให้เรามี iterable
เรามีสิ่งที่เราเรียกว่าฟังก์ชันภายใน
ที่ยอมรับ iterable ที่เราเพิ่งผ่านไป
ตอนนี้การแทรกแซงนี้จะทำให้เราสามารถใช้ฟังก์ชันถัดไปในการวนซ้ำนี้ได้
ดังนั้นอยู่กับฉัน
ฉันจะพูดในขณะที่จริง
ฉันอยากจะลอง.
และในบล็อกของชนเผ่านี้ เราจะบอกว่าตัววนซ้ำ
และเราสามารถดำเนินการได้ สมมุติว่า การดำเนินการบางอย่างที่นี่ ถ้าเราต้องการ
หรือเราสามารถเรียกตัววนซ้ำถัดไปได้
คุณรู้อะไรไหม?
ลองพิมพ์บางอย่างที่นี่ เพื่อดูว่าตัววนซ้ำคืออะไร
และสุดท้าย ฉันต้องการให้เราหยุดเมื่อเรามีข้อยกเว้นการวนซ้ำ
จำได้ไหมว่าเราเห็นว่าไม่มีรายการอื่นใน Iterable?
และที่นี่เราก็สามารถทำลายได้
ไปและให้แน่ใจว่า
ฉันตั้งคอลินไว้ถูกต้องแล้ว
ตอนนี้ถ้าฉันทำลูปพิเศษสำหรับลูปและให้รายการหนึ่ง สอง สาม และฉันคลิกเรียกใช้
ตรวจสอบออก
ฉันวนซ้ำวัตถุที่วนซ้ำได้โดยใช้ next
และคุณเห็นว่าวัตถุนี้อยู่ในพื้นที่หน่วยความจำเดียวกัน แม้ว่าเราจะวนซ้ำไปเรื่อยๆ
จนถึง 1 ถึง 3
นี่คือวิธีที่สี่ลูปทำงานภายใต้ประทุนเมื่อเราทำเช่น NUM แล้วให้รายการ
มันจะผ่านไปได้ทุกอย่าง
มันจะเปลี่ยนเป็น iterable และมันจะยังคงทำงานต่อไปและเรียกใช้ iterator ตัวถัดไปซ้ำแล้วซ้ำเล่าจนกว่าเราจะจบบรรทัดแล้วแตกออกจากลูป
และเราจะตรวจสอบค่าที่แท้จริงของตัววนซ้ำได้อย่างไร?
โปรดจำไว้ว่า ฟังก์ชันถัดไปจะแสดงผลรายการถัดไป
ถ้าจะพิมพ์ตรงนี้
และฉันคลิกเรียกใช้
ฉันเข้าใจ.
หนึ่งสองสาม.
ดังนั้นฉันสามารถทำซ้ำได้สองครั้งหากต้องการคลิกเรียกใช้
และที่นั่นคุณไป
รายการพิเศษของเราสำหรับ Loop เพียงคูณรายการของเราด้วยสอง
แค่นั้นแหละ.
นั่นเป็นวิธีที่ลูปใช้งานได้จริง
แต่สิ่งที่เกี่ยวกับช่วง?
เราสามารถสร้างฟังก์ชันช่วงของเราเองได้หรือไม่?
เราทำได้อย่างแน่นอน
และนี่เป็นเรื่องที่สนุก
มาสร้างคลาสและคลาสนี้กันเถอะ เพราะสุดท้ายแล้ว เราก็แค่จะสร้างวัตถุขึ้นมา
ที่มีการกระทำที่เราสามารถทำได้
ดังนั้นฉันจะบอกว่า gen ของฉันสำหรับเครื่องกำเนิดไฟฟ้าของฉันและนี่จะเลียนแบบสิ่งที่เราทำ
ฉันจะมีคลาสและคลาสนี้จะมีฟังก์ชัน init
เราจะมีตัวตน ครั้งแรกและครั้งสุดท้าย
นี่คือช่วงที่เราพูดได้ เริ่มต้นด้วยสิ่งนี้และสิ้นสุดด้วยสิ่งนี้
และในนี้เราจะทำจุดตัวเองทั่วไปก่อน
เท่ากับครั้งแรก
แล้ว self dott สุดท้ายเท่ากับสุดท้าย
และฉันกำลังใช้ชั้นเรียนที่นี่ เพราะจำไว้ว่าเรากำลังสร้างประเภทข้อมูลของเราเอง ซึ่งเป็นช่วงพิเศษของเราเองใน
Python
ตอนนี้เรามีตัวสร้างตัวอย่างแล้ว และในอุดมคติแล้ว เราต้องการบอกว่า gen เท่ากับ และสร้างอินสแตนซ์
gen ของฉันให้ได้ สมมุติว่า 0 ถึง 100 เหมือนกับที่เราทำกับช่วง
และตามหลักการแล้วเราสามารถพูดได้สำหรับ AI และ Gen
และพิมพ์
ฉันเพราะฉันหมายถึงนั่นคือวิธีที่เราสามารถใช้ช่วงได้ใช่ไหม
แล้วฉันจะทำงานนี้ได้อย่างไร?
เราสามารถใช้วิธีการโง่เขลาของเราได้
ดังนั้นจงจำไว้ว่าเรามีอีเทอร์อย่างไร
เพื่อรับตัววนซ้ำและใช้งานต่อไป
เรามีคำจำกัดความที่เป็นตัวปล่อยและตัวปล่อยช่วยให้เราสามารถสร้างได้
เหมาะแก่การเพาะปลูก
ในกรณีของเรา ฉันจะบอกตัวเอง และที่นี่ ฉันจะคืนคลาสจริงแบบนี้
และสุดท้าย เราต้องการเรียกใช้ฟังก์ชันถัดไปบน Jen ของเรา เพราะเราเห็นว่าสี่ลูปทำงานอย่างไร
เราจำเป็นต้องสามารถใช้ itor และ M&M ต่อไปได้
อีกครั้งหนึ่ง เราสามารถใช้วิธี dunder ซึ่งเรียกว่าสะดวก
ต่อไป.
และสิ่งนี้ถูกสร้างขึ้นใน Python
ดังนั้นถ้าฉันทำที่นี่ด้วยตัวเอง
และสิ่งที่เราต้องการทำที่นี่คือบอกให้รู้ว่าเราต้องการทำงานต่อไปอย่างไร
ฉันจะบอกว่าถ้า
และเราต้องการสถานะหรือข้อมูลบางอย่างเพื่อติดตามว่าเราอยู่ที่ไหน
จำไว้ว่าเครื่องกำเนิดไฟฟ้าทำงานอย่างไร
จำไว้ว่าพวกเขาอยู่ที่ไหน
เราสามารถสร้างแอตทริบิวต์ class object ได้
ผมจึงบอกได้ว่ากระแสเท่ากับศูนย์
นี่คือจุดที่เรากำลังทำซ้ำและบอกว่า gen dot ปัจจุบันของฉัน
ตราบใดที่มีค่าน้อยกว่า self dot ซึ่งจะเป็น 100 ตรงนี้
หากเป็นกรณีนี้
ฉันต้องการตัวเลขเท่ากับเจนดอทปัจจุบันของฉัน
ฉันต้องการเพิ่ม gen dot ปัจจุบันของฉันทีละหนึ่งเพราะเราต้องการบอกว่า เฮ้ เรากำลังย้ายขึ้นไปยังตำแหน่งถัดไปแล้วกลับมา
จำนวน.
เพราะนั่นคือวิธีการทำงานต่อไปภายใต้ประทุนใช่ไหม?
เราเพิ่มตำแหน่งปัจจุบันของเราทีละหนึ่ง และเราก็แค่คืนค่าตัวเลขนั้น ซึ่งก็คือ ในกรณีของเรา
มันจะเป็นศูนย์
และเราต้องการไปต่อ ไปต่อ ไปต่อ
จนกระทั่งปัจจุบันไม่ใหญ่กว่าที่ผ่านมา
ในกรณีนั้น เราจะเพิ่มการหยุดการวนซ้ำเพราะไม่มีอะไรให้ทำซ้ำอีกแล้ว
ลองดูว่ามันใช้งานได้หรือไม่
ฉันจะดำเนินการนี้
และดูว่าทุกอย่างใช้งานได้
ฉันสามารถวนรอบตัวสร้างของฉันและพิมพ์ฉันจากศูนย์ไปจนถึง 99
อีกครั้ง หากเรากลับไปที่ตัวอย่างของเราที่นี่
และฉันรู้ว่ามันยากนิดหน่อยที่จะมองมันในตอนแรก
แต่ทั้งหมดที่ฉันทำคือบอกว่าฉันต้องการให้ฟังก์ชันไอทีมีตัวเลือกเป็นอันดับแรกและสุดท้าย
และฉันต้องการที่จะสามารถทำซ้ำผ่านวัตถุนี้ที่ฉันจะสร้าง
และฉันยังต้องการที่จะใช้ next ซึ่ง for loop ถ้าคุณจำจากตัวอย่างก่อนหน้านี้ ความต้องการ
ดังนั้นฉันจะพูดสี่ข้อในเจน
เพียงแค่วนรอบมัน
ฉันสามารถวนซ้ำได้เพราะตอนนี้เป็นตัววนซ้ำและฉันสามารถใช้ค่าถัดไปกับมันได้เพราะฉันอนุญาตให้เราวนซ้ำและเพิ่มทีละหนึ่งอย่างต่อเนื่อง
จนกว่าเราจะส่งคืนหมายเลข
ให้คืนเบอร์ไปเรื่อยๆ จนกว่า Gen ปัจจุบันจะกลายเป็น 101 ร้อยไม่ต่ำกว่า 100 ซึ่งตัวเองน้อย
ดังนั้นมันจะทำให้เกิดการหยุดวนซ้ำ
for loop จะจับเราโดยอัตโนมัติเพื่อไม่ให้เกิดข้อผิดพลาดและหยุดการวนซ้ำ
นั่นคือวิธีการทำงานภายใต้ประทุนด้วยระยะ
ตอนนี้คุณไม่จำเป็นต้องรู้เรื่องนี้
คุณจะไม่ถูกขอให้ดำเนินการนี้ในแต่ละวัน
แต่ฉันต้องการแสดงให้คุณเห็นว่านี่คือสิ่งที่ทำงาน
ฉันคิดว่ามันสำคัญ