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.

Neste tutorial, você aprenderá:

Quais são os módulos em Python?
Módulo de importação Python
Como criar e importar um módulo em Python?
Importando uma classe em Python
Usando de para importar o módulo
Importando tudo do módulo
Usando o módulo de importação
Usando importação *
A função dir()
Pacotes
PythonModuleSearchPath
Usando alias de módulo na importação
Importações absolutas e relativas em Python
UsandoAbsoluteImports
Usando oRelativeImports

O que é o módulo de importação do Python?

Um arquivo é considerado um módulo em python. Para usar o módulo, você precisa 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 em 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

Etapa 1) Crie um arquivo e nomeie-o test.py

Etapa 2) Dentro do test.py crie uma função chamada display_message()

Def display_message():
    return "Welcome to Guru99 Tutorials!"

Etapa 3) Agora crie outro arquivo display.py.

Etapa 4) Dentro do display.py importe o arquivo moduletest.py, conforme mostrado abaixo:

import test

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

Etapa 5)

Então você pode chamar a função display_message() de test.py dentro de display.py, você precisa fazer uso de module_name.function_name.

Por exemplo test.display_message().

Import test
print(test.display_message())

Etapa 6)

Ao executar display.py, você obterá a 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 referenciar a classe 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(), 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())

Resultado:

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 de para importar o 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 você deseja que apenas coisas específicas sejam importadas, você 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

Em test.py existem 2 funções como mostrado:

Nome do arquivo:teste.py

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

Agora você quer 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 você usar a função display_message1() , ele lançará um erro de 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

Import permite importar o módulo completo usando import seguido pelo nome do módulo, ou seja, o nome do arquivo ou a 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 o nome do módulo de importação, para se referir às variáveis e funções dentro do módulo, ele deve prefixar 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 teste do nome do módulo é usado para se referir à função e às variáveis dentro do teste do módulo.

Resultado:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Usando importação *

Vamos ver um exemplo usando import * . Usando importar * , as funções e variáveis são diretamente acessíveis, conforme mostrado no exemplo abaixo:

from test import *

print(display_message())
print(display_message1())
print(my_name)
print(my_address)

Resultado:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

A função dir()

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

Então, 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 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 Python. Vamos tentar o mesmo em json módulo como 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)

Resultado:

['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 interpretador Python tratá-lo como um pacote, seu diretório deve ter o arquivo init.py. O init.py torna o diretório como um pacote. Aqui está o layout do pacote que 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

module1.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")

module2.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")

module3.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 s pronto para uso. Agora chame o pacote dentro de qualquer arquivo como mostrado abaixo :test.py:

Aqui, o 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())

Resultado:

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 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 encontra nome do módulo de importação , o interpretador tenta localizar o módulo. Ele pesquisa o módulo na lista de módulos integrados. Mais tarde, os diretórios definidos dentro de sys.path.

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

Em 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)

Resultado:

['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 de acordo com seus requisitos.

Usando alias de módulo na importação

Você também pode converter o nome do módulo em um formato mais curto, dando um nome de alias 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 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 . Assim, a função e as variáveis de test.py podem ser referenciadas usando o alias t.

Resultado:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Importações absolutas e relativas em Python

Agora você sabe como 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/. Tem duas subpastas package1 e package2.

A pasta package1 tem dois módulos, module1.py e module2.py.

A pasta package2 tem uma classe myclass.py, um subpacote subpkg com module3.py e o último module4.py.

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

Como usar importações absolutas

Para importações absolutas, você precisa adicionar todo o caminho do seu módulo diretamente da pasta raiz do projeto.

Vejamos agora como fazer uso de importações absolutas para fazer referência às funções presentes em cada um dos módulos.

Para trabalhar com a functionmyfunc1, 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:

Fica fácil rastrear os módulos para verificação de código.
Fácil de usar e muito simples.
Se o projeto for movido para um caminho diferente, as importações continuarã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 longo.

Usando importações relativas

Considerando a mesma estrutura de pastas mencionada abaixo, veremos como importar a mesma 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 (.) antes do nome do módulo ao importar usando de .

Serão 2 pontos (..) antes do nome do módulo se o módulo estiver em um nível acima do local atual.

Referindo-se à figura da estrutura de pastas mencionada acima, temos os seguintes módulos com sua função, aos quais precisamos nos referir.

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

Para trabalhar com a functionmyfunc1 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 do local atual, 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 fazer referência 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 (gerenciador de pacotes python), e você precisa 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 se torna um módulo e pode ser importado dentro de outro arquivo para fazer referência ao 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. Mais tarde, usando a importação, você pode consultar o código dentro do arquivo necessário.
Python tem seus módulos embutidos, 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 em um formato mais curto, dando um nome de alias 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 arquivo __init.py. O init.py torna o diretório como um pacote. Aqui está o layout do pacote que vamos trabalhar.
Durante a execução, quando o python encontra nome do módulo de importação , o interpretador tenta localizar o módulo. Ele pesquisa o módulo na lista de módulos integrados. Mais tarde, os diretórios definidos dentro de sys.path.
Para importações Absolutas, você precisa adicionar o caminho inteiro 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.

Multithreading em Python com Exemplo:Aprenda GIL em Python Python Debugger:Melhore sem esforço suas habilidades de depuração

python