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

Índice:

Anonim

Quais são os módulos em Python?

Um módulo é um arquivo com código python. O código pode ser na forma de variáveis, funções ou classe definida. O nome do arquivo se torna o nome do módulo.

Por exemplo, se o nome do 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 o módulo de para importar
  • Importando tudo do módulo
  • Usando o módulo de importação
  • Usando a importação *
  • A função dir ()
  • Pacotes
  • PythonModuleSearchPath
  • Usando o alias do módulo na importação
  • Importações absolutas e relativas em Python
  • UsingAbsoluteImports
  • UsingRelativeImports

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

Um arquivo é considerado um módulo em python. Para usar o módulo, você deve importá-lo usando a palavra-chave import . A função ou variáveis ​​presentes dentro do arquivo podem ser usadas 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 da pasta usada para testar o código é a seguinte:

modtest/test.pydisplay.py

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

Etapa 2) Dentro de 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 de display.py importe o arquivo moduletest.py, conforme mostrado abaixo:

import test

Durante a importação, 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 testprint(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 da pasta para testar o código é a seguinte:

myproj/Car.pydisplay.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_nameself.model = modelself.manu_year = manu_yeardef 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 um módulo em outro arquivo chamado display.py.

Nome do arquivo: display.py

import Carcar_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:

BMWCar brand is BMWCar model is Z5Car manufacture year is 2020Car brand is BMWCar model is Z5

Assim, podemos acessar todas as variáveis ​​e funções de Car.py usando o módulo Car.

Usando o módulo de para importar

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 itens específicos sejam importados, você pode usar a palavra-chave "de" para importar o que quiser.

Portanto, a sintaxe é

from module import your function_name , variables,… etc.

A estrutura da pasta usada para testar o código é a seguinte:

modtest/test.pydisplay.py

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

Nome do arquivo: test.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_messageprint(display_message())

Resultado:

Welcome to Guru99 Tutorials!

Agora, se acontecer de você usar a função display_message1 (), ela irá lançar um erro que a função não está definida como mostrado abaixo:

from test import display_messageprint(display_message1())

Resultado:

Traceback (most recent call last):File "display.py", line 3, in print(display_message1())Name Error: name 'display_message1' is not defined

Importando tudo do módulo

Import permite que você importe 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 da pasta usada para testar o código é a seguinte:

modtest/test.pydisplay.py

A seguir estão os detalhes do código em 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 tem que prefixar com o nome do módulo.

Exemplo

Nome do arquivo: display.py

Import testprint(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!Guru99Mumbai

Usando a importação *

Vejamos um exemplo usando import * . Usando import * , 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!Guru99Mumbai

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.

Portanto, quando dir () é usado no módulo, ele fornecerá as variáveis, funções que estão presentes dentro do módulo.

Aqui está um exemplo prático 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 da pasta para testar o código será a seguinte:

test prop/Car.pytest.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_nameself.model = modelself.manu_year = manu_yeardef 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: test.py

import Carclass_contents = dir(Car)print(class_contents)

A saída nos fornece 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 no módulo json conforme mostrado no exemplo abaixo. Ele exibirá todas as propriedades e métodos disponíveis no módulo json .

Import jsonjson_details = dir(json)print(json_details)

Resultado:

['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_encoder', 'codecs', 'decoder', 'detect_encoding', 'dump', 'dumps', 'encoder', 'load', '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")

A embalagem está pronta para uso. Agora chame o pacote dentro de qualquer um de seus arquivos, conforme 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 mod1print(mod1.mod1_func1())print(mod1.mod1_func2())print(mod1.mod1_func2())

Resultado:

Welcome to Module1 function1NoneWelcome to Module1 function2NoneWelcome to Module1 function2None

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 sub-pacotes. Subpastas / com módulos com classes definidas.

Caminho de pesquisa do módulo Python

Durante a execução, quando o python encontra o 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. Posteriormente, os diretórios definidos em sys.path.

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

  1. Em 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 imprimir o sys.path. Ele lhe dará a lista de diretórios conforme mostrado abaixo:

importsysprint(sys.path)

Resultado:

['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\\Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\Python37\\DLLs']

Você também pode modificar o caminho e manter os diretórios de acordo com seus requisitos.

Usando o alias do módulo na importação

Você também pode converter o nome do módulo em 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 da pasta para testar o código será a seguinte:

Mod test/test.pydisplay.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 tprint(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.

Resultado:

Welcome to Guru99 Tutorials!All about Python!Guru99Mumbai

Importações absolutas e relativas em Python

Agora você sabe importar um arquivo como um módulo dentro de outro arquivo. Vamos agora ver 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 package1 e package2.

A pasta package1 possui 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, há uma função chamada myfunc2.
  • Em module3.py, existe uma função chamada myfunc3.
  • Em module4.py, existe uma função chamada myfunc4.

Usando importações absolutas

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

Vamos agora ver como fazer uso de importações absolutas para se referir às funções presentes em cada um dos módulos.

Para trabalhar com a função myfunc1, você precisará importar da seguinte maneira:

from package1.module1 import myfunc1orfrom package1 import module1module1.myfunc1()

Para trabalhar com a função myfunc3, você precisará importar da seguinte maneira:

from package1.subpkg.module3 import myfunc3orfrom package1.subpkg import module3module3.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, ainda assim 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 no caso, os módulos estão 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 .

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

Referindo-nos à figura da estrutura de pastas mencionada acima, temos os seguintes módulos com suas funções, aos quais precisamos nos referir.

  • Em module1.py, existe uma função chamada myfunc1.
  • Em module2.py, há 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 função myfunc1, você precisará importar da seguinte maneira:

from .module1 import myfunc1

Para trabalhar com a função myfunc3, você precisará importar da seguinte maneira:

from .subpkg.module3 import myfunc3

Vantagens das importações relativas

Vantagens:

  • É fácil trabalhar com importações relativas.
  • A partir da localização 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 de volta onde o código reside

Resumo:

  • Importar em Python ajuda você a se referir ao código, ou seja, funções / objetos 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 de seu arquivo, você pode ter suas variáveis, funções ou sua classe definida. O arquivo inteiro se torna um módulo e pode ser importado dentro de outro arquivo para se referir 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. Posteriormente, usando a importação, você pode consultar o código dentro do arquivo de que precisa.
  • 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, 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 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 o 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. Posteriormente, os diretórios definidos em sys.path.
  • Para importações Absolute, você precisa adicionar todo o caminho 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.