Fino a questo punto, abbiamo appreso alcuni modi per organizzare il nostro codice Python.
La prima cosa che abbiamo fatto bene, abbiamo semplicemente scritto Python in un file e questo lo organizza.
Destra?
Il nostro intero codice è stato finora su un unico file.
Quindi questo era un modo in cui abbiamo organizzato il nostro codice.
Successivamente, abbiamo appreso che le funzioni e le funzioni sono state utilizzate come un modo per noi di non scrivere codice che
ripetiamo più e più volte, potremmo scrivere funzioni che possiamo usare ovunque vogliamo nel nostro file in modo da poter chiamare
queste funzioni più e più volte e possiamo nominare le funzioni in modo appropriato in modo che il nostro codice
abbia senso.
E poi abbiamo imparato a conoscere le classi, a scrivere questi progetti da cui possiamo creare oggetti.
Possiamo creare un'istanza di nuovi tipi di dati Python oltre a quelli che ci hanno appena fornito.
Destra.
Invece di avere solo dizionari ed elenchi, possiamo creare il nostro personalizzato una volta che i nostri elenchi potrebbero
avere funzionalità extra.
E siamo in grado di usare le classi per organizzare il nostro codice per imballarli e dare a ogni classe un certo
metodo e attributo che lo impacchetta bene per noi da usare.
Abbiamo anche imparato a conoscere la programmazione funzionale e come, a differenza, diciamo, della
programmazione orientata agli oggetti, dove vediamo molte classi con programmazione funzionale, usiamo solo molte funzioni,
molte funzioni pure.
E abbiamo dati che abbiamo appena passato a quelle funzioni e organizziamo le cose in piccoli pezzi.
Tutte queste cose avevano lo scopo di mantenere il nostro codice pulito, rendere il nostro codice più gestibile, mantenendo così
il nostro codice organizzato, perché man mano che scriviamo più righe di codice, diventa sempre più difficile mantenere tutto nella
tua testa.
Se altre persone si uniscono al tuo team per lavorare al tuo progetto, hanno bisogno di un modo semplice per capire come funzionano le
cose.
Ma abbiamo ancora un problema, e quel problema è che tutto è contenuto in questo unico file, tutte le funzioni, tutte
le classi che abbiamo scritto sono state su un solo file dot pi.
Ma nella vita reale, questo non è il caso.
Abbiamo molto più codice e non possiamo avere solo un file con milioni di righe di codice.
Allora, come ci manteniamo organizzati?
Bene.
Se avessimo più file di Python.
Così, perché il nostro progetto sta diventando sempre più grande.
Funzionerebbe?
C'è un modo per collegare tutti questi file insieme?
In effetti, esiste ed è una pratica molto comune in tutto il settore e chiamiamo questo
modo di organizzare moduli di codice.
E i moduli sono semplicemente, beh, questi file, ognuno di questi file, ogni file punto py è un modulo.
E costruendo questi moduli, un po' come abbiamo costruito funzioni diverse, un po' come abbiamo costruito
classi diverse, perché all'interno di questi file possiamo avere classi, possiamo avere funzioni, ma possiamo anche avere
file diversi.
Quindi uno strato più in alto per dividere il nostro codice.
E in questa sezione, impareremo tutto sui moduli e proveremo a padroneggiarli e vedremo come
possiamo scrivere codice organizzato.
Diamo un'occhiata, puoi vedere qui, se clicco su philes nel nostro Reppel, abbiamo un DCPI principale e
ogni volta che clicco su corri questo autunno, corro.
Ma cosa succede se abbiamo più file?
Cosa succede se aggiungo un altro file qui e lo chiameremo utility dot pi?
Quindi, in base a ciò che ti ho appena detto, queste due cose sono giuste per il modulo, il DCPI principale è
un'utilità del modulo.
Tappy è un modulo.
E quando scriviamo moduli, usiamo gli stessi principi delle variabili in Python, che è snake case,
cioè, se sono spazi usiamo underscore tutto è lettera minuscola.
Quindi, come dividiamo questi moduli e questo arriva con la pratica quando sei solo all'inizio, è difficile dire, ehi,
cosa succede in cosa?
Cosa va in quale file?
Ma è simile alle classi, giusto?
Simile alle funzioni.
Vogliamo dividere il nostro codice in blocchi che abbiano un senso.
Di nuovo, diciamo che stiamo lavorando su Netflix.
Potremmo avere un file dedicato ai video.
Potremmo avere un altro file o modulo dedicato all'accesso di un utente, forse un altro file dedicato
all'analisi e alla comprensione dei consigli per gli utenti.
Vogliamo raggruppare queste classi e funzioni all'interno di un file che abbia senso.
Ora, uno dei modi più comuni per utilizzare un modulo è qualcosa come un'utilità.
Diciamo che vogliamo creare un modulo di utilità che è un modulo che ha molte cose simili a una
cintura degli strumenti, funzioni molto semplici che possiamo usare in tutto il nostro progetto perché possiamo immaginare di
avere più file.
Quindi creiamo un esempio molto semplice.
Dirò che qui esiste una funzione di moltiplicazione.
E questo prende un nome uno e un numero due.
E qui, riporteremo semplicemente Namwon Times insensibile a una funzione molto semplice e, ancora una volta, avremo anche
una funzione di divisione.
E sì, questo è inutile perché possiamo semplicemente usare il plus o per dividere l'operando in Python.
Ma resta con me qui e cerca di mostrarti un esempio.
Bene, quindi numero due, restituirò il numero uno, diviso per il numero due, carino e semplice.
Così questo.
È il nostro modello di utilità che ha tutte queste funzioni per noi.
Ora, nota qui che in realtà non stiamo facendo nulla in questo file.
Sto semplicemente definendo le funzioni, ma non eseguo nessuna delle funzioni.
Ma diciamo che abbiamo questo modulo di utilità e voglio usarlo nella mia trappola principale.
Come faremmo per farlo?
Bene, il modo in cui comunichiamo tra questi due file è abbastanza semplice, tutto ciò che dobbiamo fare è
utilizzare il comando import che importiamo e quindi dargli il nome del file che vogliamo importare.
Cosa vogliamo importare?
Vogliamo importare l'utilità proprio così.
E nota che non sto aggiungendo la torta di punti perché presumiamo che qualunque cosa importeremo sarà
un file python.
Quindi non abbiamo bisogno di farlo.
Solo il nome, proprio così.
Ora scriviamo qui l'utilità di stampa.
Se eseguo questo.
Whoa, vedi che abbiamo l'utilità del modulo da e quindi questo è un percorso di file che questo sito Web genera per
noi, quindi non importa.
Ora, ci sono alcune cose che sono successe qui.
Uno è che abbiamo generato questa cartella cache PAE, underscore, underscore, cache PAE.
E oh, ragazzo, cos'è questo incomprensibile?
Hmm, questo è piuttosto confuso, giusto?
Bene, questa torta in contanti viene creata ogni volta che eseguiamo un file con, diciamo, l'approvazione.
Quindi, quando usiamo i moduli.
Vedi, quello che fa Pae Cash è quando clicchiamo, corriamo.
L'interprete creerà questa cartella podcast e dirà, ehi, sto eseguendo questo file.
Questo potrebbe non archiviare nulla che non paghi le importazioni di file, diciamo utility.
Nel nostro caso, lo incasserò.
Quindi guarda come qui dice dot PC.
Questo perché sta usando l'interprete C Python.
Ricorda, questo è C python, che è l'interprete scritto, e C, quindi questo è in realtà un file
compilato in modo che la prossima volta che farò clic su Esegui qui sul mio DCPI principale, non cambierà nulla
perché ciò che accadrà è invece di caricare l'utilità Dopy, caricherà questa versione compilata dell'utilità perché nulla
è cambiato e l'utilità DCPI.
E questo rende le cose più veloci quando ho provato a eseguire di nuovo Maeng Pie.
Ecco cos'è la memorizzazione nella cache.
La memorizzazione nella cache è, ehi, me ne ricorderò, e questa è la versione di
compilazione, quindi non devo ripetere la fase di compilazione.
Ma nota che il file principale non viene compilato perché, beh, lo eseguiamo ogni volta.
Ora, se cambiamo la funzione di utilità per non avere la divisione lì dentro, faccio clic su Esegui e non lo
noti qui.
Ma questo è stato rieseguito ora perché abbiamo un file diverso.
Vedi che qui abbiamo moltiplicare, ma non dividere.
Quindi riportiamo di nuovo la divisione.
Torna qui, clicca, corri.
Ed ecco qua, abbiamo una divisione qui due ora, ma questo è qualcosa che non tocchiamo.
Questo viene appena sotto il cofano con qualsiasi editor che usiamo.
E in alcuni video, ti mostreremo come ciò accade anche quando usi qualcosa come un grafico a
torta.
Questo è solo qualcosa che gli editor ci consentono di fare in modo che i nostri programmi possano essere eseguiti più velocemente.
Quindi ora ho accesso.
Facciamolo un po' più piccolo.
Ora ho accesso all'utilità.
Ed ecco la parte interessante.
Se punto qui, guarda quello.
Ho accesso a dividere e moltiplicare in modo da poter moltiplicare i numeri.
Diciamo due e tre.
Fare clic su Esegui.
E sono in grado di utilizzare il modulo di utilità nel mio file principale, molto, molto bello se divido e faccio clic su Esegui.
Posso usare anche questo.
Molto, molto bello, e posso importare tutte le volte che voglio se avessi un file diverso qui e
voglio importare un'altra cosa, diciamo che c'è un'utilità per archiviare.
Bene, posso importarlo e importare tutte le cose che voglio e usarle nei miei file.
Quant'è fico?
Quindi ora abbiamo un modo per organizzare il nostro codice e far comunicare tutti questi file, perché
nella vita reale abbiamo grandi progetti e questi grandi progetti verranno elaborati da diversi team,
diversi programmatori.
E abbiamo bisogno di un modo per lavorare con tutti questi file.
E utilizzando le istruzioni di importazione tra i moduli, siamo in grado di utilizzare la funzionalità proprio come siamo stati in
grado di utilizzare la funzionalità che le funzioni ci hanno fornito tra file diversi.
E la maggior parte delle volte, se lavori in un'azienda, le prime due righe di un file dot pi
sono solitamente istruzioni di importazione perché di solito stai comunicando con altri file.
Impariamo qualcosa di più nel prossimo video.