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

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 é o módulo de importação do Python?

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:

Crie e importe um módulo em Python

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 seguintewing 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 seguintewing 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	

Following são o código details 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']

PACK

Um pacote é um diretório com todos os módulos definidos dentro dele. Para fazer um interpretador Python tratá-lo como um pacote, seu diretório deve ter o init.pyfile. O init.py transforma o diretório em um pacote. Aqui está o layout do pacote no qual vamos trabalhar.

Pacotes em Python

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 ostails 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")

A 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.

Caminho de pesquisa do módulo Python

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 o seguintewing pesquise 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 o details de 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	

Following é 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:

Importações absolutas e relativas em Python

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 o seguintewing módulos com suas funções, às 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 estão escritos em outro arquivo. Ele também é usado para importar bibliotecas/pacotes python que são instalados usando pip (gerenciador de pacotes python) e você precisa usá-los 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 interpretador Python tratá-lo como um pacote, seu diretório deve 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.