Módulo de importação em Python com exemplos
Ana Blake
Quais são os módulos em Python?
Um módulo é um arquivo com código python. O código pode estar na forma de variáveis, funções ou classes definidas. O nome do arquivo se torna o nome do módulo.
Por exemplo, se o nome do seu arquivo for guru99.py, o nome do módulo será guru99. Com a funcionalidade do módulo, você pode dividir seu código em arquivos diferentes em vez de escrever tudo dentro de um arquivo.
O que é a sessão Python módulo de importação?
Um arquivo é considerado um módulo em python. Para usar o módulo, você deve importá-lo usando a importação palavra-chave. A função ou variáveis presentes dentro do arquivo podem ser utilizadas em outro arquivo importando o módulo. Esta funcionalidade está disponível em outras linguagens, como TypeScript, JavaScript, Java, Ruby, etc.
Como criar e importar um módulo em Python?
Agora vamos criar um módulo e importá-lo para outro arquivo.
Aqui está o fluxo para criar e importar o módulo conforme mostrado na captura de tela:
Siga as etapas fornecidas para criar um módulo em python.
A estrutura de pastas usada para testar o código é a seguinte:
modtest/ test.py display.py
Passo 1) Crie um arquivo e nomeie-o test.py
Passo 2) Dentro de test.py crie uma função chamada display_message()
Def display_message():
return "Welcome to Guru99 Tutorials!"
Passo 3) Agora crie outro arquivo display.py.
Passo 4) Dentro de display.py importe o arquivo moduletest.py, conforme mostrado abaixo:
import test
Durante a importação, você não precisa mencionar test.py, mas apenas o nome do arquivo.
Passo 5) Então você pode chamar a função display_message() de test.py dentro de display.py, você precisa usar module_name.function_name.
Por exemplo test.display_message().
Import test print(test.display_message())
Passo 6) Ao executar display.py, você obterá o seguinte Saída:
Welcome to Guru99 Tutorials!
Importando uma classe em Python
Anteriormente, vimos um módulo simples com uma função. Aqui irá criar uma classe e referenciá-la dentro de outro arquivo.
A estrutura de pastas para testar o código é a seguinte:
myproj/ Car.py display.py
Crie um arquivo chamado Car.py com o seguinte código:
Nome do arquivo: Car.py
class Car:
brand_name = "BMW"
model = "Z4"
manu_year = "2020"
def __init__(self, brand_name, model, manu_year):
self.brand_name = brand_name
self.model = model
self.manu_year = manu_year
def car_details(self):
print("Car brand is ", self.brand_name)
print("Car model is ", self.model)
print("Car manufacture year is ", self.manu_year)
def get_Car_brand(self):
print("Car brand is ", self.brand_name)
def get_Car_model(self):
print("Car model is ", self.model)
No arquivo Car.py , existem atributos brand_name, model e manu_year. As funções definidas dentro da classe são car_details(), get_Car_brand(), get_Car_model().
Vamos agora usar o arquivo Car.py como módulo em outro arquivo chamado display.py.
Nome do arquivo: display.py
import Car
car_det = Car.Car("BMW","Z5", 2020)
print(car_det.brand_name)
print(car_det.car_details())
print(car_det.get_Car_brand())
print(car_det.get_Car_model())
Saída:
BMW Car brand is BMW Car model is Z5 Car manufacture year is 2020 Car brand is BMW Car model is Z5
Assim podemos acessar todas as variáveis e funções do Car.py usando o módulo Car.
Usando from para importar módulo
Você pode importar apenas uma pequena parte do módulo, ou seja, apenas as funções necessárias e nomes de variáveis do módulo, em vez de importar o código completo.
Quando quiser que apenas coisas específicas sejam importadas, você pode usar a palavra-chave “de” para importar o que deseja.
Então a sintaxe é
from module import your function_name , variables,... etc.
A estrutura de pastas usada para testar o código é a seguinte:
modtest/ test.py display.py
Em test.py existem 2 funções conforme mostrado:
Nome do arquivo: teste.py
defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Agora você deseja a função display_message(). A função ou variável que você está importando pode ser acessada diretamente conforme mostrado abaixo:
Nome do arquivo: display.py
from test import display_message print(display_message())
Saída:
Welcome to Guru99 Tutorials!
Agora, se acontecer de você usar a função display_message1() , ocorrerá um erro informando que a função não está definida conforme mostrado abaixo:
from test import display_message print(display_message1())
Saída:
Traceback (most recent call last): File "display.py", line 3, in <module> print(display_message1()) Name Error: name 'display_message1' is not defined
Importando tudo do módulo
Import permite importar o módulo completo usando import seguido do nome do módulo, ou seja, o nome do arquivo ou da biblioteca a ser usada.
Sintaxe:
Import module
Ou usando
from module import *
A estrutura de pastas usada para testar o código é a seguinte:
modtest/ test.py display.py
A seguir estão os detalhes do código dentro de test.py
my_name = "Guru99" my_address = "Mumbai" defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Usando o módulo de importação
Usando apenas importar o nome do módulo, para se referir às variáveis e funções dentro do módulo, é necessário prefixar o nome do módulo.
Exemplo
Nome do arquivo: display.py
Import test print(test.display_message()) print(test.display_message1()) print(test.my_name) print(test.my_address)
O nome do módulo test é usado para se referir à função e variáveis dentro do módulo test.
Saída:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Usando importação *
Vejamos um exemplo usando importar *. Usando importar *, as funções e variáveis são acessíveis diretamente, conforme mostrado no exemplo abaixo:
from test import * print(display_message()) print(display_message1()) print(my_name) print(my_address)
Saída:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
A função dir()
O dir() é uma função integrada em python. O dir() retorna todas as propriedades e métodos, incluindo as propriedades integradas do objeto fornecido.
Portanto, quando dir() for usado no módulo, ele fornecerá as variáveis, funções que estão presentes dentro do módulo.
Aqui está um exemplo funcional de dir() em um módulo. Temos uma classe chamada Car.py, vamos importar Car e atribuir dir() para ver a saída.
A estrutura de pastas para testar o código será a seguinte:
test prop/ Car.py test.py
Nome do arquivo: Car.py
class Car:
brand_name = "BMW"
model = "Z4"
manu_year = "2020"
def __init__(self, brand_name, model, manu_year):
self.brand_name = brand_name
self.model = model
self.manu_year = manu_year
def car_details(self):
print("Car brand is ", self.brand_name)
print("Car model is ", self.model)
print("Car manufacture year is ", self.manu_year)
def get_Car_brand(self):
print("Car brand is ", self.brand_name)
def get_Car_model(self):
print("Car model is ", self.model)
Nome do arquivo: teste.py
import Car class_contents = dir(Car) print(class_contents)
A saída nos dá o nome da classe e todas as funções definidas em Car.py.
Você também pode tentar usar dir() em um módulo integrado disponível em Python. Vamos tentar o mesmo json módulo conforme mostrado no exemplo abaixo. Ele exibirá todas as propriedades e métodos disponíveis em json módulo.
Import json json_details = dir(json) print(json_details)
Saída:
['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__bu iltins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__pac kage__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_en coder', 'codecs', 'decoder', 'detect_encoding', 'dump', 'dumps', 'encoder', 'loa d', 'loads', 'scanner']
PACOTES
Um pacote é um diretório com todos os módulos definidos dentro dele. Para fazer um Python intérprete tratá-lo como um pacote, seu diretório deverá ter o init.pyfile. O init.py transforma o diretório em um pacote. Aqui está o layout do pacote no qual vamos trabalhar.
O nome do pacote é Meu pacote. Para começar a trabalhar com o pacote, crie um diretório chamado package/. Dentro do diretório, crie um arquivo vazio chamado __init__.py. Crie mais 3 arquivos module1.py, module2.py e module3.py e defina as funções conforme mostrado na captura de tela. Aqui estão os detalhes de module1.py, module2.py e module3.py
módulo1.py
def mod1_func1():
print("Welcome to Module1 function1")
def mod1_func2():
print("Welcome to Module1 function2")
def mod1_func3():
print("Welcome to Module1 function3")
módulo2.py
def mod2_func1():
print("Welcome to Module2 function1")
def mod2_func2():
print("Welcome to Module2 function2")
def mod2_func3():
print("Welcome to Module2 function3")
módulo3.py
def mod3_func1():
print("Welcome to Module3 function1")
def mod3_func2():
print("Welcome to Module3 function2")
def mod3_func3():
print("Welcome to Module3 function3")
O ESB ( pacoteestá pronto para uso. Agora chame o pacote dentro de qualquer arquivo conforme mostrado abaixo: test.py:
Aqui, mypackage.module1 é importado e recebe um nome alternativo como mod1. Da mesma forma, você pode usar outros módulos module2.py e module3.py do meu pacote.
import mypackage.module1 as mod1 print(mod1.mod1_func1()) print(mod1.mod1_func2()) print(mod1.mod1_func2())
Saída:
Welcome to Module1 function1 None Welcome to Module1 function2 None Welcome to Module1 function2 None
Acabamos de demonstrar o pacote com um módulo simples com funções dentro dele. De acordo com o seu projeto, você também pode empacotar com subpacotes. Subpastas/com módulos com classes definidas.
Python Caminho de pesquisa do módulo
Durante a execução, quando o python se depara nome do módulo de importação, o intérprete tenta localizar o módulo. Ele pesquisa o módulo na lista de módulos integrados. Later ao todo, os diretórios definidos dentro de sys.path.
Resumindo, o intérprete faz a seguinte pesquisa para localizar o módulo:
- No seu diretório atual.
- Na lista de módulos integrados
- Dentro dos diretórios sys.path
Você pode obter os detalhes do sys.path importando o módulo sys e imprimindo o sys.path. Ele lhe dará a lista de diretórios conforme mostrado abaixo:
importsys print(sys.path)
Saída:
['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\ \Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\P ython37\\DLLs']
Você também pode modificar o caminho e manter os diretórios conforme suas necessidades.
Usando o alias do módulo na importação
Você também pode converter o nome do módulo para um formato mais curto, fornecendo um nome alternativo a ele. O alias pode ser feito usando a palavra-chave.
Sintaxe:
import filename as alias name
A estrutura de pastas para testar o código será a seguinte:
Mod test/ test.py display.py
A seguir está o código dentro de test.py
my_name = "Guru99" my_address = "Mumbai" def display_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
Agora usaremos um alias para test.py em display.py
Import test as t print(t.display_message()) print(t.display_message1()) print(t.my_name) print(t.my_address)
O alias usado para o módulo de teste é t . Portanto, a função e as variáveis de test.py podem ser referenciadas usando o alias t.
Saída:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Importações Absolutas e Relativas em Python
Agora você sabe importar um arquivo como um módulo dentro de outro arquivo. Vejamos agora como gerenciar os arquivos disponíveis nas pastas. Os arquivos nas pastas podem ser importados usando importações absolutas ou relativas.
Considere que você tem a estrutura de pastas do seu projeto, conforme mostrado abaixo:
A pasta raiz é meu projeto/. Possui duas subpastas pacote1 e pacote2.
A pasta package1 possui dois módulos, module1.py e module2.py.
A pasta package2 possui uma classe myclass.py, um subpacote subpkg com module3.py e por último module4.py.
- No module1.py, existe uma função chamada myfunc1.
- No module2.py, existe uma função chamada myfunc2.
- No module3.py, existe uma função chamada myfunc3.
- No module4.py, existe uma função chamada myfunc4.
Usando importações absolutas
Para importações absolutas, você precisa adicionar o caminho completo do seu módulo diretamente da pasta raiz do projeto.
Vejamos agora como fazer uso de importações absolutas para nos referirmos às funções presentes em cada módulo.
Para trabalhar com a funçãomyfunc1, você precisará importar da seguinte forma:
from package1.module1 import myfunc1 or from package1 import module1 module1.myfunc1()
Para trabalhar com a função myfunc3 você precisará importar da seguinte forma:
from package1.subpkg.module3 import myfunc3 or from package1.subpkg import module3 module3.myfunc3()
Vantagens e desvantagens de usar importações absolutas
Aqui estão as vantagens de usar importações absolutas:
- Torna-se fácil rastrear os módulos para verificação de código.
- Fácil de usar e muito direto.
- Se o projeto for movido para um caminho diferente, as importações permanecerão as mesmas.
Desvantagens de usar importações absolutas
Aqui estão as desvantagens de usar importações absolutas:
Desvantagens:
- O caminho de importação pode ficar muito longo caso os módulos estejam aninhados e se o nome dos módulos for extenso.
Usando importações relativas
Considerando a mesma estrutura de pastas mencionada abaixo, veremos como importá-las usando importações relativas.
Na importação relativa, o módulo a ser importado é relativo ao local atual que é o local onde a instrução de importação está presente.
Sintaxe
Em importações relativas, você precisa adicionar um ponto final (.) antes do nome do módulo ao importar usando da.
Serão 2 pontos (..) antes do nome do módulo se o módulo estiver um nível acima da localização atual.
Referindo-se à figura da estrutura de pastas mencionada acima, temos os seguintes módulos com suas funções, aos quais precisamos nos referir.
- No module1.py, existe uma função chamada myfunc1.
- No module2.py, existe uma função chamada myfunc2.
- No module3.py, existe uma função chamada myfunc3.
- No module4.py, existe uma função chamada myfunc4.
Para trabalhar com a funçãomyfunc1 você precisará importar da seguinte forma:
from .module1 import myfunc1
Para trabalhar com a função myfunc3, você precisará importar da seguinte forma:
from .subpkg.module3 import myfunc3
Vantagens das importações relativas
Vantagens:
- É fácil trabalhar com importações relativas.
- A partir da localização actual, as importações podem ser reduzidas em comparação com as importações absolutas.
Desvantagens das importações relativas
Desvantagens:
- Usando importações relativas, é difícil rastrear onde o código reside
Resumo
- Importar em Python ajuda você a se referir ao código, ou seja, .functions/objects que são escritos em outro arquivo. Ele também é usado para importar bibliotecas/pacotes python que são instalados usando pip (python package manager), e você precisa então usar em seu código.
- A funcionalidade de importação está disponível em outras linguagens como TypeScript, JavaScript, Java, Ruby, etc.
- Um módulo é python é o código escrito dentro do arquivo, por exemplo (test.py). Dentro do seu arquivo, você pode definir suas variáveis, funções ou sua classe. O arquivo inteiro vira um módulo e pode ser importado dentro de outro arquivo para referenciar o código.
- Com a funcionalidade do módulo, você pode dividir seu código em arquivos diferentes em vez de escrever tudo dentro de um arquivo. Later, usando import, você pode consultar o código dentro do arquivo que você precisa.
- Python tem seus módulos integrados e também bibliotecas/pacotes externos instalados usando um gerenciador de pacotes python (pip), por exemplo, pandas, NumPy, etc. são chamados de módulos.
- Você pode importar apenas uma pequena parte do módulo, ou seja, apenas as funções necessárias e nomes de variáveis do módulo, em vez de importar o código completo.
- Você também pode converter o nome do módulo para um formato mais curto, fornecendo um nome alternativo a ele. O alias pode ser feito usando a palavra-chave.
- Um pacote é um diretório com todos os módulos definidos dentro dele. Para fazer um Python intérprete tratá-lo como um pacote, seu diretório deverá ter o __init.pyfile. O init.py transforma o diretório em um pacote. Aqui está o layout do pacote no qual vamos trabalhar.
- Durante a execução, quando o python se depara nome do módulo de importação, o intérprete tenta localizar o módulo. Ele pesquisa o módulo na lista de módulos integrados. Later ao todo, os diretórios definidos dentro de sys.path.
- Para importações absolutas, você precisa adicionar o caminho completo do seu módulo diretamente da pasta raiz do projeto.
- Na importação relativa, o módulo a ser importado é relativo ao local atual que é o local onde a instrução de importação está presente.
