‫ถึงจุดนี้ เราได้เรียนรู้เกี่ยวกับวิธีการจัดระเบียบโค้ด Python ของเราสองสามวิธี
‫อย่างแรกที่เราทำได้ดีคือเราแค่เขียน Python ลงในไฟล์และจัดระเบียบใช่ไหม
‫รหัสทั้งหมดของเราอยู่ในไฟล์เดียว
‫นั่นเป็นวิธีหนึ่งที่เราจัดระเบียบโค้ดของเรา
‫ต่อไปเราเรียนรู้เกี่ยวกับฟังก์ชันและฟังก์ชันต่างๆ ถูกใช้เพื่อให้เราไม่เขียนโค้ดซ้ำแล้วซ้ำอีก
‫เราสามารถเขียนฟังก์ชันที่เราสามารถใช้ได้ทุกที่ที่เราต้องการในไฟล์ของเรา เพื่อให้เราสามารถเรียกใช้ฟังก์ชันเหล่านี้ซ้ำแล้วซ้ำอีก
‫และเราสามารถตั้งชื่อฟังก์ชันต่างๆ ได้อย่างเหมาะสม เพื่อให้โค้ดของเรามีความสมเหตุสมผล จัดทำแพ็กเกจไว้อย่างดีเพื่อให้เราใช้
‫สิ่งเหล่านี้มีไว้เพื่อให้โค้ดของเราสะอาด ทำให้โค้ดของเรามีการบำรุงรักษามากขึ้น ทำให้โค้ดของเรามีระเบียบ
‫เพราะเมื่อเราเขียนโค้ดหลายบรรทัดมากขึ้น การเก็บทุกอย่างไว้ในหัวก็ยิ่งยากขึ้นเรื่อยๆ
‫หากมีคนอื่นเข้าร่วมทีมของคุณเพื่อทำงานในโครงการของคุณ พวกเขาต้องการวิธีง่ายๆ ในการค้นหาว่าสิ่งต่างๆ เป็นอย่างไร
‫แต่เรายังคงมีปัญหาอยู่ และปัญหานั้นก็คือทุกอย่างมีอยู่ในไฟล์เดียว
‫ฟังก์ชันทั้งหมดที่เราเคยเขียนมานั้นอยู่ในไฟล์ dot pi เพียงไฟล์เดียว
‫แต่ในชีวิตจริงไม่เป็นเช่นนั้น
‫เรามีโค้ดอีกมาก และเราไม่สามารถมีไฟล์เดียวที่มีโค้ดหลายล้านบรรทัดได้
‫แล้วเราจะจัดระเบียบได้อย่างไร?
‫ดี.
‫ถ้าเรามีไฟล์ Python หลายไฟล์
‫เช่นนี้เพราะโครงการของเรากำลังขยายใหญ่ขึ้นเรื่อยๆ
‫นี้จะทำงาน?
‫มีวิธีที่เราจะเชื่อมโยงไฟล์เหล่านี้ทั้งหมดเข้าด้วยกันหรือไม่?
‫ตามจริงแล้ว มีและนี่เป็นแนวทางปฏิบัติทั่วไปทั่วทั้งอุตสาหกรรม และเราเรียกวิธีนี้ว่าการจัดระเบียบโมดูลโค้ด
‫และโมดูลก็ง่ายๆ ก็คือ ไฟล์เหล่านี้
‫แต่ละไฟล์เหล่านี้ แต่ละไฟล์ dot pi เป็นโมดูล
‫และโดยการสร้างโมดูลเหล่านี้ แบบที่เราสร้างฟังก์ชันต่างๆ แบบที่เราสร้างคลาสต่างๆ
‫เพราะภายในไฟล์เหล่านี้ เราสามารถมีคลาสได้ เราสามารถมีฟังก์ชันได้ แต่เราก็มีไฟล์ต่างกันได้เช่นกัน
‫ดังนั้นชั้นที่สูงขึ้นเพื่อแบ่งรหัสของเรา
‫และในส่วนนี้ เราจะเรียนรู้ทั้งหมดเกี่ยวกับโมดูล และพยายามทำให้เชี่ยวชาญ และดูว่าเราจะเขียนโค้ดที่จัดระเบียบได้อย่างไร
‫มาดูกันเลย
‫คุณสามารถดูได้ที่นี่ ถ้าฉันคลิกที่ไฟล์ใน Ripple เรามี pi หลัก และทุกครั้งที่ฉันคลิก Run
‫ไฟล์นี้จะถูกเรียกใช้
‫แต่ถ้าเรามีไฟล์มากกว่านี้ล่ะ?
‫จะเกิดอะไรขึ้นถ้าฉันเพิ่มไฟล์อื่นที่นี่และเราจะเรียกว่า Utility Dot Pi
‫จากสิ่งที่ฉันเพิ่งสอนคุณไป สองสิ่งนี้คืออะไร?
‫มันคือโมดูลใช่ไหม
‫Main Pi เป็นยูทิลิตี้โมดูล
‫PI เป็นโมดูล
‫และเมื่อเขียนโมดูลเราใช้หลักการเดียวกันกับตัวแปรใน Python ซึ่งเป็นตัวพิมพ์ใหญ่
‫นั่นคือ ถ้ามีช่องว่างที่เราใช้ขีดล่าง ทุกอย่างเป็นอักษรตัวพิมพ์เล็ก
‫แล้วเราจะแบ่งโมดูลเหล่านี้อย่างไร?
‫และสิ่งนี้มาพร้อมกับการฝึกฝน
‫เมื่อคุณเพิ่งเริ่มต้น มันยากที่จะพูดว่า เฮ้ อะไรเข้าไฟล์อะไร อะไรเข้าไฟล์อะไร
‫แต่มันเหมือนกับคลาสใช่ไหม?
‫คล้ายกับฟังก์ชั่น
‫เราต้องการแบ่งโค้ดของเราเป็นส่วนๆ ที่สมเหตุสมผล
‫อีกครั้ง สมมติว่าเรากำลังทำงานที่ Netflix
‫เราอาจมีไฟล์สำหรับวิดีโอโดยเฉพาะ เราอาจมีไฟล์หรือโมดูลอื่นที่มีไว้สำหรับการเข้าสู่ระบบของผู้ใช้โดยเฉพาะ
‫อาจมีไฟล์อื่นสำหรับการวิเคราะห์และค้นหาคำแนะนำสำหรับผู้ใช้
‫เราต้องการจัดกลุ่มคลาสและฟังก์ชันเหล่านี้ไว้ด้วยกันภายในไฟล์ที่เหมาะสม
‫วิธีหนึ่งที่ใช้บ่อยที่สุดในการใช้โมดูลคือบางอย่างเช่นยูทิลิตี้
‫สมมติว่าเราต้องการสร้างโมดูลยูทิลิตี้ที่เป็นโมดูลที่มีจำนวนมาก เช่น แถบเครื่องมือ ฟังก์ชันง่ายๆ
‫ที่เราสามารถใช้ได้ทั่วทั้งโปรเจ็กต์ของเรา เพราะเราสามารถจินตนาการได้ว่ามีไฟล์หลายไฟล์ที่นี่
‫เรามาสร้างตัวอย่างง่ายๆ กัน
‫ฉันจะบอกว่ามีฟังก์ชันการคูณอยู่ที่นี่
‫และสิ่งนี้ทำให้มึนงงและมึนงง
‫และในนี้เราจะคืนค่า num คูณ num เป็นฟังก์ชันที่ง่ายมาก
‫และอีกครั้ง เราจะมีฟังก์ชันหารด้วย
‫และใช่ มันไม่มีประโยชน์อะไรเพราะเราสามารถใช้เครื่องหมายบวกหรือตัวถูกดำเนินการหารใน Python ได้
‫แต่อยู่กับฉันที่นี่
‫ฉันกำลังพยายามแสดงตัวอย่างให้คุณดู
‫ไม่เป็นไร.
‫ข้อสอง ผมจะคืนค่า เลขหนึ่ง หารด้วย เลขสอง
‫ดีและเรียบง่าย
‫อย่างนี้.
‫เป็นโมดูลยูทิลิตี้ของเราที่มีฟังก์ชั่นเหล่านี้ทั้งหมดสำหรับเรา
‫ตอนนี้สังเกตว่าเราไม่ได้ทำอะไรในไฟล์นี้จริงๆ
‫ฉันแค่กำหนดฟังก์ชัน แต่ฉันไม่ได้ใช้งานฟังก์ชันใดๆ
‫แต่สมมุติว่าเรามีโมดูลยูทิลิตี้นี้ และฉันต้องการใช้ในไฟล์ py หลักของฉัน
‫เราจะทำสิ่งนี้ได้อย่างไร?
‫วิธีที่เราสื่อสารระหว่างสองไฟล์นี้ค่อนข้างง่าย
‫สิ่งที่เราต้องทำคือใช้คำสั่งนำเข้าที่เรานำเข้า จากนั้นตั้งชื่อไฟล์ที่เราต้องการนำเข้า
‫เราต้องการนำเข้าอะไร
‫เราต้องการนำเข้ายูทิลิตี้แบบนั้น
‫และสังเกตว่าฉันไม่ได้เพิ่ม dot py เพราะเราคิดว่าสิ่งที่เราจะนำเข้าจะเป็นไฟล์หลาม
‫ดังนั้นเราจึงไม่จำเป็นต้องทำอย่างนั้น
‫แค่ชื่อ.
‫เป็นแบบนั้น.
‫ทีนี้มาพิมพ์ยูทิลิตี้กันที่นี่
‫ถ้าฉันเรียกใช้สิ่งนี้
‫โว้ว.
‫คุณเห็นไหม
‫เรามีโมดูลยูทิลิตี้จากนั้นนี่คือเส้นทางของไฟล์ที่เว็บไซต์นี้สร้างขึ้นสำหรับเรา ดังนั้นจึงไม่สำคัญ
‫ทีนี้ มีบางสิ่งที่เกิดขึ้นที่นี่
‫หนึ่งคือเราสร้างโฟลเดอร์เงินสด py นี้
‫ขีดเส้นใต้
‫พี เงินสด
‫และ.
‫โอ้เด็กนี่พูดพล่อย ๆ อะไร?
‫อืม.
‫นี่มันค่อนข้างสับสนใช่มั้ย?
‫แคชพายนี้ถูกสร้างขึ้นทุกครั้งที่เราเรียกใช้ไฟล์ สมมติว่านำเข้าคำสั่ง
‫เมื่อเราใช้โมดูล
‫คุณเห็นไหมว่า Pi Cash ทำอะไรเมื่อเราคลิกเรียกใช้
‫ล่ามกำลังจะสร้างโฟลเดอร์พอดคาสต์นี้ และจะบอกว่า เฮ้ ฉันกำลังเรียกใช้ไฟล์นี้
‫ไฟล์ pi หลักนี้ อะไรก็ตามที่อาจไม่ใช่การนำเข้าไฟล์ py สมมติว่ามีประโยชน์
‫ในกรณีของเราฉันจะจ่ายเงิน
‫ดูว่าที่นี่เขียนว่าดอทไพอย่างไร
‫ดูสิ นี่เป็นเพราะมันใช้ล่ามภาษา C Python
‫จำไว้ว่านี่คือ C python ซึ่งเป็นล่ามที่เขียนและ C ดังนั้นนี่คือไฟล์ที่คอมไพล์แล้ว
‫ครั้งต่อไปที่ฉันคลิก เรียกใช้ที่นี่บน pi หลักของฉัน ไม่มีอะไรเปลี่ยนแปลงเพราะสิ่งที่จะเกิดขึ้นคือแทนที่จะโหลดยูทิลิตี้
‫pi มันจะโหลดยูทิลิตี้เวอร์ชันที่คอมไพล์แล้วนี้เพราะไม่มีอะไรเปลี่ยนแปลง
‫และยูทิลิตี้ปี่
‫และทำให้สิ่งต่างๆ เร็วขึ้น
‫เมื่อฉันพยายามเรียกใช้ Main Pi อีกครั้ง นั่นคือการแคช
‫การแคชคือ เฮ้ ฉันจะจำสิ่งนี้ไว้ และนี่คือเวอร์ชันคอมไพล์ ดังนั้นฉันไม่ต้องทำตามขั้นตอนการรวบรวมอีก
‫แต่สังเกตว่าไฟล์ pi หลักไม่ได้รับการคอมไพล์เพราะเรารันมันทุกครั้ง
‫ทีนี้ ถ้าเราเปลี่ยนฟังก์ชันยูทิลิตี้ให้ไม่มีการแบ่งในนั้น ฉันคลิก run และคุณไม่สังเกตเห็นที่นี่
‫แต่ตอนนี้มีการเรียกใช้ซ้ำแล้วเนื่องจากเรามีไฟล์อื่น
‫คุณจะเห็นว่าเราคูณตรงนี้แต่ไม่หาร.
‫เลยเอามาแบ่งกันใหม่
‫กลับไปที่นี่ คลิกเรียกใช้
‫และที่นั่นคุณไป
‫เราได้แบ่งที่นี่เช่นกันตอนนี้
‫แต่นี่คือสิ่งที่เราไม่ได้สัมผัส
‫นี่แค่อยู่ใต้ประทุนกับโปรแกรมแก้ไขที่เราใช้
‫และในวิดีโอบางส่วน เราจะแสดงให้คุณเห็นว่าสิ่งนี้เกิดขึ้นเมื่อเราใช้บางอย่าง เช่น แผนภูมิวงกลม
‫นี่เป็นเพียงสิ่งที่บรรณาธิการอนุญาตให้เราทำเพื่อให้โปรแกรมของเราทำงานได้เร็วขึ้น
‫ดังนั้นตอนนี้ฉันสามารถเข้าถึงได้
‫มาทำให้มันเล็กลงหน่อย
‫ตอนนี้ฉันสามารถเข้าถึงยูทิลิตี้ได้แล้ว
‫และนี่คือส่วนที่น่าสนใจ
‫ถ้าผมดอทตรงนี้, ดูนั่นสิ
‫ฉันมีสิทธิ์เข้าถึงการหารและคูณเพื่อที่ฉันจะได้คูณตัวเลขได้
‫สมมติว่าสองและสามคลิกเรียกใช้
‫และฉันสามารถใช้โมดูลยูทิลิตี้ในไฟล์หลักของฉันได้
‫เยี่ยมมาก
‫ถ้าฉันหารแล้วคลิกเรียกใช้
‫ฉันสามารถใช้สิ่งนี้ได้เช่นกัน
‫เยี่ยมมาก
‫และฉันสามารถนำเข้าได้หลายครั้งเท่าที่ต้องการ หากฉันมีไฟล์อื่นที่นี่ และฉันต้องการนำเข้าสิ่งอื่น
‫สมมติว่ามีโปรแกรมอรรถประโยชน์ในการจัดเก็บ
‫ฉันสามารถนำเข้าและนำเข้าสิ่งต่างๆ ได้มากเท่าที่ต้องการ และใช้ในไฟล์ต่างๆ ของฉัน
‫มันเจ๋งแค่ไหน?
‫ตอนนี้เรามีวิธีจัดระเบียบโค้ดของเราและให้ไฟล์เหล่านี้สื่อสารกัน
‫เพราะในชีวิตจริง เรามีโปรเจ็กต์ใหญ่ๆ และโปรเจ็กต์ใหญ่ๆ เหล่านี้จะต้องทำงานโดยทีมต่างๆ โปรแกรมเมอร์ที่แตกต่างกัน
‫และเราต้องการวิธีการทำงานกับไฟล์เหล่านี้ทั้งหมด
‫และด้วยการใช้คำสั่งนำเข้าระหว่างโมดูล เราจึงสามารถใช้ฟังก์ชันต่างๆ ได้ เช่นเดียวกับที่เราสามารถใช้ฟังก์ชันการทำงานที่จัดเตรียมไว้ให้เราระหว่างไฟล์ต่างๆ
‫และโดยส่วนใหญ่ หากคุณทำงานที่บริษัท สองสามบรรทัดแรกในไฟล์ dot pi มักจะเป็นคำสั่งนำเข้า
‫เนื่องจากโดยปกติแล้วคุณกำลังสื่อสารกับไฟล์อื่นๆ
‫มาเรียนรู้เพิ่มเติมในวิดีโอหน้ากัน