Hasta este punto, hemos aprendido algunas formas de organizar nuestro código Python.
Lo primero que hicimos bien, simplemente escribimos Python en un archivo y eso lo organiza.
¿Derecha?
Todo nuestro código ha estado hasta ahora en un solo archivo.
Así que esa fue una de las formas en que organizamos nuestro código.
Luego, aprendimos que las funciones y las funciones se usaban como una forma de no escribir código que repetimos una
y otra vez, pudimos escribir funciones que podemos usar en cualquier lugar que queramos en nuestro archivo para poder
llamar a estas funciones una y otra vez. y podemos nombrar las funciones apropiadamente para que nuestro código tenga
sentido.
Y luego aprendimos sobre las clases, escribimos estos planos a partir de los cuales podemos crear objetos.
Podemos crear instancias de nuevos tipos de datos de Python más allá de los que nos acaban de dar.
Derecha.
En lugar de solo tener diccionarios y listas, podemos crear nuestras propias listas, una vez que nuestras propias listas tal
vez tengan características adicionales.
Y podemos usar clases para organizar nuestro código para empaquetarlos y darle a cada clase un cierto método y
atributo que lo empaqueta muy bien para que lo usemos.
También aprendimos sobre programación funcional y cómo, a diferencia de, digamos, la programación orientada
a objetos, donde vemos muchas clases con programación funcional, solo usamos muchas funciones, muchas
funciones puras.
Y tenemos datos que acabamos de pasar a esas funciones y organizamos las cosas en pequeños fragmentos.
Todas estas cosas estaban destinadas a nosotros para mantener nuestro código limpio, hacer que nuestro código sea más fácil de mantener,
y así mantener nuestro código organizado, porque a medida que escribimos más líneas de código, se vuelve cada vez más difícil mantener todo
en la cabeza.
Si otras personas se unen a su equipo para trabajar en su proyecto, necesitan una forma sencilla de averiguar cómo están funcionando las
cosas.
Pero todavía tenemos un problema, y ese problema es que todo está contenido en este archivo, todas las funciones, todas las
clases que hemos estado escribiendo han estado en un solo archivo dot pi.
Pero en la vida real, este no es el caso.
Tenemos mucho más código y no podemos tener un solo archivo con millones de líneas de código.
Entonces, ¿cómo nos mantenemos organizados?
Bien.
Si tuviéramos varios archivos de Python.
Así, porque nuestro proyecto es cada vez más grande.
¿Funcionaría esto?
¿Hay alguna forma de vincular todos estos archivos?
De hecho, existe y es una práctica muy común en toda la industria, y llamamos a esta
forma de organizar módulos de código.
Y los módulos son simplemente, bueno, estos archivos, cada uno de estos archivos, cada archivo dot py es un módulo.
Y al construir estos módulos, como si construyéramos diferentes funciones, como si construyéramos diferentes
clases, porque dentro de estos archivos podemos tener clases, podemos tener funciones, pero también podemos tener
diferentes archivos.
Entonces, una capa más alta para dividir nuestro código.
Y en esta sección, aprenderemos todo sobre los módulos e intentaremos dominarlos y veremos cómo
podemos escribir código organizado.
Echemos un vistazo, pueden ver aquí, si hago clic en philes en nuestro Reppel, tenemos un DCPI principal y
cada vez que hago clic en ejecutar este otoño, corro.
Pero, ¿y si tenemos más archivos?
¿Qué pasa si agrego otro archivo aquí y lo llamamos utilidad dot pi?
Entonces, de acuerdo con lo que les acabo de decir, estas dos cosas son lo correcto para el módulo, el DCPI principal es una
utilidad de módulo.
Tappy es un módulo.
Y cuando escribimos módulos, usamos los mismos principios que las variables en Python, que es el caso de la serpiente, es
decir, si son espacios usamos un guión bajo, todo es una letra minúscula.
Entonces, ¿cómo dividimos estos módulos y esto viene con la práctica cuando recién está comenzando? Es difícil decir, oye,
¿qué hay en qué?
¿Qué entra en qué archivo?
Pero es similar a las clases, ¿verdad?
Similar a funciones.
Queremos dividir nuestro código en partes que tengan sentido.
Nuevamente, digamos que estamos trabajando en Netflix.
Podríamos tener un archivo dedicado a los videos.
Es posible que tengamos otro archivo o módulo dedicado al inicio de sesión de un usuario, tal vez otro archivo dedicado
al análisis y la elaboración de recomendaciones para los usuarios.
Queremos agrupar estas clases y funciones dentro de un archivo que tenga sentido.
Ahora, una de las formas más comunes de usar un módulo es algo así como una utilidad.
Digamos que queremos crear un módulo de utilidad que es un módulo que tiene mucho parecido a un cinturón
de herramientas, funciones muy simples que podemos usar en todo nuestro proyecto porque podemos imaginar que aquí tenemos
varios archivos.
Así que creemos un ejemplo muy simple.
Voy a decir que aquí existe una función de multiplicación.
Y esto lleva un nombre uno y un número dos.
Y aquí, simplemente vamos a devolver Namwon Times adormecido a una función muy simple y, una vez más, también tendremos
una función de división.
Y sí, esto es algo inútil porque podemos usar el operando más o para dividir en Python.
Pero quédate conmigo aquí y trata de mostrarte un ejemplo.
Muy bien, número dos, voy a devolver el número uno, dividido por el número dos, agradable y simple.
Así que esto.
Es nuestro modelo de utilidad el que tiene todas estas funciones para nosotros.
Ahora, observe aquí que en realidad no estamos haciendo nada en este archivo.
Simplemente estoy definiendo funciones, pero no estoy ejecutando ninguna de las funciones.
Pero digamos que tenemos este módulo de utilidad y quiero usarlo en mi principal trampa.
¿Cómo haríamos esto?
Bueno, la forma en que nos comunicamos entre estos dos archivos es bastante simple, todo lo que tenemos que hacer es
usar el comando de importación que importamos y luego darle el nombre del archivo que queremos importar.
¿Qué queremos importar?
Queremos importar utilidades así.
Y observe que no estoy agregando el pastel de puntos porque asumimos que lo que sea que vayamos a importar será
un archivo de Python.
Entonces no necesitamos hacer eso.
Solo el nombre, así como así.
Ahora imprimamos la utilidad aquí.
Si ejecuto esto.
Vaya, ¿ves que tenemos la utilidad de módulo de y luego esta es una ruta de archivo que este sitio web genera para nosotros, por
lo que realmente no importa?
Ahora, hay algunas cosas que sucedieron aquí.
Una es que generamos esta carpeta de caché PAE, subrayado, subrayado, caché PAE.
Y oh, chico, ¿qué es este galimatías?
Hmm, esto es bastante confuso, ¿verdad?
Bueno, este dinero en efectivo se crea cada vez que ejecutamos un archivo con, digamos, endosos.
Entonces, cuando usamos module's.
Verá, lo que hace Pae Cash es cuando hacemos clic, ejecutamos.
El intérprete creará esta carpeta de podcasts y dirá, oye, estoy ejecutando este
archivo.
Este no puede presentar nada que no pague las importaciones de archivos, digamos utilidad.
En nuestro caso, lo voy a cobrar.
Así que mira cómo aquí dice dot PC.
Esto se debe a que utiliza el intérprete de C Python.
Recuerde, este es el Python C, que es el intérprete escrito, y C, por lo que en realidad es un archivo
compilado para que la próxima vez que haga clic en ejecutar aquí en mi DCPI principal, nada cambia porque lo que va a
suceder es en lugar de cargar la utilidad Dopy, va a cargar esta versión compilada de la utilidad porque nada
ha cambiado y la utilidad DCPI.
Y esto acelera las cosas cuando intenté ejecutar Maeng Pie nuevamente.
Eso es lo que es el almacenamiento en caché.
El almacenamiento en caché es, bueno, voy a recordar esto, y esta es la versión de compilación, por lo
que no tengo que volver a pasar por el paso de compilación.
Pero observe que el archivo principal no se compila porque, bueno, lo ejecutamos todo el tiempo.
Ahora, si cambiamos la función de utilidad para que no tenga la división allí, hago clic en ejecutar y no lo
notan aquí.
Pero esto ahora se ha vuelto a ejecutar porque tenemos un archivo diferente.
Ves que aquí hemos multiplicado, pero no dividido.
Así que volvamos a dividir de nuevo.
Vuelve a aquí, haz clic, corre.
Y ahí lo tienes, tenemos una división aquí dos ahora, pero esto es algo que no tocamos.
Esto simplemente viene debajo del capó con cualquier editor que usemos.
Y en algunos videos, le mostraremos cómo esto también sucede cuando usa algo como un gráfico circular.
Esto es algo que los editores nos permiten hacer para que nuestros programas se ejecuten más rápido.
Entonces ahora tengo acceso.
Hagamos esto un poco más pequeño.
Ahora tengo acceso a la utilidad.
Y esta es la parte interesante.
Si le doy un punto aquí, mire eso.
Tengo acceso a dividir y multiplicar para poder multiplicar números.
Digamos dos y tres.
Haga clic en ejecutar.
Y puedo usar el módulo de utilidades en mi archivo principal, muy, muy bueno si divido y hago clic en ejecutar.
Puedo usar esto también.
Muy, muy bueno, y puedo importar tantas veces como quiera si tengo un archivo diferente aquí y quiero
importar otra cosa, digamos que hay una utilidad para archivar.
Bueno, puedo importar eso e importar tantas cosas como quiera y usarlas en mis archivos.
¿Cuan genial es eso?
Así que ahora tenemos una forma de organizar nuestro código y hacer que todos estos archivos se comuniquen juntos,
porque en la vida real tenemos grandes proyectos y estos grandes proyectos serán trabajados por diferentes
equipos, diferentes programadores.
Y necesitamos una forma de trabajar con todos estos archivos.
Y al usar las declaraciones de importación entre módulos, podemos usar la funcionalidad del mismo modo que pudimos
usar la funcionalidad que las funciones nos proporcionaron entre diferentes archivos.
Y la mayoría de las veces, si trabaja en una empresa, las primeras dos líneas de un archivo dot
pi suelen ser declaraciones de importación porque normalmente se está comunicando con otros archivos.
Aprendamos un poco más en el siguiente video.