Até este ponto, aprendemos algumas maneiras de organizar nosso código Python.
A primeira coisa que fizemos bem, apenas escrevemos Python em um arquivo e isso o organiza.
Direito?
Nosso código inteiro está até agora em um único arquivo.
Essa foi uma forma de organizar nosso código.
Em seguida, aprendemos que funções e funções eram usadas como uma maneira de não escrevermos códigos que repetimos
continuamente, poderíamos escrever funções que podemos usar em qualquer lugar que quisermos em nosso arquivo para que
possamos chamar essas funções continuamente e podemos nomear as funções apropriadamente para que nosso código faça
sentido.
E então aprendemos sobre classes, escreva esses projetos a partir dos quais podemos criar objetos.
Podemos instanciar novos tipos de dados Python além daqueles que eles acabaram de nos fornecer.
Direito.
Em vez de apenas ter dicionários e listas, podemos criar nosso próprio costume, uma vez que nossas próprias listas podem
ter recursos extras.
E somos capazes de usar classes para organizar nosso código para encaixá-los e dar a cada classe um determinado método
e atributo que os empacota muito bem para nós usarmos.
Também aprendemos sobre programação funcional e como, ao contrário, digamos, da programação orientada
a objetos, onde vemos muitas classes com programação funcional, apenas usamos muitas funções, muitas
funções puras.
E temos dados que acabamos de passar para essas funções e organizamos as coisas em pequenos pedaços.
Todas essas coisas foram feitas para mantermos nosso código limpo, torná-lo mais sustentável, mantendo assim nosso código
organizado, porque à medida que escrevemos mais linhas de código, fica cada vez mais difícil manter tudo em
sua cabeça.
Se outras pessoas se juntam à sua equipe para trabalhar no seu projeto, elas precisam de uma maneira fácil de descobrir como as coisas
estão funcionando.
Mas ainda temos um problema, e esse problema é que tudo está contido neste único arquivo, todas as funções, todas
as classes que temos escrito estão em apenas um arquivo dot pi.
Mas na vida real, esse não é o caso.
Temos muito mais código e não podemos ter apenas um arquivo com milhões de linhas de código.
Então, como nos mantemos organizados?
Nós vamos.
Se tivéssemos vários arquivos do Python.
Assim, porque nosso projeto está cada vez maior.
Isso funcionaria?
Existe uma maneira de vincularmos todos esses arquivos juntos?
Na verdade, existe e é uma prática muito comum em toda a indústria, e chamamos essa
forma de organizar módulos de código.
E os módulos são simplesmente, bem, esses arquivos, cada um desses arquivos, cada arquivo dot py é um módulo.
E ao construir esses módulos, meio que construímos funções diferentes, meio que construímos classes
diferentes, porque dentro desses arquivos podemos ter classes, podemos ter funções, mas também podemos ter
arquivos diferentes.
Então, uma camada mais alta para dividir nosso código.
E nesta seção, vamos aprender tudo sobre os módulos e tentar dominá-los e ver como
podemos escrever código organizado.
Vamos dar uma olhada, você pode ver aqui, se eu clicar em philes em nosso Reppel, temos um DCPI principal e
toda vez que clico em run neste outono, eu corro.
Mas e se tivermos mais arquivos?
E se eu adicionar outro arquivo aqui e chamá-lo de utilitário dot pi?
Portanto, com base no que acabei de dizer, essas duas coisas são o correto do módulo, o DCPI principal é um
utilitário de módulo.
Tappy é um módulo.
E ao escrever módulos, usamos os mesmos princípios das variáveis em Python, que é o caso da cobra,
ou seja, se forem espaços usamos sublinhado, tudo é letra minúscula.
Então, como dividimos esses módulos e isso vem com a prática, quando você está apenas começando, é difícil dizer, ei, o que
se passa em quê?
O que entra em qual arquivo?
Mas é parecido com as aulas, certo?
Semelhante a funções.
Queremos dividir nosso código em partes que façam sentido.
Novamente, digamos que estejamos trabalhando na Netflix.
Podemos ter um arquivo dedicado aos vídeos.
Podemos ter outro arquivo ou módulo dedicado ao login de um usuário, talvez outro arquivo
dedicado a análises e descobrir recomendações para usuários.
Queremos agrupar essas classes e funções dentro de um arquivo que faça sentido.
Agora, uma das maneiras mais comuns de usar um módulo é algo como um utilitário.
Digamos que queremos criar um módulo de utilitário que seja um módulo que tem muito de como um cinto
de ferramentas, funções muito simples que podemos usar em todo o nosso projeto, porque podemos imaginar aqui tendo
vários arquivos.
Então, vamos criar um exemplo muito simples.
Vou dizer que existe uma função de multiplicação aqui.
E isso leva um nome e número dois.
E aqui, vamos simplesmente retornar o Namwon Times entorpecido a uma função muito simples e, mais uma vez, também teremos
uma função de divisão.
E sim, isso é meio inútil porque podemos apenas usar o mais ou para dividir o operando em Python.
Mas fique comigo aqui e tente mostrar um exemplo.
Tudo bem, então, número dois, vou retornar o número um, dividido pelo número dois, bonito e simples.
Então, é isso.
É o nosso modelo de utilidade que tem todas essas funções para nós.
Agora, observe aqui que, na verdade, não estamos fazendo nada neste arquivo.
Estou simplesmente definindo funções, mas não estou executando nenhuma das funções.
Mas digamos que temos esse módulo de utilitário e quero usá-lo em minha armadilha principal.
Como faríamos para fazer isso?
Bem, a maneira como nos comunicamos entre esses dois arquivos é bastante simples, tudo o que precisamos fazer é usar o
comando import que importamos e, em seguida, dar a ele o nome do arquivo que queremos importar.
O que queremos importar?
Queremos importar utilitário assim.
E observe que não estou adicionando a torta de pontos porque presumimos que tudo o que vamos importar será
um arquivo python.
Portanto, não precisamos fazer isso.
Apenas o nome, assim mesmo.
Agora vamos imprimir o utilitário aqui.
Se eu executar isso.
Uau, você vê que temos o utilitário de módulo de e este é um caminho de arquivo que este site gera para nós,
então isso realmente não importa.
Agora, algumas coisas aconteceram aqui.
Uma é que geramos essa pasta de cache PAE, sublinhado, sublinhado, cache PAE.
E oh, cara, o que é esse jargão?
Hmm, isso é muito confuso, certo?
Bem, esse dinheiro da torta é criado toda vez que executamos um arquivo com, digamos, endosso.
Então, quando estamos usando o módulo.
Veja, o que Pae Cash faz é quando clicamos e corremos.
O intérprete criará essa pasta de podcast e dirá: ei, estou executando este
arquivo.
Este não pode arquivar nada que não pague as importações de arquivos, digamos utilitário.
No nosso caso, vou descontar.
Então veja como aqui diz dot PC.
Isso ocorre porque ele está usando o interpretador C Python.
Lembre-se, este é o C python, que é o interpretador escrito, e C, então este é na verdade um
arquivo compilado para que da próxima vez que eu clicar em executar aqui no meu DCPI principal, nada mude porque o
que vai acontecer é em vez de carregar o utilitário Dopy, vai carregar esta versão compilada do utilitário porque
nada mudou e o utilitário DCPI.
E isso torna as coisas mais rápidas quando tentei executar o Maeng Pie novamente.
Isso é o cache.
O cache é, ei, vou me lembrar disso, e esta é a versão de compilação,
então não preciso passar pela etapa de compilação novamente.
Mas observe que o arquivo principal não é compilado porque, bem, nós o executamos todas as vezes.
Agora, se mudarmos a função de utilitário para não ter a divisão ali, clico em executar e você não percebe
aqui.
Mas agora isso foi executado novamente porque temos um arquivo diferente.
Você vê que nós multiplicamos aqui, mas não dividimos.
Então, vamos trazer de volta a divisão novamente.
Volte para aqui, clique, corra.
E aí está, nós temos uma divisão aqui dois agora, mas isso é algo que não tocamos.
Isso vem por baixo do capô com qualquer editor que usamos.
E em alguns vídeos, mostraremos como isso também acontece quando você usa algo como um gráfico de
pizza.
Isso é apenas algo que os editores permitem que façamos para que nossos programas sejam executados com mais rapidez.
Portanto, agora tenho acesso.
Vamos tornar isso um pouco menor.
Agora tenho acesso ao utilitário.
E aqui está a parte interessante.
Se eu fizer ponto aqui, olhe para isso.
Eu tenho acesso para dividir e multiplicar para poder multiplicar números.
Digamos dois e três.
Clique em executar.
E eu sou capaz de usar o módulo utilitário no meu arquivo principal, muito, muito legal se eu dividir e clicar em executar.
Eu posso usar isso também.
Muito, muito legal, e posso importar quantas vezes quiser se eu tiver um arquivo diferente aqui e quiser
importar outra coisa, digamos que haja um utilitário para arquivar.
Bem, posso importar isso e importar quantas coisas eu quiser e usá-las em meus arquivos.
Quão legal é isso?
Agora temos uma maneira de organizar nosso código e fazer com que todos esses arquivos se comuniquem, porque
na vida real temos grandes projetos e esses grandes projetos serão trabalhados por diferentes equipes,
diferentes programadores.
E precisamos de uma maneira de trabalhar com todos esses arquivos.
E usando as instruções de importação entre os módulos, podemos usar a funcionalidade da mesma forma que usamos
a funcionalidade que as funções nos forneceram entre os diferentes arquivos.
E na maioria das vezes, se você estiver trabalhando em uma empresa, as primeiras linhas em um arquivo dot pi
geralmente são declarações de importação, porque normalmente você está se comunicando com outros arquivos.
Vamos aprender mais no próximo vídeo.