2. Instalação de um ambiente de trabalho

2.1. Python 3.8.1

Os exemplos deste documento foram testados com o interpretador Python 3.8.1 disponível em URL |https://www.python.org/downloads/| (fevereiro de 2020) em um computador com Windows 10:

A instalação do Python gera a estrutura de arquivos [1] e o menu [2] na lista de programas:

[3-4]: dois interpretadores interativos do Python;
[5]: a documentação do Python;
[6]: a documentação dos módulos Python;

Não utilizaremos o interpretador interativo do Python. Basta saber que os scripts deste documento poderiam ser executados com esse interpretador. Embora seja prático para testar o funcionamento de uma funcionalidade do Python, ele não é muito útil para scripts que precisam ser reutilizados. Aqui está um exemplo com a opção [4] mencionada acima:

O prompt >>> permite inserir uma instrução em Python que é executada imediatamente. O código digitado acima tem o seguinte significado:

>>> nom="tintin"
>>> print("nom=%s" % nom)
nom=tintin
>>> print("type=%s" % type(nom))
type=<class 'str'>
>>>

Linhas:

1: inicialização de uma variável. Em Python, não se declara o tipo das variáveis. Elas assumem automaticamente o tipo do valor que lhes é atribuído. Esse tipo pode mudar ao longo do tempo;
2: exibição do nome. 'nom=%s' é um formato de exibição em que %s é um parâmetro formal que designa uma sequência de caracteres. nom é o parâmetro efetivo que será exibido no lugar de %s;
3: o resultado da exibição;
4: exibição do tipo da variável nome;
5: a variável nom é, neste caso, do tipo class. No Python 2.7, ela teria o valor <type 'str'>;

Agora, vamos abrir um terminal do Windows:

O fato de termos conseguido digitar [python] em vez de [1] e de o executável [python.exe] ter sido encontrado mostra que ele está no diretório PATH da máquina Windows. Isso é importante porque significa que as ferramentas de desenvolvimento do Python conseguirão localizar o interpretador do Python. É possível verificar isso da seguinte forma:

no [2], saímos do interpretador Python;
em [3], o comando que exibe o PATH dos executáveis da máquina Windows;
em [4], percebe-se que a pasta do interpretador Python 3.8 faz parte do PATH;

2.2. O IDE PyCharm Community

2.2.1. Introdução

Para compilar e executar os scripts deste documento, utilizamos o editor [PyCharm], edição Community, disponível (fevereiro de 2020) no URL |https://www.jetbrains.com/fr-fr/pycharm/download/#seção=windows| :

Baixe o IDE, PyCharm e [1-3] (edição Community) e instale-os.

Vamos executar o IDE PyCharm e, em seguida, criar um primeiro projeto em Python:

no [2-4], crie um novo projeto;

O IDE PyCharm apresenta o projeto criado da seguinte forma:

no [2-3], vamos examinar as propriedades do IDE;

em [4], o interpretador Python que será utilizado para o projeto;
em [5], uma lista suspensa dos interpretadores disponíveis;
em [6], seleciona-se o interpretador baixado no parágrafo |Python 3.8.1|;

em [7], o interpretador selecionado;
em [8], a lista de pacotes disponíveis com esse interpretador. Os pacotes contêm módulos que os scripts Python podem utilizar. Existem centenas de módulos disponíveis;

Vamos começar criando uma pasta na qual colocaremos nosso primeiro script em Python:

clique com o botão direito do mouse no projeto e, em seguida, selecione [1-2] para criar uma pasta;
em [3], digite o nome da pasta: ela será criada na pasta do projeto;

Em seguida, vamos criar um script em Python:

clique com o botão direito do mouse na pasta [bases] e, em seguida, em [1-3];
em [4-5], digite o nome do script;

Vamos escrever nosso primeiro script:

no arquivo [3], escrevemos o seguinte script:
- linhas 1 e 3: os comentários começam com o sinal #;
- linha 2: inicialização de uma variável. O Python não declara o tipo de suas variáveis;
- linha 4: exibição na tela. A sintaxe usada aqui é [format % données] com:
  - formato: nome=%s, onde %s indica o local de uma sequência de caracteres. Essa sequência será encontrada na parte [données] da expressão;
  - dados: o valor da variável [nom] substituirá o formato %s na sequência de caracteres de formato;
- com [4-5], reformatamos o código de acordo com as recomendações do órgão responsável pelo Python;

O script é executado com um clique direito no código [6]:

em [7], o comando executado;
em [8], o resultado da execução;

Para executar o script do documento, baixe o código em URL |https://tahe.developpez.com/tutoriels-cours/python-flask-2020/documents/python-flask-2020.rar| e, em seguida, no PyCharm, proceda da seguinte forma:

em [1-2], ao abrir um projeto existente: selecione a pasta do código baixado;
no [3], o projeto aberto;
em [4-5], execução de um dos scripts do projeto;

