Introdução

Os módulos Python são arquivos .py que consistem em código Python. Qualquer arquivo Python pode ser referenciado como um módulo.

Alguns módulos estão disponíveis através da Python Standard Library e, portanto, são instalados com a instalação do Python. Outros podem ser instalados com o pip administrador de pacotes do Python. Além disso, você pode criar seus próprios módulos Python, já que os módulos são compostos de arquivos .pydo Python.

Este tutorial irá guiá-lo através da escrita de módulos Python para uso dentro de outros arquivos de programação.

Escrever e Importar Módulos

Escrever um módulo é como escrever qualquer outro arquivo Python. Os módulos podem conter definições de funções, classes e variáveis que podem então ser utilizadas em outros programas Python.

No ambiente de programação local do Python 3 ou no ambiente de programação baseado em servidor , vamos começar criando um arquivo hello.py que mais tarde hello.py para outro arquivo.

Para começar, criaremos uma função que imprime Hello, World! :

Hello.py
 # Define a function def world(): print("Hello, World!")

Se python hello.py o programa na linha de comando com python hello.py nada vai python hello.py uma vez que não disse ao programa para fazer nada.

Vamos criar um segundo arquivo no mesmo diretório chamado main_program.py para que possamos importar o módulo que acabamos de criar e, em seguida, chamar a função. Este arquivo precisa estar no mesmo diretório para que Python saiba onde encontrar o módulo, uma vez que não é um módulo embutido.

Main_program.py
 # Import hello module import hello # Call function hello.world()

Como estamos importando um módulo , precisamos chamar a função fazendo referência ao nome do módulo em notação de ponto.

Em vez disso, poderíamos importar o módulo a from hello import world e chamar a função diretamente como world() . Você pode aprender mais sobre este método lendo como usar a from … importação ao importar módulos .

Agora, podemos executar o programa na linha de comando:

  • Python main_program.py

Quando o fizermos, receberemos o seguinte resultado:

Saída
  Olá Mundo!

Para ver como podemos usar variáveis em um módulo, vamos adicionar uma definição de variável no nosso arquivo hello.py :

Hello.py
 # Define a function def world(): print("Hello, World!") # Define a variable shark = "Sammy"

Em seguida, main_program.py a variável em uma função print() dentro do nosso arquivo main_program.py :

Main_program.py
 # Import hello module import hello # Call function hello.world() # Print variable print(hello.shark)

Assim que rodarmos o programa novamente, receberemos a seguinte saída:

Saída
  Olá Mundo!
 Sammy

hello.py , vamos também definir uma classe no arquivo hello.py . Criaremos a classe Octopus com atributos de name e color e uma função que imprimirá os atributos quando chamados.

Hello.py
 # Define a function def world(): print("Hello, World!") # Define a variable shark = "Sammy" # Define a class class Octopus: def __init__(self, name, color): self.color = color self.name = name def tell_me_about_the_octopus(self): print("This octopus is " + self.color + ".") print(self.name + " is the octopus's name.")

Agora vamos main_program.py a classe ao final de nosso arquivo main_program.py :

Main_program.py
 # Import hello module import hello # Call function hello.world() # Print variable print(hello.shark) # Call class jesse = hello.Octopus("Jesse", "orange") jesse.tell_me_about_the_octopus()

Depois de hello.Octopus() classe Octopus com hello.Octopus() , podemos acessar as funções e atributos da classe dentro do main_program.py arquivo main_program.py. Isso nos permite escrever jesse.tell_me_about_the_octopus() na última linha sem invocar hello . Poderíamos, por exemplo, chamar um dos atributos da classe, como jesse.color sem fazer referência ao nome do módulo hello .

Quando executamos o programa, receberemos o seguinte resultado:

Saída
  Olá Mundo!
 Sammy
 Este polvo é laranja.
 Jesse é o nome do polvo.

É importante ter em mente que embora os módulos sejam frequentemente definições, eles também podem implementar código. Para ver como isso funciona, vamos hello.py nosso arquivo hello.py para que ele implemente a função world() :

