Módulo de importação em Python com exemplos

As seções abaixo explicam módulos, pacotes, os diferentes estilos de importação e como funcionam as importações absolutas e relativas. Python.

Quais são os módulos em Python?

Um módulo é um arquivo com Python código. O código pode estar na forma de variáveis, funções ou uma classe definida. O nome do arquivo torna-se 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 PythonPara usar o módulo, você precisa importá-lo usando o importar palavra-chave. As funções ou variáveis ​​presentes no arquivo podem ser usadas em outro arquivo importando o módulo. Essa funcionalidade está disponível em outras linguagens, como TypeScript, JavaRoteiro, Java, rubi, 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 os passos indicados 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 como 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 do arquivo display.py, importe o arquivo de módulo test.py, conforme mostrado abaixo:

import test

Ao importar, você não precisa mencionar o arquivo test.py, apenas o nome do arquivo.

Passo 5) Em seguida, você pode chamar a função display_message() de test.py dentro de display.py. Você precisa usar o formato module_name.function_name.

Por exemplo test.display_message().

Import test
print(test.display_message())

Passo 6) Ao executar o arquivo display.py, você obterá o seguinte resultado: Saída:

Welcome to Guru99 Tutorials!

Importando uma classe em Python

Anteriormente, vimos um módulo simples com uma função. Aqui, criaremos uma classe e faremos referência a ela 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 os atributos brand_name, model e manu_year. As funções definidas dentro da classe são car_details(), get_Car_brand() e 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 de 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 e nomes de variáveis ​​necessários, em vez de importar o código completo.

Quando você deseja importar apenas itens específicos, pode usar a palavra-chave “from” 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	

No arquivo test.py existem 2 funções, conforme mostrado abaixo:

Nome do arquivo: teste.py

defdisplay_message():
	return "Welcome to Guru99 Tutorials!"
	
def display_message1():
	return "All about Python!"

Agora você precisa da função display_message(). A função ou variável que você está importando pode ser acessada diretamente, como mostrado abaixo:

Nome do arquivo: display.py

from test import display_message
print(display_message())

Saída:

Welcome to Guru99 Tutorials!

Agora, se você usar a função display_message1(), ela lançará um erro informando que a função não está definida, como 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

A opção `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

Ao usar apenas o nome do módulo de importação, para se referir às variáveis ​​e funções dentro do módulo, você precisa prefixá-las com 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 às funções 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()

A função dir() é uma função integrada em PythonA função dir() retorna todas as propriedades e métodos, incluindo as propriedades internas do objeto fornecido.

Portanto, quando dir() é usado no módulo, ele retornará as variáveis ​​e funções presentes dentro do módulo.

Aqui está um exemplo funcional de dir() em um módulo. Temos uma classe chamada Car.py; vamos importá-la e atribuí-la a 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 PythonVamos tentar o mesmo no json módulo, conforme mostrado no exemplo abaixo. Ele exibirá todas as propriedades e métodos disponíveis no 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 Para que o interpretador trate o diretório como um pacote, ele deve conter o arquivo `__init__.py`. O arquivo `__init__.py` transforma o diretório em um pacote. A seguir, a estrutura do pacote com o qual trabalharemos.

O nome do pacote é Meu pacotePara começar a trabalhar com o pacote, crie um diretório chamado `mypackage/`. Dentro desse diretório, crie um arquivo vazio chamado `__init__.py`. Crie mais três arquivos: `module1.py`, `module2.py` e `module3.py`, e defina as funções conforme mostrado na captura de tela. A seguir, os detalhes dos arquivos `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 pacote Está pronto para uso. Agora, chame o pacote dentro de qualquer um dos seus arquivos, como mostrado abaixo em test.py:

Aqui, mypackage.module1 é importado e recebe um nome alternativo como modo1Da mesma forma, você pode usar os 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 contendo funções. Conforme o seu projeto, você também pode criar pacotes com subpacotes, ou seja, subpastas com módulos e classes definidas.

Python Caminho de pesquisa do módulo

Durante a execução, quando Python se deparou nome do módulo de importaçãoO interpretador tenta localizar o módulo. Ele procura o módulo na lista de módulos internos e, em seguida, em todos os diretórios definidos em sys.path.

Resumindo, o intérprete faz a seguinte pesquisa para localizar o módulo:

1. No seu diretório atual.
2. Na lista de módulos integrados.
3. Dentro dos diretórios sys.path.

Você pode obter os detalhes de sys.path importando o módulo sys e imprimindo sys.path. Isso 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 uma forma mais curta, atribuindo-lhe um nome alternativo. O nome alternativo pode ser criado usando o as 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 vamos usar 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, as funções e 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 é myproject/. Ela possui duas subpastas: package1 e package2.

A pasta package1 contém 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 arquivo module1.py, existe uma função chamada myfunc1.
• No arquivo module2.py, existe uma função chamada myfunc2.
• No arquivo module3.py, existe uma função chamada myfunc3.
• No arquivo 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 utilizar importações absolutas para referenciar as funções presentes em cada um dos módulos.

Para trabalhar com a função myfunc1, você precisará importá-la da seguinte forma:

from package1.module1  import  myfunc1
or
from package1 import module1
module1.myfunc1()  

Para trabalhar com a função myfunc3, você precisará importá-la 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 de trace devolvemos 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

Eis as desvantagens de usar importações absolutas:

• O caminho de importação pode ficar muito longo caso os módulos estejam aninhados e os nomes dos módulos sejam extensos.

Usando importações relativas

Considerando a mesma estrutura de pastas mencionada acima, veremos como importá-la usando importações relativas.

Numa importação relativa, o módulo a ser importado é relativo à localização atual, ou seja, à localização 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.

Haverá dois pontos (...) antes do nome do módulo se o módulo estiver um nível acima da localização atual.

Consultando o diagrama de estrutura de pastas mencionado acima, temos os seguintes módulos com suas respectivas funções, aos quais precisamos nos referir.

• No arquivo module1.py, existe uma função chamada myfunc1.
• No arquivo module2.py, existe uma função chamada myfunc2.
• No arquivo module3.py, existe uma função chamada myfunc3.
• No arquivo module4.py, existe uma função chamada myfunc4.

Para trabalhar com a função myfunc1, você precisará importá-la da seguinte forma:

from  .module1  import  myfunc1

Para trabalhar com a função myfunc3, você precisará importá-la da seguinte forma:

from  .subpkg.module3  import  myfunc3

Vantagens das importações relativas

• É 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

• Usando importações relativas, é difícil trace de volta para onde o código reside.

Perguntas Frequentes