em [7-8], os resultados da execução;

2.2.2. Ambiente virtual de execução

Nosso ambiente de trabalho já está operacional. No entanto, vamos modificá-lo para escrever os scripts deste curso. Primeiro, vamos alterar a configuração do Pycharm:

Na janela à direita:

por padrão, a caixa de seleção [1] está marcada. Desmarcamos essa opção para que o Pycharm não abra por padrão o último projeto aberto, mas nos permita escolher qual projeto deve ser aberto;
em [2], não confirmamos o encerramento do Pycharm ao fechar a janela do aplicativo;
em [3], os novos projetos são abertos em outra janela;
em [4], se fecharmos o PyCharm e houver um programa em execução, ele será interrompido;

Vamos agora fechar o PyCharm e reabri-lo:

no [1], cria-se um novo projeto;
em [2], indique a pasta do projeto;
No [3], utilize um ambiente virtual. Um ambiente virtual é específico do projeto que estamos criando. Ele não se mistura com os ambientes virtuais de outros projetos. Um projeto Python/Flask utiliza diversas bibliotecas externas que precisam ser instaladas. Um projeto P1 pode utilizar a biblioteca B na versão v1, enquanto um projeto P2 pode utilizar a mesma biblioteca B, mas na versão v2. Essas duas versões podem ser mais ou menos compatíveis. No entanto, quando se instala uma biblioteca na versão v2 e uma versão v1 já está instalada, esta é substituída pela versão v2. Isso pode ser problemático para o projeto que utilizava a versão v1, caso a nova versão v2 não seja totalmente compatível com a versão v1. Para evitar esses problemas, isola-se cada projeto em um ambiente virtual;
em [4], indique a pasta onde serão armazenadas as bibliotecas Python que serão baixadas ao longo do projeto. Escolhemos aqui uma pasta [venv] (ambiente virtual) dentro da pasta do projeto. Não é obrigatório fazer isso;
em [5], o interpretador Python do projeto. É aquele que instalamos na etapa anterior;
em [6], criar o projeto;

em [7-8], o projeto criado;
em [9], o ambiente de execução do projeto, chamado de ambiente virtual;
em [10], a pasta [site-packages] é a pasta na qual serão armazenadas as bibliotecas baixadas posteriormente;

2.2.3. Git

Em seguida, ativa-se um software de controle de código-fonte. Neste caso, será o Git [1-4]:

Um software de controle de código-fonte (VCS: Sistema de Controle de Versões) permite acompanhar as evoluções de um projeto. É possível registrar instantâneos do projeto, por meio de uma operação chamada commit, em diferentes momentos de seu ciclo de vida. Se forem feitos dois commits nos momentos T e T+1, o VCS permite identificar o que mudou entre as duas versões submetidas. Normalmente, o VCS é utilizado por uma equipe de desenvolvedores. Eles realizam commits de seu código quando este já foi devidamente testado. A partir do VCS, os demais desenvolvedores podem recuperar esse código validado e utilizá-lo.

Neste caso, há apenas um desenvolvedor. A experiência mostra que é possível ter um aplicativo que funciona no momento T e deixa de funcionar no momento T+1. Gostaríamos, então, de voltar ao momento T para recomeçar do zero. O VCS permite isso e é por essa razão que vamos usá-lo aqui.

Mostramos como proceder com o Git.

No [1], selecione a aba [Git] (no canto inferior esquerdo);
no [2], vemos que há 495 arquivos do projeto que não estão controlados pelo Git. Isso significa que eles não farão parte das versões do projeto durante os commits;
em [3], o botão de [commit] ou botão de validação do projeto. Conforme mencionado, o Git então captura um instantâneo do projeto e o armazena em uma pasta [.git] na raiz do projeto (não exibida pelo PyCharm, mas visível no Explorador do Windows);

Vamos validar o projeto em seu estado atual.

em [4], a lista de arquivos não versionados;
em [5], todos esses arquivos não versionados pertencem ao ambiente virtual [venv];
em [6], todo commit deve ser acompanhado de uma mensagem. O desenvolvedor descreve aqui as alterações introduzidas pela versão que será submetida em relação à última versão submetida;

Algumas pastas ou arquivos podem ser ignorados pelo Git. Nesse caso, eles nunca fazem parte do snapshot. No [5] acima, cliquemos com o botão direito do mouse na pasta [venv].

Em [1-3], indicamos que a pasta [venv] não deve fazer parte dos commits do Git. A lista de pastas e arquivos ignorados pelo Git é armazenada em um arquivo chamado [.gitignore] [4];

após a operação anterior, todos os arquivos da pasta [venv] desaparecem da lista de arquivos não versionados. Resta apenas o arquivo [.gitignore], que acabou de ser criado;
no [5], selecionamos esse arquivo para que seja salvo;
em [6], criamos uma mensagem de commit:
em [7], confirmamos. A foto do projeto é então tirada;

