9. As importações
O erro encontrado na versão 1 do exercício prático nos leva a aprofundar o papel da instrução [import].
9.1. Scripts [import_01]
O script [imported] será importado por diferentes scripts (também chamados de módulos):
# módulo importado
# esta instrução será executada sempre que o módulo for importado
print("2")
# variável pertencente ao módulo importado
x=4
Um módulo é executado quando é importado. Assim, quando o módulo [imported] for importado:
- a linha 3 será exibida;
- a variável x da linha 5 receberá seu valor;
O script [main_01] é o seguinte:
# um módulo importado é executado
import imported
# uso da variável x do módulo importado
print(imported.x)
- linha 2: o módulo [imported] é importado. Isso fará com que ele seja executado:
- o valor 2 será exibido;
- a variável x é criada com o valor 4;
- linha 4: utiliza-se a variável x do módulo importado;
No PyCharm, é sinalizado um erro:
No [1], o PyCharm indica que ele não reconhece o módulo [imported]. Em termos técnicos, isso significa que a pasta que contém o módulo [imported] não está no Python Path do PyCharm. O Python Path é o conjunto de pastas nas quais os módulos importados são procurados. Para resolver esse problema, basta declarar ao [Sources root] a pasta na qual se encontra o módulo [imported], neste caso, a pasta [import/01]:
Após essa operação, a pasta [import/01] é adicionada ao Python Path do Pycharm e o erro desaparece:
- em [1], a pasta [01] mudou de cor;
- em [2-3], não há mais erro;
Os resultados da execução são os seguintes:
Comentários
- a linha 2 é o resultado da execução do módulo importado;
- a linha 3 exibe o valor da variável x do módulo importado;
Deste exemplo, destaca-se o conceito importante de que um módulo (ou script) importado é executado.
O script [main_02] é o seguinte:
# importa-se a variável x do módulo importado
from imported import x
# ela é exibida
print(x)
- Na linha 2, temos outra sintaxe de importação: [from module import objet1, objet2, …]. Aqui, importamos a variável [imported.x]. Com essa sintaxe, a variável x passa a ser uma variável do script [main_02]. Não é mais necessário prefixá-la com seu módulo [imported];
- linha 4: exibimos a variável x de [main_02];
Os resultados da execução são os seguintes:
O script [main_03] é o seguinte:
# importa-se tudo o que está visível do módulo importado
from imported import *
# utiliza-se a variável x do módulo importado
print(x)
A notação [import *] na linha 2 significa que todos os objetos visíveis do módulo importado (variáveis, funções) são importados.
Os resultados são os seguintes:
O script [main_04] é o seguinte:
# importa-se a variável x do módulo importado
# e renomeia-se como y
from imported import x as y
# exibe-se a variável y
print(y)
A linha 3 mostra que é possível importar um objeto do módulo importado e atribuir-lhe um alias. Aqui, a variável [imported.x] passa a ser a variável [main_04.y]. Os resultados são os mesmos de antes.
9.2. Script [import_02]
O módulo importado [module1.py] é o seguinte:
# uma função
def f1():
print("f1")
O módulo importado define uma função, o que é comum.
O script [main_01] é o seguinte:
# import
import module1
# execução de f1
module1.f1()
- na linha 2, o módulo é importado. Ele será executado. Aqui, ele não exibe nada;
- linha 4: a função [f1] do módulo importado é executada;
Os resultados da execução são os seguintes:
Observação: Para evitar que PyCharm sinalize um erro na importação da linha 2, é necessário colocar a pasta que contém [module1] dentro da pasta [Sources Root] de PyCharm:
No [1], a pasta [02] inserida no [Sources Root] ficou em azul. Vale ressaltar que o erro sinalizado não impede, neste caso, a execução correta dos scripts. De fato, durante a execução do script [main_0x], a pasta do script é automaticamente adicionada ao Python Path. Assim, o [module1] é encontrado. A partir de agora, quando uma pasta aparecer em azul em uma captura de tela, isso significa que ela foi adicionada ao Python Path do [Sources Root] a partir do PyCharm.
O script [main_02] é o seguinte:
# importar
from module1 import f1
# execução de f1
f1()
- a linha 2 importa a função [f1] do módulo [module1];
- na linha 4, utiliza-se a função f1;
Os resultados são idênticos aos do script [main_01].
9.3. Scripts [import_03]
Observação: o [03] está no [Sources Root] do projeto.
Os novos scripts importarão o módulo [module2], que não está na mesma pasta que eles.
O script [module2] é o seguinte:
# uma função
def f2():
print("f2")
O script define, portanto, uma função [f2].
O script [main_01] é o seguinte:
# importação do módulo Class2
import dir1.module2
# execução f2
dir1.module2.f2()
- linha 2: utiliza-se uma notação especial para indicar como localizar o módulo [module2]. Deve-se interpretar [dir1.module2] como o caminho [dir1/module2]: para localizar o [module2], parte-se da pasta do script atual [main_01], depois passa-se para o [dir1] e, a partir daí, encontra-se o [module2]. Não se deve esquecer, neste caso, que o ponto de partida do caminho é a pasta do script que está sendo importado;
- linha 4: para executar a função [f2] a partir de [module2];
Os resultados são os seguintes:
Linha 2, o resultado da função [f2].
O script [main_02] é o seguinte:
# importação do módulo dir1.module2, que será renomeado
import dir1.module2 as module2
# execução de f2
module2.f2()
Na linha 2, renomeia-se o módulo [dir1.module] para simplificar a escrita da linha 4.
O script [main_03] é o seguinte:
# importação da função f2 do módulo dir1.module2
from dir1.module2 import f2
# execução de f2
f2()
Desta vez, na linha 2, importamos apenas a função [f2], que passa a ser uma função do script [main_03] (linha 4).
Todos esses scripts funcionam tanto no contexto do PyCharm quanto no de um console Python. Isso ocorre porque, em ambos os casos, a pasta do script executado — neste caso, a pasta [03] — faz parte do Python Path. Assim, a pasta [dir1/module2] é localizada.
9.4. Scripts [import_04]
Aqui, as pastas [dir1] e [dir2] foram colocadas na pasta [Sources Root] do projeto PyCharm.
O primeiro módulo importado é o [module3]:
# uma função
def f3():
print("f3")
O segundo módulo importado é o [module4]:
from module3 import f3
# uma função
def f4():
f3()
print("f4")
- na linha 1, importa-se a função [f3] a partir de [module3]. Aqui, [module3] está visível porque colocamos sua pasta [dir1] dentro de [Sources Root];
- linhas 4-6: define-se uma função [f4] que chama a função [f3] da função [module3];
O script principal [main_01] é o seguinte:
# importando o módulo4
from module4 import f4
# execução f4
f4()
- na linha 2, importa-se o módulo [module4]. Este fica visível porque sua pasta [dir2] foi colocada na pasta [Sources Root] de PyCharm;
- linha 4: execução da função [f4] de [module4];
Os resultados da execução de [main_01] em PyCharm são os seguintes:
Agora, vamos executar [main_01] em um terminal (console) Python:
Os resultados são os seguintes:
O que aconteceu? O terminal Python não tem conhecimento do Python Path nem dos arquivos [Sources Root] e PyCharm. Ele possui seu próprio Python Path. Nele, está sempre presente a pasta do script que está sendo executado, neste caso, o script [main_01]. Portanto, ele reconhece a pasta [import/04]. No script executado, ele encontra a linha:
from module4 import f4
O interpretador Python procura por [module4] nas pastas do seu Python Path. No entanto, [module4] não está em [import/04] — que, por sua vez, está no Python Path —, mas sim em [import/04/dir2], que não está nesse caminho. Daí o erro.
Portanto, temos um problema já encontrado anteriormente: um script que é executado corretamente no PyCharm pode travar no contexto de um terminal Python. Trata-se de um problema recorrente que precisaremos resolver.
9.5. Scripts [import_05]
Observação: as pastas [dir1] e [dir2] estão incluídas no Python Path. Vale ressaltar que há um conflito aqui: [module3] e [module4] serão encontrados em dois locais do Python Path de PyCharm:
- em [import/04/dir1] e [import/05/dir1] para [module3];
- em [import/04/dir2] e [import/05/dir2] para [module4];
É possível, então, extrair [import/04/dir1] e [import/04/dir2] do [Sources Root] do projeto PyCharm. Acontece que, neste caso, o [import/05/dir1] é uma cópia do [import/04/dir1] (o mesmo vale para o [dir2]) e, portanto, não há problema algum. Mas vale ressaltar que, dentro do próprio PyCharm, é preciso prestar atenção à lista de pastas do [Sources Root] para evitar conflitos.
O script [main_01] fica da seguinte forma:
import sys
# modifica-se o sys.path para incluir as pastas
# que contêm as classes a serem importadas
sys.path.append(".")
sys.path.append("./dir1")
sys.path.append("./dir2")
# importa-se o módulo4
from module4 import f4
# execução f4
f4()
Estamos tentando resolver o problema do Python Path. Queremos um que funcione tão bem no PyCharm quanto em um terminal Python. Para isso, vamos corrigir isso nós mesmos.
- linhas 4-6: adicionamos as pastas [., ./dir1, ./dir2] ao Python Path. Para que isso funcione, é necessário que a pasta atual no momento da execução seja a pasta [import/05]. Isso será verdade no PyCharm, mas não necessariamente em um terminal Python, como veremos;
- linha 8: importamos [module4]. Pelo que acabamos de fazer, ele deve ser encontrado em [./dir2];
A execução em PyCharm produz os seguintes resultados:
Agora, em um terminal Python:
(venv) C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\import\05>python main_01.py
f3
f4
Na linha 1, a pasta de execução é [import/05].
Agora, subamos um nível na árvore de diretórios de [import/05]:
(venv) C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\import\05>cd ..
(venv) C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\import>python 05/main_01.py
Traceback (most recent call last):
File "05/main_01.py", line 8, in <module>
from module4 import f4
ModuleNotFoundError: No module named 'module4'
- linha 2: quando [main_01] é executado, não estamos mais na pasta [import/05], mas sim em [import]. No entanto, escrevemos:
sys.path.append(".")
sys.path.append("./dir1")
sys.path.append("./dir2")
Isso adiciona ao Python Path as pastas [import, import/dir1, import/dir2], o que não é de forma alguma o que queremos. Observe que adicionar ao Python Path pastas que não existem (import/dir1, import/dir2) não gera erros.
Avançamos, mas ainda não é suficiente. É preciso adicionar ao Python Path, não caminhos relativos, mas caminhos absolutos.
O script [main_02] é uma variante do [main_01] que utiliza um arquivo de configuração [config.json]:
{
"dependencies": [
"C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/import/05/dir1",
"C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/import/05/dir2"
]
}
O valor da chave [dependencies] é a lista de pastas a serem adicionadas ao Python Path. Observe que, neste caso, foram utilizados nomes absolutos e não nomes relativos.
O script [main_02] utiliza o arquivo [config.json] da seguinte maneira:
import codecs
import json
import sys
# arquivo de configuração
config_filename="C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/import/05/config.json"
# leitura do arquivo de configuração JSON
with codecs.open(config_filename, "r", "utf-8") as file:
config = json.load(file)
# modificação do sys.path
for directory in config['dependencies']:
sys.path.append(directory)
# importando o módulo4
from module4 import f4
# execução de f4
f4()
- linha 6: observe que foi utilizado o nome absoluto do arquivo de configuração;
- linhas 8-9: o arquivo de configuração é lido. Um dicionário [config] (linha 9) é construído com seu conteúdo;
- linhas 11-13: os elementos da tabela [config['dependencies']] são adicionados ao Python Path. Observe que, como foram inseridos nomes absolutos de pastas no [config.json], nomes absolutos são adicionados ao Python Path;
- linha 16: o [module4] é importado. Ele deve ser encontrado, já que agora o [dir2] está no Python Path;
A execução produz os mesmos resultados que para [main_02], exceto que o script continua funcionando quando a pasta de execução não é mais [import/05]:
(venv) C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\import>python 05/main_02.py
f3
f4
Na linha 1, a pasta de execução é [import].
Fizemos progressos. Vimos que:
- que precisávamos construir o Python Path nós mesmos;
- que era preciso incluir nele os nomes absolutos de todas as pastas contendo os módulos importados pelo aplicativo;
No entanto, inserir nomes absolutos em scripts não é uma solução. Assim que o projeto é transferido para outro local, ele deixa de funcionar. Precisamos encontrar outra solução.
9.6. Scripts [import_06]
Observação: as pastas [06, dir1, dir2] foram colocadas nas pastas [Sources Root] do projeto PyCharm. As pastas [dir1, dir2] são idênticas às dos exemplos anteriores.
O arquivo [config.json] é o seguinte:
{
"rootDir": "C:/Data/st-2020/dev/python/cours-2020/v-02/imports/06",
"relativeDependencies": [
"dir1",
"dir2"
],
"absoluteDependencies": [
]
}
Introduzimos dois tipos de caminhos:
- caminhos absolutos, linhas 7-8;
- caminhos relativos, linhas 3-6. Eles são relativos à raiz da linha 2. Assim, quando o projeto for movido para outro local, apenas essa linha precisará ser alterada;
O script [utils.py] utiliza o arquivo [config.json] e define o caminho do Python:
# importações
import codecs
import json
import os
import sys
# configuração do aplicativo
def config_app(config_filename: str) -> dict:
# config_filename: nome do arquivo de configuração
# permitir que as exceções sejam reportadas
# processamento do arquivo de configuração
with codecs.open(config_filename, "r", "utf-8") as file:
config = json.load(file)
# adição de dependências ao sys.path
rootDir = config['rootDir']
# adiciona-se as dependências relativas do projeto ao syspath
for directory in config['relativeDependencies']:
# adiciona-se a dependência no início do syspath
sys.path.insert(0, f"{rootDir}/{directory}")
# adiciona-se as dependências absolutas do projeto ao syspath
for directory in config['absoluteDependencies']:
# adiciona-se a dependência no início do syspath
sys.path.insert(0, directory)
# cria-se o dicionário de configuração
return config
# pasta do script executado
def get_scriptdir():
return os.path.dirname(os.path.abspath(__file__))
- linha 8: a função [config_app] recebe como parâmetro o nome do arquivo de configuração;
- linhas 12-14: o arquivo de configuração é utilizado para criar o dicionário [config];
- linha 20: [sys.path] é a lista de pastas do Python Path;
- linhas 17-20: as dependências relativas do arquivo de configuração são adicionadas ao Python Path. Elas são adicionadas ao início da tabela [sys.path], linha 20. De fato, quando o Python procura um módulo, ele explora as pastas do [sys.path] nessa ordem. No entanto, neste documento, módulos com os mesmos nomes estarão em pastas diferentes do [sys.path]. Ao colocar as dependências do aplicativo no início da tabela [sys.path], garantimos que elas serão exploradas antes de outras pastas do [sys.path] que possam conter módulos com os mesmos nomes;
- linhas 21-24: as dependências absolutas do arquivo de configuração são adicionadas ao Python Path;
- linha 26: retorna-se a configuração do aplicativo;
- linhas 29-30: a função [get_scriptdir] retorna o nome absoluto da pasta do script em execução (aquela onde se encontra a chamada à função);
O script principal [main] é o seguinte:
# importações
import sys
from utils import config_app
def affiche_path(msg: str):
# mensagem
print(f"{msg}------------------------------")
# sys.path
for path in sys.path:
print(path)
# main -------------
try:
# o sys.path está configurado
affiche_path("avant....")
config = config_app(f"{get_scriptdir()}/config.json")
affiche_path("après....")
# importando o módulo4
from module4 import f4
# execução f4
f4()
except BaseException as erreur:
print(f"L'erreur suivante s'est produite : {erreur}")
finally:
print("done")
- linha 4: a função [config_app] é importada. Observe que, como [utils] e [main] estão na mesma pasta, essa função [import] funciona sempre. De fato, a pasta do script principal é automaticamente adicionada ao Python Path;
- linhas 7-12: a função [affiche_path] exibe a lista de pastas do Python Path;
- linha 19: configuramos o aplicativo. Observe que passamos para a função [config_app] o nome absoluto do arquivo de configuração. Após essa instrução, o Python Path foi reconstruído;
- linha 22: importa-se [module4]. Graças à reconstrução do Python Path, esse módulo será encontrado;
- linha 24: executa-se a função [f4];
No contexto PyCharm, os resultados da execução são os seguintes:
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/import/06/main.py
avant....------------------------------
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\import\06
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\fonctions\shared
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\impots\v01\shared
…
C:\Program Files\Python38\python38.zip
C:\Program Files\Python38\DLLs
C:\Program Files\Python38\lib
C:\Program Files\Python38
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\lib\site-packages
après....------------------------------
C:/Data/st-2020/dev/python/cours-2020/v-02/imports/06/dir2
C:/Data/st-2020/dev/python/cours-2020/v-02/imports/06/dir1
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\import\06
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\fonctions\shared
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\impots\v01\shared
….
C:\Program Files\Python38\python38.zip
C:\Program Files\Python38\DLLs
C:\Program Files\Python38\lib
C:\Program Files\Python38
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\lib\site-packages
f3
f4
done
Process finished with exit code 0
Comentários
- linhas 2-13: o Python Path de PyCharm. Nele estão todas as pastas incluídas no [Sources Root] do projeto;
- linhas 14-29: o Python Path construído pela função [config_app]. Nas linhas 15-16, encontram-se as duas dependências que adicionamos;
- linhas 22-27: as pastas do sistema do interpretador Python que executou o script;
- linhas 28-29: a execução ocorre normalmente;
Agora, vamos nos colocar no contexto que, até agora, causava um erro de execução:
- abrimos um terminal Python;
- vamos para uma pasta diferente daquela que contém o script executado;
(venv) C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\import>python 06/main.py
avant....------------------------------
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\import\06
C:\Program Files\Python38\python38.zip
C:\Program Files\Python38\DLLs
C:\Program Files\Python38\lib
C:\Program Files\Python38
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\lib\site-packages
après....------------------------------
C:/Data/st-2020/dev/python/cours-2020/v-02/imports/06/dir2
C:/Data/st-2020/dev/python/cours-2020/v-02/imports/06/dir1
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\import\06
C:\Program Files\Python38\python38.zip
C:\Program Files\Python38\DLLs
C:\Program Files\Python38\lib
C:\Program Files\Python38
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\lib\site-packages
f3
f4
done
Desta vez deu certo (linhas 20-21). Observe que o [sys.path] não contém as mesmas pastas de quando a execução ocorre no PyCharm.
9.7. Scripts [import_07]
Melhoramos a solução anterior de duas maneiras:
- substituímos o arquivo de configuração [config.json] por um script [config.py]. De fato, o arquivo jSON apresenta um problema significativo: ele não permite comentários. O dicionário [config.json] pode ser substituído por um dicionário Python, que tem a vantagem de poder ser comentado;
- utilizamos um módulo visível para todos os projetos Python da máquina;
9.7.1. Instalação de um módulo com escopo de máquina
Acima, criamos uma pasta [packages/myutils] no projeto PyCharm (os nomes não importam).
O script [myutils.py] é o seguinte:
# importações
import sys
import os
def set_syspath(absolute_dependencies: list):
# absolute_dependencies: uma lista de nomes absolutos de pastas
# adiciona-se ao syspath as dependências absolutas do projeto
for directory in absolute_dependencies:
# verifica-se se a pasta existe
existe = os.path.exists(directory) and os.path.isdir(directory)
if not existe:
# lança-se uma exceção
raise BaseException(f"[set_syspath] le dossier du Python Path [{directory}] n'existe pas")
else:
# adiciona-se a pasta ao início do syspath
sys.path.insert(0, directory)
- linhas 6-18: a função [set_syspath] cria um Python Path com a lista de pastas que lhe é passada como parâmetro;
- linhas 12-15: verifica-se se a pasta a ser incluída no Python Path existe;
O script [__init.py__] (com dois traços antes e depois do nome. Esse formato é obrigatório) é o seguinte:
from .myutils import set_syspath
Importa-se a função [set_syspath] do script [myutils]. A notação [.myutils] designa o caminho [./myutils]; portanto, o script [myutils] está localizado na mesma pasta que o [__init.py]. Poderíamos ter usado a notação [myutils]. No entanto, vamos criar um módulo [myutils] com escopo de máquina. Assim, a notação [from myutils import set_syspath] se tornaria ambígua. Trata-se de importar o script [myutils] da pasta atual ou o script [myutils] com escopo de máquina? A notação [.myutils] elimina essa ambiguidade.
O script [setup.py] (também neste caso o nome é imposto) é o seguinte:
from setuptools import setup
setup(name='myutils',
version='0.1',
description='Utilitaire fixant le Python Path',
url='#',
author='st',
author_email='st@gmail.com',
license='MIT',
packages=['myutils'],
zip_safe=False)
Nesse script, descreve-se o módulo que será criado. Aqui, vamos criá-lo localmente. Mas o mesmo processo é utilizado para criar um módulo distribuído oficialmente (cf. |pypi|). Os pontos importantes aqui são os seguintes:
- linha 3: o nome do módulo criado;
- linha 4: a versão do módulo;
- linha 5: sua descrição;
- linhas 7-8: o autor do módulo;
Para instalar esse módulo com escopo de máquina, proceda da seguinte maneira:
Em seguida, no terminal do Python, digite o seguinte comando: [pip install .]:
(venv) C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\packages>pip install .
Processing c:\data\st-2020\dev\python\cours-2020\python3-flask-2020\packages
Using legacy setup.py install for myutils, since package 'wheel' is not installed.
Installing collected packages: myutils
Attempting uninstall: myutils
Found existing installation: myutils 0.1
Uninstalling myutils-0.1:
Successfully uninstalled myutils-0.1
Running setup.py install for myutils ... done
Successfully installed myutils-0.1
A partir de agora, qualquer script da máquina poderá importar o módulo [myutils] sem que ele esteja nos códigos do projeto.
9.7.2. O script [config.py]
O script [config.py] garante a configuração do aplicativo:
def configure():
import os
# nome absoluto da pasta do script de configuração
script_dir = os.path.dirname(os.path.abspath(__file__))
# caminhos absolutos das pastas a serem incluídas no syspath
absolute_dependencies = [
# pastas locais
f"{script_dir}/dir1",
f"{script_dir}/dir2",
]
# atualização do syspath
from myutils import set_syspath
set_syspath(absolute_dependencies)
# retornamos a configuração
return {}
- linha 1: a função [configure] é responsável pela configuração do aplicativo;
- linhas 7-10: o dicionário que antes estava em [config.json];
- linhas 9-10: como estamos em um script, podemos obter diretamente os nomes absolutos das pastas [dir1, dir2];
- linhas 12-14: utilizamos a função [set_syspath] do módulo [myutils] que acabamos de criar para definir o Python Path da configuração;
- linha 20: retornamos o dicionário da configuração do aplicativo. Aqui, ele está vazio;
9.7.3. O script [main.py]
O script principal [main] é o seguinte:
# configuramos o aplicativo
import config
config = config.configure()
# o syspath está configurado — já é possível fazer as importações
from module4 import f4
# main -------------
try:
f4()
except BaseException as erreur:
print(f"L'erreur suivante s'est produite : {erreur}")
finally:
print("done")
- linhas 2-4: configuramos a aplicação usando o módulo [config.py]. Ele está acessível porque se encontra na mesma pasta que o script principal. Ora, a pasta do script principal sempre faz parte do Python Path;
- ao chegar à linha 6, o Python Path já foi construído e inclui a pasta do módulo [module4]. Portanto, é possível importá-lo na linha 7;
- linhas 10-15: basta executar a função [f4];
Os resultados da execução em PyCharm são os seguintes:
Em um terminal Python e fora da pasta do script principal, os resultados são os seguintes:
A partir de agora, sempre seguiremos o mesmo procedimento para configurar um aplicativo:
- presença de um script [config.py] na pasta do script principal. Esse script contém uma função [configure] que tem dois objetivos:
- construir o Python Path para o aplicativo. Para isso, o [config.py] declara todas as pastas que contêm os módulos utilizados pelo aplicativo e constrói o Python Path com seus nomes absolutos;
- construir o dicionário [config] da configuração do aplicativo;
Aplicamos esse esquema à segunda versão do exercício prático. Lembramos, de fato, que a versão 1 funcionava no ambiente PyCharm, mas não em um terminal Python. O problema estava no Python Path.