Hello.py
 # Define a function def world(): print("Hello, World!") # Call function within module world()

Também apagamos as outras definições no arquivo.

Agora, no nosso arquivo main_program.py , main_program.py todas as linhas, exceto a instrução import:

Main_program.py
 # Import hello module import hello

Quando main_program.py , receberemos o seguinte resultado:

Saída
  Olá Mundo!

Isso ocorre porque o módulo hello implementou a função world() , que é passada para main_program.py e é main_program.py quando o main_program.py é main_program.py .

Um módulo é um arquivo de programa Python composto de definições ou código que você pode aproveitar em outros arquivos de programa Python.

Acessando Módulos de Outro Diretório

Os módulos podem ser úteis para mais de um projeto de programação e, nesse caso, faz menos sentido manter um módulo em um diretório específico que está vinculado a um projeto específico.

Se você quiser usar um módulo Python de um local diferente do mesmo diretório onde seu programa principal é, você tem algumas opções.

Adicionando caminhos

Uma opção é invocar o caminho do módulo através dos arquivos de programação que usam esse módulo. Isso deve ser considerado mais uma solução temporária que pode ser feita durante o processo de desenvolvimento, uma vez que não torna o módulo disponível em todo o sistema.

Para anexar o caminho de um módulo a outro arquivo de programação, você começará importando o módulo sys juntamente com outros módulos que deseja usar no arquivo de programa principal.

O módulo sys faz parte da Biblioteca Padrão do Python e fornece parâmetros e funções específicos do sistema que você pode usar em seu programa para definir o caminho do módulo que deseja implementar.

Por exemplo, digamos que movemos o arquivo hello.py e ele está agora no caminho /usr/ sammy /enquanto o arquivo main_program.py está em outro diretório.

No arquivo main_program.py , ainda podemos importar o módulo hello importando o módulo sys e adicionando /usr/ sammy / ao caminho que o Python verifica para arquivos.

Main_program.py
 import sys sys.path.append('/usr/sammy/') import hello ...

Contanto que você definir corretamente o caminho para o hello.py arquivo, você será capaz de executar o arquivo main_program.py sem erros e receber a mesma saída como acima quando hello.pyestava no mesmo diretório.

Adicionando o Módulo ao Caminho do Python

Uma segunda opção que você tem é adicionar o módulo ao caminho onde Python verifica os módulos e pacotes. Esta é uma solução mais permanente que torna o módulo disponível em todo o ambiente ou em todo o sistema, tornando este método mais portátil.

Para descobrir o caminho que o Python verifica, execute o interpretador Python do seu ambiente de programação:

  • Python

Em seguida, importe o módulo sys :

  • Sistema de importação

Em seguida, faça com que o Python imprima o caminho do sistema:

  • Print (sys.path)

Aqui, você receberá alguma saída com pelo menos um caminho do sistema. Se você estiver em um ambiente de programação, você pode receber vários. Você vai querer olhar para o que está no ambiente que você está usando atualmente, mas você também pode querer adicionar o módulo para o seu caminho do sistema principal Python. O que você está procurando será semelhante a este:

Saída
  '/ Usr / sammy / my_env /lib/python3.5/site-packages'

Agora você pode mover seu arquivo hello.py para esse diretório. Assim que estiver completo, você pode importar o módulo hello como de costume:

Main_program.py
 import hello ...

Quando você executa o programa, ele deve ser concluído sem erros.

Modificar o caminho do seu módulo pode garantir que você pode acessar o módulo, independentemente do diretório que você está dentro Isso é útil especialmente se você tiver mais de um projeto referenciando um determinado módulo.

Conclusão

Escrever um módulo Python é o mesmo que escrever qualquer outro arquivo Python .py . Este tutorial cobriu como escrever definições dentro de um módulo, fazer uso dessas definições dentro de outro arquivo de programação Python, e passou por cima de opções de onde manter o módulo para acessá-lo.

Anúncios