no arquivo [8-9], o conteúdo do arquivo [.gitignore]: uma única linha com o nome da pasta [/venv], indicando que seu conteúdo deve ser ignorado nas fotos;

Vamos mostrar agora como o Git pode nos ajudar. Primeiro, criamos uma pasta [git] (você pode usar qualquer outro nome – ela poderá ser excluída ao final da demonstração):

em [1-5], criamos uma pasta [git];

em [6-10], criamos um script Python [git_01];

em [11-12], o script contém apenas um comentário;
em [13-14], cria-se uma cópia de [git_01]. Para isso, selecione [git_01] e pressione Ctrl-C (Copiar), depois (Ctrl-V) (Colar) e indique [git_02] como nome do arquivo;

Agora, vamos fazer o commit do nosso projeto. Será tirada uma foto com os dois arquivos [git_01, git_02];

em [1-3], fazemos o commit do projeto;
em [4], selecionamos os arquivos não versionados que queremos fazer o commit, neste caso, todos;
no [5], insere-se a mensagem que identifica o commit;
em [6], confirma-se;

em [1-2], confirme o commit;
em [3], seleciona-se a aba [Log];
em [4], uma visualização dos ramos do projeto. Aqui, há apenas um ramo chamado [master];
em [5-6], o commit que acaba de ser realizado;

Agora, vamos criar, da mesma forma, um script [git_03]:

Vamos modificar o script [git_02] e excluir o script [git_01]:

Em seguida, vamos fazer o commit da nova versão:

Agora temos dois commits nos logs:

Ao selecionar um commit específico, aparece à direita a árvore de arquivos do projeto:

Agora, suponhamos que o último commit nos tenha levado a um impasse e que queiramos voltar a uma situação correspondente a um dos commits anteriores:

em [1-2], selecionamos o commit ao qual queremos retornar;
em [3-5], existem vários modos de reset. Escolhemos o modo [hard], que retorna ao estado selecionado, descartando as alterações feitas desde então;

em [6], recuperamos [git_01], que havia sido excluído;
em [7-8], recuperamos [git_02] em seu estado original, sem a modificação que havia sido feita;

Agora, vamos modificar o [git_02] e adicionar o [git_03] e o [1-4]:

Agora, vamos repetir a operação de voltar ao commit inicial:

em [1-4], voltamos à imagem do commit nº 1;
em [5-6], escolhemos a opção [Keep] em vez de [Hard]. Essas opções não são fáceis de entender. Por isso, é preciso testá-las:

em [1], o arquivo [git_03] ainda está lá;
ao converter para [2-3], o arquivo [git_02] manteve suas alterações;

É difícil dizer o que esse [Revert Commit] fez. Agora, vamos fazer o commit da situação atual:

no [1-6], o commit;

no [9], vemos o novo commit;

Agora, vamos tentar voltar ao commit 1, como já foi feito:

em [1-6], voltamos ao commit nº 1 no modo [Hard];

em [7-8], desta vez perdemos de fato todas as alterações feitas desde o primeiro commit;

Daqui em diante, não voltaremos mais a abordar o [Git]. O leitor poderá trabalhar da seguinte maneira:

poderá acompanhar os exemplos fornecidos, seja digitando-os ele mesmo, seja baixando-os do site do curso;
sempre que um exemplo funcionar, poderá fazer o commit do seu projeto;
quando estiver desenvolvendo seus próprios códigos e se deparar com um impasse, ele sabe que pode retornar a uma situação estável, revertendo para um commit anterior;

2.3. Convenções de escrita de código Python

É possível escrever código em Python sem seguir convenções de escrita, e isso não impedirá que ele funcione. Mas ele pode não ser bem recebido pela comunidade Python, que estabeleceu convenções de escrita. Elas estão resumidas em uma publicação no endereço |https://stackoverflow.com/questions/159720/what-is-the-naming-convention-in-python-for-variable-and-function-names|:

o nome de um módulo (module_name) segue uma convenção às vezes chamada de [snake_case]: todo em letras minúsculas, podendo conter palavras separadas pelo caractere sublinhado. Essa convenção [snake_case] se aplica a nomes de métodos, pacotes, variáveis e funções;
o nome de uma classe (ClassName) segue uma convenção às vezes chamada de [PascalCase]: uma sequência de palavras unidas, com a primeira letra de cada palavra em maiúscula;
os nomes das constantes seguem a convenção [SNAKE_CASE]: sequência de palavras em maiúsculas separadas pelo caractere de sublinhado;

Essas convenções foram seguidas de maneira geral neste documento. No entanto, para os módulos que definem uma classe, atribuí ao módulo o mesmo nome da classe que ele contém. Assim, ele segue a convenção [PascalCase] em vez de [snake_case]. Eu queria poder identificar rapidamente os módulos de classes.