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