Logo Passei Direto
Buscar
Material
páginas com resultados encontrados.
páginas com resultados encontrados.

Prévia do material em texto

Tema 2 - Paradigmas e Linguagem Python
SUMÁRIO
· 1. Classificando as linguagens de programação
· 1.1. Razões para estudarmos linguagens de programação
· 1.1.1. Linguagem de programação e produtividade do programador
· 1.1.2. O papel da abstração nas linguagens de programação
· 1.1.3. Por que estudar linguagens de programação?
· 1.2. Classificação das linguagens de programação por nível
· 1.2.1. Linguagem de baixo nível
· 1.2.2. Linguagem de alto nível
· 1.3. Classificação das linguagens de programação por gerações
· 1.3.1. Classificação por gerações
· 1.3.2. Linguagens de 1ª geração (linguagem de máquina)
· 1.3.3. Linguagens de 2ª geração (linguagem de montagem - Assembly)
· 1.3.4. Linguagens de 3ª geração (linguagens procedurais)
· 1.3.5. Linguagens de 4ª geração (linguagens aplicativas)
· 1.3.6. Linguagens de 5ª geração (linguagens declarativas)
· 2. Critérios de avaliação de linguagens de programação
· 2.1. Domínios da programação
· 2.1.1. Aplicações científicas (máquinas de calcular com alta precisão)
· 2.1.2. Aplicações comerciais
· 2.1.3. Aplicações com inteligência artificial
· 2.1.4. Programação de sistemas
· 2.1.5. Programação para Web
· 2.1.6. Programação mobile
· 2.2. Critérios para avaliação de linguagens de programação
· 2.2.1. Avaliação de linguagens de programação
· 2.2.2. Legibilidade
· 2.2.3. Facilidade de escrita (redigibilidade)
· 2.2.4. Confiabilidade
· 2.2.5. Custo
· 3. Paradigmas de linguagens de programação
· 3.1. Paradigma imperativo
· 3.1.1. Paradigma estruturado
· 3.1.2. Paradigma orientado a objetos
· 3.1.3. Paradigma concorrente
· 3.2. Paradigma declarativo
· 3.2.1. Paradigma funcional
· 3.2.2. Paradigma lógico
· 4. Métodos de implementação das linguagens
· 4.1. Tradução
· 4.1.1. Fases de tradução
· 4.1.2. Compilador e fases da compilação
· 4.1.3. Principais características dos compiladores
· 4.2. Interpretação e sistemas híbridos
· 4.2.1. Interpretação
· 4.2.2. Tradução (Compilação) x Interpretação
· 4.2.3. Sistemas híbridos
· 4.2.4. Sistema de implementação de Python
1. Classificando as linguagens de programação
1.1. Razões para estudarmos linguagens de programação
Estudar linguagens de programação é a base do desenvolvimento de software, essencial em várias áreas da ciência e da tecnologia. O domínio de diferentes linguagens e paradigmas capacita a escolha da ferramenta exata para a solução de problemas específicos, otimizando eficiência e eficácia técnica. 
1.1.1. Linguagem de programação e produtividade do programador
· Definição de software: Conjunto de instruções que orientam o hardware sobre o que deve ser executado. Divide-se em: 
· Software Aplicativo: Oferece facilidades ao usuário para tarefas cotidianas, laborais ou de lazer. 
· Software Básico: Programas essenciais ao funcionamento da própria máquina (ex.: sistemas operacionais). 
· Linguagem de programação: Classifica-se como um software básico que permite a escrita de outros programas. Representa um formalismo com símbolos, palavras reservadas, comandos e regras sintáticas e semânticas. 
· Programa-fonte e Linguagem de Máquina: O código redigido em uma linguagem chama-se programa-fonte. O hardware não o executa diretamente, pois só compreende linguagem binária/de máquina (sequências de bits 0 e 1). 
· Foco da produtividade: A facilidade de aprendizado, leitura e escrita somada ao domínio dos recursos superlativos da linguagem garantem códigos melhores e mais eficientes. 
· Impacto no pensamento: Conforme Edsger Dijkstra, uma linguagem de programação atua influenciando diretamente o próprio hábito de pensar do desenvolvedor. 
1.1.2. O papel da abstração nas linguagens de programação
· Conceito de abstração: Processo de identificar propriedades e qualidades relevantes para o contexto analisado, ignorando os detalhes irrelevantes. 
· Modelagem: Um programa é um modelo algorítmico abstrato da realidade. 
· Evolução histórica da abstração:
· Linguagem de máquina: Primeira forma de programar, binária, de alta complexidade e difícil memorização. 
· Assembly (anos 1950): Introduziu a abstração por nomes simbólicos (mnemônicos: ADD, SUB, MUL, DIV). Contudo, mantinha a paridade de 1 comando em Assembly para 1 instrução em linguagem de máquina, obrigando o desenvolvedor a pensar como a máquina. 
· Linguagens de alto nível: Criadas para afastar o programador da arquitetura física e aproximá-lo do raciocínio humano. Por exemplo, uma rotina de troca (swap) em Python necessita de apenas 3 instruções ativas, enquanto em Assembly e em linguagem de máquina exige 7 instruções. 
· Hierarquia das camadas de abstração:
· Nível 1: Hardware (circuitos eletrônicos). 
· Nível 2: Linguagem de máquina (bits 0 e 1, nativa do hardware). 
· Nível 3: Linguagem Assembly (mnemônicos). 
· Nível 4: Linguagens de alto nível (próximas ao raciocínio humano e distantes da máquina; ex.: Python, Java). 
1.1.3. Por que estudar linguagens de programação?
· Melhora a capacidade de conceber soluções algorítmicas. 
· Aprimora a habilidade de uso dos recursos da linguagem (como optar por iteração em vez de recursão para maior eficiência de desempenho). 
· Aumenta o acerto na escolha da linguagem adequada ao problema (ex.: optar por C quando há necessidade de acessos velozes a vetores sem checagem dinâmica). 
· Facilita o aprendizado de novas tecnologias (o domínio da orientação a objetos acelera o aprendizado de C++, C#, Java e Python). 
· Reduz limitações conceituais de projeto. 
· Habilita o profissional a projetar novas linguagens de programação. 
· Amplia os processos mentais e a capacidade de expressar ideias técnicas. 
1.2. Classificação das linguagens de programação por nível
1.2.1. Linguagem de baixo nível
· São linguagens intimamente vinculadas à arquitetura do processador, comunicando-se diretamente com hardware, memória e registradores. 
· Variam conforme o conjunto de instruções específico de cada processador (instruction set). 
· Instruções de máquina dividem-se em campos binários (ex.: código de operação e endereços de operandos). 
· A linguagem Assembly utiliza mnemônicos para manipular diretamente valores em registradores (ex.: MOV, ADD), exigindo conversão direta para binário. Ficam distantes da linguagem humana. 
1.2.2. Linguagem de alto nível
· Afastam-se da máquina e aproximam-se da linguagem humana escrita (majoritariamente em inglês). 
· O desenvolvedor não precisa conhecer detalhes internos de hardware; os conceitos são abstraídos. 
· Cada comando de alto nível é convertido internamente em múltiplas instruções primárias do processador, reduzindo drasticamente o volume de código digitado. 
· Exemplos: Python, Java, C#, Pascal, Delphi, JavaScript, PHP, Ruby, entre outras. 
· Classificações complementares:
· Médio nível: Termo usado por certos autores para designar C e C++, pois combinam sintaxe de alto nível com operadores de acesso direto à memória e registradores. 
· Altíssimo nível: Linguagens como Python, Ruby e Elixir, devido ao vasto ecossistema de bibliotecas e facilidade para iniciantes. 
1.3. Classificação das linguagens de programação por gerações
1.3.1. Classificação por gerações
 Divisão histórica (geralmente dividida em 5 gerações, havendo vertentes que citam uma 6ª), em que cada nova geração incorpora recursos adicionais para aumentar o poder de abstração e a produtividade. 
1.3.2. Linguagens de 1ª geração (linguagem de máquina)
· Códigos binários puros executados diretamente pelo processador. 
· Nível mínimo de abstração, totalmente dependentes da arquitetura. 
· Programação de extrema complexidade e alta propensão a erros, apesar de muito veloz. 
1.3.3. Linguagens de 2ª geração (linguagem de montagem - Assembly)
· Substituição de números binários por mnemônicos simbólicos legíveis. 
· Necessitam de um programa montador (Assembler) para converter as sentenças em linguagem de máquina. 
· Exigem domínio de endereçamento, registradores e arquitetura da CPU. 
1.3.4. Linguagens de 3ª geração (linguagens procedurais)
· Linguagens de alto nívelScripts esteja configurado na variável de ambiente PATH do sistema operacional. 
· Ambientes Virtuais (virtualenvs): Estruturas que isolam as dependências de cada projeto, evitando conflitos de versões e mantendo o ambiente de desenvolvimento organizado. 
· Principais pacotes do mercado:
· numpy: Cálculos matemáticos de alta performance, matrizes e computação numérica. 
· pandas: Manipulação e análise estruturada de conjuntos de dados. 
· scikit-learn: Modelagem estatística e algoritmos de aprendizado de máquina (machine learning). 
· matplotlib: Geração e plotagem gráfica de visualização de dados. 
· requests: Envio de requisições HTTP e consumo de APIs web. 
· flask: Criação de servidores e aplicações web enxutas. 
3.5.2. Criação do próprio módulo
 
 Desenvolvedores podem estruturar suas próprias funções em arquivos .py independentes. Para importar o módulo sem configurações adicionais, basta manter o arquivo na mesma pasta do script principal e chamá-lo com a instrução import. 
4. Eventos em Python
4.1. Erros em um programa Python
4.1.1. Erros e exceções
Os problemas de execução em Python dividem-se em duas categorias básicas: 
1. Erros de sintaxe: Ocorrem quando o código desobedece às regras gramaticais da linguagem. São detectados previamente pelo analisador sintático (parser) durante a carga inicial do código. 
2. Exceções em tempo de execução: Ocorrem durante a execução ativa do código quando o programa atinge um estado inconsistente ou inválido. Nesse momento, o interpretador "levanta" (raises) um objeto de exceção com os dados do problema. 
· Hierarquia das exceções: Exceções derivam da classe primordial BaseException. A maioria das exceções comuns deriva de sua subclasse principal: Exception. 
· Principais exceções nativas:
· KeyboardInterrupt: Usuário envia sinal de interrupção manual pelo teclado (CTRL+C). 
· OverflowError: Expressão em ponto flutuante ultrapassa o limite máximo suportado. 
· ZeroDivisionError: Tentativa de divisão aritmética por zero. 
· IOError: Falha em rotina de entrada/saída (como acesso a disco ou comunicação de arquivos). 
· IndexError: Tentativa de acesso a um índice sequencial inexistente ou fora dos limites válidos. 
· NameError: Referência a um identificador ou variável que não foi atribuído. 
· TypeError: Operador ou função aplicado a um tipo incompatível de objeto. 
· ValueError: Operação aplicada a um tipo correto de dado, porém contendo um valor inadequado. 
4.2. Erros e exceções na prática
4.2.1. Roteiro de prática
 Diagnóstico e correção de falhas comuns em tempo de execução: tratamento de conversões inválidas com int(), tratamento de erros em operações numéricas e prevenção contra falhas de acesso a posições inexistentes em listas. 
4.3. Tratamento de exceções e eventos
4.3.1. Captura e manipulação de exceções
 Mecanismo que previne o término inesperado do programa por falhas em tempo de execução. Utiliza os blocos try e except: 
· Bloco try: Contém as instruções do fluxo normal do programa passíveis de falha. 
· Bloco except: Manipulador de exceção que executa rotinas de recuperação caso um erro ocorra dentro do try. 
4.3.2. Captura de exceções de determinado tipo
 Especifica a classe do erro no bloco de captura (ex.: except NameError:). O bloco só é acionado se a exceção ocorrida coincidir exatamente com o tipo declarado. 
4.3.3. Captura de exceções de múltiplos tipos
 Permite encadear vários blocos except após o mesmo try para definir tratamentos distintos para cada erro (como except ValueError: para entradas inválidas e except IndexError: para limites violados). Um bloco except genérico ao final captura eventuais erros não tratados nos blocos anteriores. 
4.3.4. O tratamento completo das exceções
 Estrutura completa com as cláusulas opcionais adicionais: 
Python
try:
 # Bloco do fluxo normal
except TipoDeErro:
 # Manipulador de exceção
else:
 # Executado apenas se o bloco try terminar SEM lançar exceções
finally:
 # Executado SEMPRE ao final, havendo ou não ocorrido exceções
As cláusulas else e finally são complementares e opcionais. 
4.3.5. Tratamento de eventos
 Notificações geradas pelo sistema operacional ou pelo usuário por meio de interações com periféricos (como cliques de mouse, rolagem de cursor ou teclas pressionadas em uma GUI). O tratador de evento é o segmento de código executado como resposta funcional direta ao evento capturado. 
4.4. Tratamento de exceções na prática
4.4.1. Roteiro de prática
 Adaptação de rotinas aritméticas de cálculo de divisão com validações pontuais em try/except: tratamento de entradas não numéricas via ValueError e prevenção de operações impossíveis via ZeroDivisionError. 
4.5. Tratamento de eventos na prática
4.5.1. Roteiro de prática
· Mapeamento de cursor via tkinter: Uso do método .bind() para monitorar o deslocamento contínuo do mouse dentro da janela e atualizar coordenadas textuais na tela. 
· Captura de botões do mouse: Associação de rotinas disparadas por eventos de clique do botão esquerdo () e do botão direito (), exibindo mensagens de resposta a cada clique do usuário. 
Tema 5 - Python Orientado a Objetos
SUMÁRIO
· 1. Orientação a objetos
· 1.1. Conceitos e pilares de programação orientada a objetos
· 1.1.1. Conceitos de programação orientada a objetos (POO)
· 1.1.2. Pilares da orientação a objetos
· 1.2. O conceito de classe
· 1.3. O conceito de encapsulamento
· 1.4. O conceito de herança e polimorfismo
· 1.4.1. Herança
· 1.4.2. Polimorfismo
· 2. Orientação a objetos na linguagem Python
· 2.1. Classes e objetos
· 2.1.1. Definição de classe
· 2.1.2. Construtores e self
· 2.1.3. Métodos
· 2.1.4. Métodos com retorno
· 2.1.5. Referências entre objetos na memória
· 2.2. Classes e objetos na prática
· 2.2.1. Roteiro de prática
· 2.3. Tipos de associação entre objetos
· 2.3.1. Agregação
· 2.3.2. Composição
· 2.4. Integridade dos objetos: encapsulamento
· 2.4.1. Encapsulamento
· 2.4.2. Atributos públicos e privados
· 2.4.3. Decorator @property
· 2.4.4. Atributos de classe
· 2.4.5. Métodos de classe
· 2.4.6. Métodos públicos e privados
· 2.4.7. Métodos estáticos
· 2.5. Associação entre objetos e encapsulamento na prática
· 2.5.1. Roteiro de prática
· 3. Orientação a objetos com herança e polimorfismo
· 3.1. Herança
· 3.1.1. Implementando herança
· 3.1.2. Herança múltipla
· 3.2. Polimorfismo
· 3.2.1. Implementando polimorfismo
· 3.3. Herança e polimorfismo na prática
· 3.3.1. Roteiro de prática
· 3.4. Classe abstrata e classe para tratamento de exceções
· 3.4.1. Classes abstratas
· 3.4.2. Tratamento de Exceções em Python: Conceitos e Práticas
· 3.5. Classes abstratas e tratamento de exceções na prática
· 3.5.1. Roteiro de prática
1. Orientação a objetos
1.1. Conceitos e pilares de programação orientada a objetos
1.1.1. Conceitos de programação orientada a objetos (POO)
 A programação orientada a objetos (POO) representou uma transformação estrutural na construção de software por aproximar a análise computacional dos conceitos e comportamentos do mundo real. Em vez de focar primariamente na codificação dependente da máquina, a tecnologia de objetos estabelece uma forma de abstrair problemas utilizando conceitos da realidade. 
· Continuidade de notação: Permite usar a mesma conceituação durante todas as etapas do ciclo de desenvolvimento, eliminando a necessidade de traduzir modelos entre as fases de análise, projeto e implementação. 
· Diferença entre POO e programação convencional: Na abordagem tradicional/convencional, a estrutura dos dados e os algoritmos (comportamento) possuem pouca vinculação direta. Na POO, o sistema é organizado em uma coleção integrada de objetos autônomos que agrupam simultaneamente a estrutura (dados) e o comportamento correspondente, tornando o sistema adaptável e de fácil manutenção. 
1.1.2. Pilares da orientação a objetos
· Objetos: Representação computacional de uma entidade ou processo do mundo real (ex.: Aluno, Professor, Livro, Locação). Cadaobjeto reúne suas informações particulares e um grupo de operações responsáveis por manipular seu estado interno. 
· Abstração: Durante a modelagem de um sistema, filtram-se unicamente os objetos essenciais e as características relevantes ao contexto (por exemplo, um sistema acadêmico foca na formação acadêmica e filiação, enquanto o sistema de uma academia de ginástica enfatiza altura e peso). 
· Atributos: Propriedades e características descritivas do mundo real mapeadas para o objeto. O conjunto momentâneo de valores atribuídos a essas propriedades define o estado do objeto naquele instante. 
· Operações: Funções, procedimentos ou transformações que atuam diretamente sobre os dados do objeto, alterando seu estado interno. 
· Interface: O conjunto público de operações exposto por um objeto constitui sua interface, sendo o único canal formal por meio do qual outros objetos podem interagir e colaborar entre si. 
· Mapeamento do mundo real para o computacional:
· Características do mundo real transformam-se em atributos computacionais. 
· Comportamentos do mundo real transformam-se em operações computacionais. 
1.2. O conceito de classe
 A classe constitui o molde ou projeto (blueprint) que define estruturalmente as características e comportamentos de um grupo de objetos afins. 
· Instanciação: Em tempo de execução, os objetos são criados a partir do molde de sua classe. Portanto, um objeto é chamado tecnicamente de instância de uma classe. 
· Escopo de nomes: Os identificadores de atributos são únicos no escopo interno da sua classe, mas classes diferentes podem ter atributos com o mesmo nome (ex.: classes Pessoa e Empresa contendo o atributo Endereco). 
· Colaboração e troca de mensagens: A resolução de tarefas em sistemas orientados a objetos ocorre pela interação entre objetos via troca de mensagens. O envio de uma mensagem equivale à solicitação de execução de uma operação específica disponibilizada pela interface do objeto receptor (ex.: o objeto motorista1 envia a mensagem "Freia" para o objeto carro1, que executa a operação interna de frenagem e diminui seu atributo velocidade). 
1.3. O conceito de encapsulamento
 O encapsulamento consiste em isolar e ocultar os detalhes internos de implementação de um objeto, expondo aos demais objetos exclusivamente sua interface pública de operações. 
· Princípio do ocultamento de informação: As classes devem revelar o mínimo possível sobre suas estruturas internas e armazenamento. 
· Independência evolutiva: Se a lógica interna de uma operação for modificada para otimizar um cálculo (ex.: o método CalculaMelhorCaminho de um objeto Mapa), essa alteração não impacta os objetos externos que o consomem (como o objeto ApresentacaoMapa), desde que a interface externa permaneça inalterada. 
· Os objetos consumidores (clientes) conhecem apenas o que uma operação faz por meio de sua assinatura, e não como ela é processada internamente. 
1.4. O conceito de herança e polimorfismo
1.4.1. Herança
 Mecanismo que permite a uma classe herdeira adquirir atributos e operações definidos em uma superclasse, organizando-as em hierarquias conceituais. 
· Reutilização de código: Permite reaproveitar integralmente a estrutura da superclasse (classe-pai) e concentrar a codificação da subclasse (classe-filha) exclusivamente nos comportamentos e dados especializados. 
· Herança simples: Ocorre quando uma subclasse herda diretamente de uma única superclasse (ex.: a classe Professor herdando os atributos gerais de Pessoa, acrescentando dados como titularidade e salario). 
· Herança múltipla: Ocorre quando uma subclasse descende simultaneamente de duas ou mais superclasses distintas (ex.: a classe ProfessorAluno herdando cumulativamente atributos e operações de Professor e de Aluno, introduzindo regras próprias como Desconto Professor). 
1.4.2. Polimorfismo
 Expressa a capacidade de uma mesma operação ser acionada em objetos de diferentes classes e produzir comportamentos adaptados a cada classe concreta. 
· Ocorre principalmente quando subclasses reimplementam (override) métodos herdados de sua hierarquia. 
· O objeto chamador emite a mesma mensagem e o objeto receptor executa a ação conforme sua definição específica (ex.: acionar o método mover() resulta em voo para a classe Aereo e em tração sobre rodas para a classe Terrestre). 
2. Orientação a objetos na linguagem Python
2.1. Classes e objetos
2.1.1. Definição de classe
 Em Python, uma classe é declarada com a palavra reservada class seguida de seu identificador e de dois pontos :. 
· Boas práticas de organização: Cada classe deve ser preferencialmente implementada em seu próprio arquivo de extensão .py com nome equivalente (ex.: a classe Conta armazenada no arquivo Conta.py). 
· Comando pass: Pode ser utilizado no corpo de uma classe em construção para atuar como marcador de posição estruturalmente válido, permitindo que o arquivo seja executado sem erros sintáticos de bloco vazio. 
2.1.2. Construtores e self
 A instanciação de objetos em Python ocorre por um processo em duas etapas gerenciado pelo interpretador: 
1. Método __new__: Responsável pela criação física da instância na memória (usado para manipulação dinâmica de classes em frameworks e metaclasses). 
2. Método __init__: Executado logo após a criação da instância, atuando como o construtor formal de inicialização dos valores de atributos do objeto. 
· O parâmetro self: Representa a referência explícita à própria instância do objeto que está executando o método ou sendo inicializada. Por convenção sintática estrita, o self deve ser declarado como o primeiro argumento dos métodos de instância. 
· Criação de atributos: Expressões como self.numero = numero vinculam o identificador numero como um atributo individual e interno daquela instância. O método construtor não é de declaração obrigatória caso a classe não demande rotinas de inicialização de dados. 
2.1.3. Métodos
 Blocos funcionais pertencentes à classe cuja finalidade é processar informações e atualizar o estado dos atributos do objeto. 
· Os métodos de instância recebem obrigatoriamente a referência self no primeiro argumento e podem aceitar parâmetros adicionais de negócio (ex.: método depositar(self, valor) somando montantes ao saldo referenciado por self.saldo). 
· A execução consecutiva de métodos como depositar() e sacar() modifica dinamicamente os valores dos atributos internos ao longo do ciclo de vida da instância. 
2.1.4. Métodos com retorno
Métodos podem utilizar a cláusula return para devolver valores computados ou indicadores de sucesso operacional baseados na avaliação do estado da instância. 
· Em regras de negócio bancárias, caso uma tentativa de saque exceda o valor disponível em self.saldo, o método sacar() pode retornar False, bloqueando a transação e sinalizando falha ao chamador. 
2.1.5. Referências entre objetos na memória
 Variáveis associadas a instâncias de classes não guardam os objetos diretamente, mas armazenam referências que apontam para o endereço daquele objeto na memória RAM. 
· Operadores de comparação:
· O operador de identidade/igualdade == ou != compara se duas variáveis de referência apontam para a mesma região física de memória. 
· Duas instâncias independentes instanciadas separadamente apontam para endereços distintos, mesmo que contenham atributos com valores idênticos. 
· Atribuição de referências: Ao declarar conta1 = conta2, o interpretador copia o endereço de memória, fazendo com que ambas as variáveis referenciem exatamente o mesmo objeto na memória física. 
· Transferência entre objetos: Na passagem de um objeto como parâmetro (ex.: conta1.transfereValor(conta2, 500)), o método receptor recebe a referência direta da instância de destino, permitindo manipular seu estado na memória compartilhada. 
2.2. Classes e objetos na prática
2.2.1. Roteiro de prática
 Construção de uma classe Televisao contendo método construtor __init__ parametrizado para registrar canal inicial, canal mínimo e canal máximo. Implementaçãode métodos operacionais para alterar canais sintonizados para cima e para baixo, validando limites e realizando testes de troca de canal em múltiplas instâncias. 
2.3. Tipos de associação entre objetos
 A associação permite que diferentes classes cooperem para resolver problemas do mundo real. Divide-se conceitualmente em agregação e composição. 
2.3.1. Agregação
 Relacionamento estrutural fraco no qual uma classe agrega referências a objetos de outra classe sem exercer posse absoluta sobre seus ciclos de vida. 
· Semântica UML: Representada por um losango vazado. 
· Independência: Os objetos agregados existem de forma independente do objeto agregador. Se a classe agregadora for excluída, os objetos associados permanecem íntegros na memória. 
· Exemplo: Uma classe Conta que gerencia contas conjuntas agrega referências a objetos independentes da classe Cliente. Os clientes podem existir no sistema de forma autônoma. 
2.3.2. Composição
 Relacionamento estrutural forte no qual uma classe contenedora possui diretamente as instâncias das classes componentes como partes integrantes de si mesma. 
· Semântica UML: Representada por um losango preenchido. 
· Dependência existencial: Os ciclos de vida dos componentes dependem integralmente do objeto composto. Destruir o objeto principal implica a destruição automática das partes internas que o compõem. 
· Exemplo: A classe Conta cria e gerencia internamente uma instância da classe Extrato em seu próprio construtor. O extrato e sua lista de transações não possuem existência independente fora do ciclo de vida daquela conta. 
2.4. Integridade dos objetos: encapsulamento
2.4.1. Encapsulamento
 Prática projetada para garantir a consistência das entidades, impedindo que partes externas do sistema alterem estados dos atributos diretamente e violem regras de negócio (como atribuir valores negativos ao saldo sem passar pelas validações do método de saque). 
2.4.2. Atributos públicos e privados
· Padrão em Python: Por padrão, todos os atributos e métodos declarados em uma classe são públicos, acessíveis livremente fora dela. 
· Declaração de membros privados: Para indicar que um atributo é privado, deve-se prefixar seu identificador com dois underscores (ex.: __saldo). Tentativas convencionais de acesso direto a objeto.__saldo resultam em erro em tempo de execução (AttributeError). 
· Mecanismo de Name Mangling (desfiguração de nomes): Em nível de implementação interna, Python não bloqueia o acesso físico ao atributo, mas renomeia a variável internamente para o padrão _NomeDaClasse__nomeDoAtributo (ex.: _Conta__saldo). Apesar de tecnicamente acessível via sintaxe desfigurada, o acesso direto a atributos privados viola as convenções de boas práticas da POO. 
2.4.3. Decorator @property
 Mecanismo que permite expor o acesso a atributos protegidos por meio de métodos decorados, oferecendo uma interface semântica de atributo sem abrir mão do controle funcional: 
· Getter (@property): Decora um método com o mesmo nome do atributo para expor sua leitura de forma controlada. 
· Setter (@.setter): Decora o método responsável por receber e validar novos valores antes de atribuí-los à variável interna privada (ex.: verificar se um novo saldo é negativo antes de gravá-lo). 
· Diretriz de uso: A criação de properties é recomendada quando existem validações ou regras de negócio associadas ao dado; quando não houver regras, pode-se manter o acesso direto aos membros da classe. 
2.4.4. Atributos de classe
Variáveis cujos valores pertencem à classe como um todo, sendo compartilhados igualmente por todas as instâncias existentes. 
· São declaradas no corpo da classe fora de qualquer método (antes do construtor __init__). 
· Diferenciam-se de atributos de instância por manterem uma única alocação de memória para toda a classe. 
· Aplicação: Contabilizar o número de instâncias criadas (ex.: a cada execução de __init__ na classe Circulo, o atributo Circulo.total_circulos é incrementado em uma unidade). 
· Encapsulamento de classe: Devem ser preferencialmente protegidos prefixando o nome com sublinhado (_total_circulos) para evitar mutações diretas fora do escopo da classe. 
2.4.5. Métodos de classe
 Métodos destinados a manipular diretamente a área de memória correspondente aos atributos de classe. 
· São definidos utilizando o decorador @classmethod. 
· Recebem a referência à própria classe como seu primeiro argumento (frequentemente capturada via chamada cls ou por type(self)), permitindo compatibilidade polimórfica quando acessados em subclasses. 
2.4.6. Métodos públicos e privados
 As convenções aplicadas aos atributos valem igualmente para a visibilidade dos métodos: 
· Métodos prefixados por dois underscores (ex.: def __gerarsaldo(self):) configuram-se como métodos privados. 
· Devem ser chamados unicamente de forma interna por outros métodos da própria classe, estruturando o padrão de métodos públicos e atributos privados. 
2.4.7. Métodos estáticos
Métodos que não recebem referências implícitas da instância (self) nem da classe (cls), comportando-se como funções utilitárias isoladas abrigadas no escopo nominal da classe. 
· São definidos utilizando o decorador @staticmethod. 
· Podem ser chamados diretamente a partir do identificador da classe, sem necessidade de instanciar nenhum objeto (ex.: Math.sqrt(20)). 
· Devem ser utilizados com moderação na POO, restringindo-se a propósitos utilitários específicos (como geradores de log e funções matemáticas acessórias). 
2.5. Associação entre objetos e encapsulamento na prática
2.5.1. Roteiro de prática
· Cenário 1 (Agregação): Construção da classe Livro (atributos titulo, autor e isbn) e da classe Biblioteca (contendo uma lista interna agregando instâncias de livros). Implementação de rotinas para adicionar, remover e listar coleções de obras bibliográficas de forma desacoplada. 
· Cenário 2 (Métodos de Classe e Estáticos): Construção da classe Pessoa utilizando o módulo datetime. Definição de método de classe (@classmethod) atuando como construtor alternativo que calcula a idade a partir do ano de nascimento informado, associado a um método estático (@staticmethod) que avalia se a pessoa é maior de idade sem depender de instâncias ativas. 
3. Orientação a objetos com herança e polimorfismo
3.1. Herança
3.1.1. Implementando herança
 A herança viabiliza estender funcionalidades de classes-base sem duplicar implementações existentes. 
· A sintaxe de declaração em Python define a superclasse entre parênteses logo após o identificador da classe-filha: class ContaEspecial(Conta):. 
· A função super(): Função embutida que acessa e invoca métodos da superclasse a partir do corpo da subclasse. Permite reaproveitar integralmente o construtor original (ex.: super().__init__(numero, cpf, nomeTitular, saldo)) enquanto a subclasse inicializa apenas seus atributos exclusivos (como o atributo limite). 
· Sobrescrita de métodos (override): Redefinição de um método herdado na classe-filha com uma implementação especializada (ex.: reescrever o método sacar() para permitir que o cliente realize saques até o limite de crédito adicional disponibilizado). 
3.1.2. Herança múltipla
 Recurso no qual uma classe herda simultaneamente de duas ou mais superclasses distintas (ex.: class ContaRemuneradaPoupanca(Conta, Poupanca):). 
· Chamada aos construtores pais: Na inicialização de classes sob herança múltipla, os construtores de cada uma das superclasses devem ser invocados explicitamente através do formato NomeDaClasse.__init__(self, ...). 
· Ordem de resolução de métodos (MRO): A declaração das superclasses dentro dos parênteses define a prioridade de resolução. Caso duas superclasses possuam métodos com nomes idênticos, o interpretador Python prioriza a implementação da classe declarada primeiro na lista de herança. 
· Exemplo do sistema bancário: A classe ContaRemuneradaPoupanca unifica atributos e regras operacionais da conta-corrente tradicional com as taxas de rendimento de Poupanca,aplicando cálculos de rentabilidade diária ajustada. 
3.2. Polimorfismo
3.2.1. Implementando polimorfismo
 O polimorfismo viabiliza que chamadas de método com nomes idênticos atuem de formas distintas conforme o tipo dinâmico do objeto receptor. 
· Vinculação tardia (late binding): A resolução de qual implementação deve ser executada é decidida pelo interpretador dinamicamente em tempo de execução. 
· O princípio de substituição ("É-UM"): Subclasses são tratadas indistintamente como instâncias válidas da sua superclasse. Um método projetado para processar um objeto da classe ContaCliente aceita perfeitamente objetos de classes derivadas como ContaComum ou ContaRemunerada. 
· Mecanismo de resolução dinâmica: Em estruturas onde diversas contas especializadas residem em uma mesma coleção, laços de repetição que executam c.CalculoRendimento() invocam transparentemente a implementação própria de cada tipo de conta (como descontos diferenciados de IR e IOF), sem a necessidade de o desenvolvedor realizar checagens manuais de tipo condicional. Caso a subclasse não tenha sobrescrito o método, a chamada sobe na hierarquia e executa a implementação da superclasse. 
3.3. Herança e polimorfismo na prática
3.3.1. Roteiro de prática
· Estruturação de hierarquia de animais criando a classe base Animal contendo métodos abstratos para falar() e mover(). 
· Criação de subclasses (Cachorro, Gato, Vaca) que especializam esses métodos emitindo comportamentos e sons particulares. 
· Utilização de herança múltipla combinando classes de capacidades de locomoção (Voador e Nadador) para derivar a classe especializada Pato, que unifica capacidades funcionais de nadar, voar e caminhar. 
3.4. Classe abstrata e classe para tratamento de exceções
3.4.1. Classes abstratas
Classes concebidas para atuar unicamente como contratos e moldes estruturais, sendo proibida a sua instanciação direta na memória do programa. 
· Servem para padronizar interfaces conceituais em hierarquias onde apenas as subclasses concretas devem ser instanciadas. 
· Módulo abc (Abstract Base Classes): Para tornar uma classe abstrata em Python, deve-se herdar da superclasse primordial ABC. 
· O decorator @abstractmethod: Identifica os métodos abstratos da classe. Uma classe abstrata exige a declaração de ao menos um método decorado com @abstractmethod. 
· Obrigatoriedade de implementação: Subclasses derivadas devem obrigatoriamente sobrescrever e implementar todos os métodos abstratos da classe-pai. Se uma subclasse falhar em implementar um desses métodos, ela também será considerada abstrata pelo Python e lançará uma exceção do tipo TypeError caso sofra tentativas diretas de instanciação. 
3.4.2. Tratamento de Exceções em Python: Conceitos e Práticas
· Conceito de exceções: Eventos anômalos levantados durante o fluxo de execução que interrompem o funcionamento do sistema caso não sejam interceptados. 
· Captura controlada: Utiliza os blocos try...except para monitorar operações sensíveis (como capturar o erro ZeroDivisionError em divisões numéricas com divisor nulo), exibindo respostas controladas e impedindo a interrupção abrupta da aplicação. 
· Criação de exceções personalizadas: Classes de erros específicas criadas a partir da herança da classe nativa Exception. Permitem sinalizar falhas semânticas da própria regra de negócio da aplicação (ex.: class ExcecaoCustomizada(Exception): pass). 
· Lançamento explícito (raise): A palavra reservada raise interrompe a execução normal de uma função e dispara uma exceção quando um estado inconsistente é identificado (como valores numéricos negativos em operações que exigem valores estritamente positivos). Essas exceções customizadas podem ser capturadas por blocos try...except específicos no código consumidor. 
3.5. Classes abstratas e tratamento de exceções na prática
3.5.1. Roteiro de prática
· Cenário 1: Criação da classe abstrata Veiculo (herdando de ABC com os métodos abstratos decorados mover() e ligar()) e fornecimento de implementações concretas especializadas por meio das subclasses Carro e Bicicleta. 
· Cenário 2: Construção de uma classe Calculadora que reúne métodos para adição, subtração, multiplicação e divisão. Incorporação de blocos try...except para capturar tipos de dados inválidos (TypeError) e impedir erros de execução decorrentes de divisão por zero (ZeroDivisionError).para uso geral alinhadas à programação estruturada (ex.: Fortran, BASIC, COBOL, C, Pascal). 
· Uma instrução humana mapeia múltiplas instruções binárias. 
· Propriedades comuns:
· Suporte a dados estáticos simples, enumerados e tipos estruturados (matrizes, vetores, registros). 
· Alocação de memória dinâmica via ponteiros. 
· Estruturas de controle de fluxo: sequencial, condicional, repetição e desvio incondicional. 
· Modularização através de sub-rotinas (funções e procedimentos) com passagem de parâmetros. 
· Presença de operadores lógicos, relacionais e aritméticos. 
· Foco centrado em simplicidade e eficiência de execução. 
1.3.5. Linguagens de 4ª geração (linguagens aplicativas)
· Linguagens não procedurais voltadas a domínios de aplicação específicos. 
· O foco desloca-se do "como fazer" (especificação detalhada dos passos) para "o que fazer". 
· Exemplo central: SQL (Structured Query Language), além de PostScript e MATLAB. 
1.3.6. Linguagens de 5ª geração (linguagens declarativas)
· Linguagens não algorítmicas fundamentadas em lógica e declaração de restrições (ex.: Prolog, Lisp). 
· Voltadas para sistemas especialistas, inferência lógica, reconhecimento de voz e aprendizagem de máquina (machine learning). 
· Nota sobre 6ª geração: Certos autores associam uma sexta geração ao avanço das redes neurais e processamento neural artificial. 
2. Critérios de avaliação de linguagens de programação
2.1. Domínios da programação
2.1.1. Aplicações científicas (máquinas de calcular com alta precisão)
· Iniciou-se com sistemas como o ENIAC (1946) para cálculo balístico e tabelas científicas. 
· Demandam aritmética de precisão em ponto flutuante e manipulação matricial básica. 
· Fortran e ALGOL60 destacaram-se como as principais linguagens precursoras nesse domínio, sucedendo o Assembly com foco em alto desempenho numérico. 
2.1.2. Aplicações comerciais
· Expansão nos anos 1950 com foco em operações administrativas corporativas. 
· COBOL (1960) tornou-se a referência. 
· Foco técnico: emissão detalhada de relatórios, precisão em valores decimais monetários e operações aritméticas financeiras, popularizando-se com os microcomputadores nos anos 1980. 
2.1.3. Aplicações com inteligência artificial
· Baseadas em computação simbólica ao invés de numérica. 
· Marcos: Lisp (1959, paradigma funcional e computação simbólica) e Prolog (1977, programação em lógica e suporte a sistemas especialistas). 
2.1.4. Programação de sistemas
· Linguagens com comandos para comunicação e controle direto de componentes de hardware sem overhead. 
· Criação de softwares básicos (sistemas operacionais, compiladores e interpretadores). 
· Destaques: Assembly (originalmente) e linguagens como C e C++ (C foi criada visando o desenvolvimento do Unix). 
2.1.5. Programação para Web
· Deslocou o processamento antes concentrado em ambientes locais de desktops para redes distribuídas em três camadas: apresentação, lógica de negócio e persistência. 
· Camada de apresentação (lado cliente/navegador): HTML (marcação), CSS (estilo visual) e JavaScript (scripts interativos). 
· Camada de lógica do negócio (lado servidor): C#, PHP, ASP.NET, Java, Ruby e Python. 
2.1.6. Programação mobile
· Desenvolvimento voltado para dispositivos móveis, funcionando como interfaces conectadas a servidores. 
· Ambientes suportados:
· Android: Oficialmente suporta Kotlin, Java e C++ (via Android SDK), além do uso de Python, Go, Unity, Shell, etc. 
· iOS: Baseado na IDE Xcode, tem como padrões oficiais Swift e Objective-C, suportando também outras linguagens. 
· Windows: Emprega C#, VB, C++, JavaScript e ferramentas como o App Studio. 
· Plataformas conectadas em nuvem oferecem suporte a compilações multiplataforma integradas. 
2.2. Critérios para avaliação de linguagens de programação
2.2.1. Avaliação de linguagens de programação
 Segundo Robert Sebesta (2018), a análise qualitativa das linguagens baseia-se em quatro critérios fundamentais: Legibilidade, Facilidade de Escrita, Confiabilidade e Custo. 
2.2.2. Legibilidade
 Mede a facilidade com que o código-fonte pode ser lido, interpretado e compreendido por outros profissionais. Fatores que afetam a legibilidade: 
· Simplicidade: Poucas construções primitivas. 
· Multiplicidade de recursos prejudica: Ter muitas formas de fazer a mesma coisa confunde (ex.: em Python há x = x + 1 e x += 1; em C há também ++x e x++). 
· Sobrecarga excessiva de operadores: Operador + atuando para somar inteiros, concatenar strings e juntar listas. 
· Excesso de simplicidade também prejudica: No Assembly, sentenças elementares sem estruturas de controle reduzem a compreensão. 
· Ortogonalidade: Propriedade em que um conjunto pequeno de construções primitivas pode ser combinado livremente sem restrições arbitrárias. Menos exceções geram mais regularidade e facilitam a aprendizagem. 
· Boa ortogonalidade: Permitir vetores contendo elementos do tipo registro. 
· Má ortogonalidade: Proibir funções de retornarem vetores ou impedi-los de atuar como argumentos. 
· Instruções de controle: A presença de saltos arbitrários (goto) reduz a legibilidade. Linguagens modernas priorizam blocos estruturados. 
· Tipos e estruturas de dados: Suporte explícito a tipos semânticos (ex.: ter o tipo nativo booleano torna achou = false muito mais legível do que usar representações inteiras achou = 0 como no C padrão antigo). 
· Sintaxe: Identificadores curtos demais dificultam clareza funcional (Fortran limitava nomes a 6 caracteres). Estruturação léxica por palavras delimitadoras (BEGIN-END em Pascal, chaves {} em C) contra a indentação obrigatória em Python, que garante legibilidade estrutural automática. 
2.2.3. Facilidade de escrita (redigibilidade)
 Mede o quão facilmente um programador formula e redige soluções para o domínio escolhido. Elementos influenciadores: 
· Simplicidade e ortogonalidade: Reduzem a carga cognitiva de regras e facilitam o domínio das construções sintáticas. 
· Expressividade: Capacidade de enunciar operações complexas de modo conveniente e conciso (ex.: comandos for representam iterações com contagem de forma mais limpa do que combinações manuais com while). 
· Suporte à abstração: Facilidade para modularizar operações:
· Abstração de processos: Subprogramas e rotinas. 
· Abstração de dados: Definição estruturada de coleções complexas (árvores binárias, listas dinâmicas). 
2.2.4. Confiabilidade
 Um programa é confiável quando opera estritamente conforme suas especificações sob quaisquer condições operacionais e repetidas vezes. Depende de: 
· Verificação de tipos: Identificação de inconsistências entre variáveis e valores. Tipagem verificada em compilação traz alta segurança e performance. Checagens em tempo de execução são flexíveis, mas mais lentas e consomem memória. Falhas de checagem afetam drasticamente a confiabilidade. 
· Tratamento de exceções: Interceptação sistemática de erros em tempo de execução (como estouro de memória, limites estourados e divisões por zero), definindo planos de recuperação. 
· Aliasing: Existência de dois ou mais identificadores apontando para o mesmo endereço de memória física. É um recurso perigoso que compromete a estabilidade do software. 
· Influência da legibilidade e escrita: Códigos difíceis de ler ou escrever propiciam a introdução de falhas humanas na fase de codificação e dificultam manutenções corretivas. 
2.2.5. Custo
 Composição do custo financeiro e temporal do ciclo de vida da linguagem: 
· Treinamento: Custo para capacitar programadores, associado ao grau de ortogonalidade e simplicidade. 
· Escrita de programas: Custo de desenvolvimento influenciado pela redigibilidade. 
· Compilação: Licenças de compiladores (reduzido amplamente por ferramentas gratuitas e de código aberto como Python). 
· Execução: Tempo de processamento e consumo de recursos exigidos pelo projeto da linguagem. 
· Implementação: Disponibilidade de ferramentas gratuitas impulsiona a adesão à linguagem. 
· Confiabilidade:Falhas em sistemas críticos geram prejuízos econômicos e humanos catastróficos. 
· Manutenção: Representa grande parcela das despesas totais; códigos pouco legíveis encarecem o suporte. 
· Critérios agregados: A portabilidade (capacidade de migrar entre arquiteturas) e o reuso de código minimizam custos globais de desenvolvimento. 
3. Paradigmas de linguagens de programação
3.1. Paradigma imperativo
 Linguagens imperativas estruturam programas detalhando rigorosamente como a máquina deve realizar o trabalho, estabelecendo comandos sequenciais que modificam estados de memória. Possuem vínculo conceitual com a arquitetura do computador. 
3.1.1. Paradigma estruturado
Consolidado nas décadas de 1970 e 1980. Seus pilares fundamentais são: 
· Princípio 1: Eliminação de comandos de desvio incondicional (goto). 
· Princípio 2: Decomposição algorítmica por refinamento sucessivo (top-down), indo do macro ao micro através de procedimentos e funções modulares. 
· Princípio 3: Emprego exclusivo de três estruturas essenciais de fluxo: sequencial, condicional e de repetição. 
· Princípio 4: Alinhamento direto à Arquitetura de Von Neumann: fluxo contínuo de instruções e dados entre CPU e memória primária. 
· Linguagens representativas: Pascal e C; Python mantém este modelo estrutural como estilo básico. 
3.1.2. Paradigma orientado a objetos
 Surgiu para sanar a dificuldade de reutilização e escalabilidade do modelo puramente estruturado perante programas com alta complexidade. 
· Pilares: Abstração, encapsulamento, herança e polimorfismo. 
· Classes e Objetos: Classes operam como moldes/abstrações que encapsulam variáveis de estado (atributos) e procedimentos funcionais (métodos). Os objetos são instâncias ativas dessas classes. 
· Relação com o modelo estruturado: É uma evolução direta, pois a lógica interna dentro dos métodos ainda é escrita seguindo o estilo estruturado. 
· Linguagens: Smalltalk, Java, C++, Delphi e Python. Em Python, tudo internamente é estruturado como um objeto. 
3.1.3. Paradigma concorrente
Estruturado para cenários em que diferentes tarefas ou processos precisam ser processados de forma concorrente, compartilhando recursos do hardware. 
· Monoprocessador: Processos competem alternadamente pelo tempo do mesmo processador. 
· Multiprocessador: Processamento simultâneo (paralelismo) distribuído por núcleos locais ou nós de rede. 
· Linguagens representativas: Ada e Java possuem suporte maduro e robusto à concorrência nativa. 
· Python e concorrência: Python não foi desenhada primariamente para tarefas paralelas concorrentes. Sua implementação oficial em C (CPython) possui o mecanismo GIL (Global Interpreter Lock), que impede paralelismo real com threads de código Python, tornando as threads recomendáveis quase exclusivamente para tarefas limitadas por operações de entrada e saída (I/O bound). 
3.2. Paradigma declarativo
 Modelo no qual o desenvolvedor especifica o que deseja solucionar conceitualmente, em vez de listar o fluxo operacional ("como fazer"). Não depende intimamente da arquitetura de hardware; as variáveis comportam-se como incógnitas matemáticas, desvinculadas do conceito de células fixas de memória. 
3.2.1. Paradigma funcional
· O processamento resume-se à aplicação matemática de chamadas consecutivas a funções puras. 
· Funções recebem argumentos, processam e retornam novos dados sem gerar efeitos colaterais nos estados globais. 
· Emprega extensivamente avaliação recursiva em substituição aos laços de repetição tradicionais. 
· Produz sistemas compactos, com código conciso. 
· Linguagens representativas: LISP, Haskell e ML. LISP destaca-se em computação simbólica aplicada à inteligência artificial. 
· Python no paradigma: Embora não seja puramente funcional, incorpora influências pontuais como capacidade de recursão e funções anônimas declaradas via palavra-chave lambda. 
3.2.2. Paradigma lógico
· A resolução baseia-se em lógica proposicional: o desenvolvedor programa fornecendo declarações de fatos conhecidos e regras relacionais. 
· A execução baseia-se no motor de dedução autônoma chamado máquina de inferência, que processa as regras para deduzir respostas e novos fatos válidos. 
· Linguagem representativa: Prolog. 
· Aplica-se no desenvolvimento de bases de regras, sistemas especialistas e processamento consultivo inteligente. 
· Python nativamente não dá suporte a este paradigma. 
4. Métodos de implementação das linguagens
4.1. Tradução
 Processo no qual o programa em linguagem de alto nível é convertido integralmente para o código de máquina equivalente do computador antes de ocorrer qualquer execução. 
4.1.1. Fases de tradução
 O fluxo global entre o programa-fonte e o arquivo executável passa pelas seguintes etapas integradas: 
1. Compilador: Converte o programa-fonte escrito em alto nível em código assembly específico da arquitetura. 
2. Montador (Assembler): Pega as instruções em assembly e gera o código-objeto (código de máquina intermediário que ainda não é executável por si só). Esse código pode ser absoluto (endereço fixo) ou relocável (endereçamento dinâmico). 
3. Carregador (Loader): Componente que transforma o código-objeto em relocável, viabilizando o carregamento flexível na memória. 
4. Ligador (Linker): Junta o código-objeto relocável às bibliotecas externas, rotinas do sistema operacional e DLLs, gerando ao final o arquivo executável binário definitivo. 
4.1.2. Compilador e fases da compilação
 O compilador atua como a unidade central do processo de tradução e divide-se nas seguintes fases: 
· Análise Léxica: Lê a cadeia de caracteres do arquivo-fonte, remove espaços e comentários, e extrai unidades mínimas válidas denominadas tokens (identificadores, operadores, palavras-chave), populando a tabela de símbolos. 
· Análise Sintática: Agrupa os tokens e confere se a ordenação obedece às regras gramaticais formais da linguagem, montando estruturas como a árvore de derivação hierárquica. 
· Análise Semântica: Confere o sentido contextual e a consistência das operações (como a compatibilidade e a coerência entre tipos de dados dos operandos). 
· Gerador de Código Intermediário: Cria uma representação abstrata interna do programa, independente da máquina. 
· Otimizador de Código: Analisa o código intermediário para eliminar redundâncias, encurtar operações e maximizar o desempenho operacional. 
· Gerador de Código: Emite o código final em nível de máquina ou montador. 
· Módulos transversais: Tratador de erros (detecta anomalias em todas as etapas) e o Gerenciador da tabela de símbolos (atualiza metadados durante todo o fluxo). 
4.1.3. Principais características dos compiladores
· Produzem código-objeto altamente otimizado para o processador. 
· O programa final executa em velocidade máxima nativa. 
· Traduzem comandos de repetição uma única vez durante a compilação. 
· A fase de depuração e correção de falhas tende a ser mais morosa. 
· O binário gerado torna-se fortemente acoplado à plataforma (combinação do processador e sistema operacional) onde foi gerado. 
4.2. Interpretação e sistemas híbridos
4.2.1. Interpretação
 Método em que as linhas do programa-fonte são lidas, convertidas e imediatamente executadas uma a uma pelo software interpretador, sem a produção de um executável definitivo. 
· Ciclo de execução:
1. Obter a próxima instrução do código-fonte. 
2. Interpretar/decodificar a instrução para comando de máquina. 
3. Executar o comando. 
· Semelhança com Von Neumann: Espelha o comportamento do ciclo de busca e decodificação do hardware (utilizando os conceitos análogos de contador de instruções e registrador de instrução). 
· Características principais:
. Não cria programa-objeto persistente no disco. 
. Não desperdiça tempo traduzindo trechos de código condicionais que nunca chegam a ser invocados. 
. Apresenta respostas e retornos de erro de imediato. 
. A execução é mais lenta, já que comandos contidos em laços de repetição precisam ser reanalisados repetidamentea cada iteração. 
. Permite alta portabilidade do código. 
4.2.2. Tradução (Compilação) x Interpretação
· Tradutores (Compiladores):
· Vantagens: Execução mais rápida, aceita programas de alta complexidade e permite otimização aprofundada de instruções. 
· Desvantagens: Conversão composta por várias etapas, arquivo final consome mais espaço em memória e o ciclo de depuração/correção de falhas é mais longo. 
· Interpretadores:
· Vantagens: Depuração facilitada e rápida, menor consumo inicial de memória e retorno de execução visual imediato. 
· Desvantagens: Execução global mais lenta, manipulação de estruturas restritas e dependência de expor e fornecer o arquivo-fonte original ao usuário final. 
4.2.3. Sistemas híbridos
 Buscam conciliar a alta velocidade de execução da compilação com a portabilidade da interpretação. O código-fonte original é compilado previamente para um código intermediário (bytecode), independente de hardware. Uma máquina virtual (VM) instalada na plataforma receptora encarrega-se de interpretar ou compilar em tempo real o bytecode para as chamadas do hardware local. Java e Python funcionam sobre essa arquitetura. 
4.2.4. Sistema de implementação de Python
· Python opera por meio de implementação híbrida. 
· O compilador converte o código-fonte em um código intermediário otimizado, que é interpretado pela máquina virtual nativa da linguagem: a PVM (Python Virtual Machine). 
· CPython: É a implementação padrão oficial da linguagem, distribuída como um pacote integrado contendo o compilador, o interpretador da máquina virtual e as ferramentas do ecossistema. 
· Jython: Implementação que compila código Python em bytecode compatível diretamente com a máquina virtual Java (JVM). 
Tema 3 - Python Básico
SUMÁRIO
· 1. Linguagem Python
· 1.1. Visão geral
· 1.2. Histórico
· 1.3. Características da linguagem Python
· 1.4. Instalando o Python
· 1.4.1. Instalação do PyCharm
· 1.4.2. Teste do PyCharm
· 1.5. Principais características
· 1.5.1. Blocos
· 1.5.2. Comentários
· 1.5.3. Boas práticas de programação
· 1.6. Python básico na prática
· 1.6.1. Roteiro de prática
· 2. Variáveis em Python
· 2.1. Variáveis
· 2.1.1. Conceitos
· 2.1.2. Identificadores de variáveis
· 2.2. Conceito de amarração (Binding)
· 2.2.1. Amarrações
· 2.2.2. Amarrações de tipo
· 2.3. Escopo e tempo de vida
· 2.3.1. Escopo de visibilidade
· 2.3.2. Variáveis globais
· 2.3.3. Variáveis locais
· 2.3.4. Escopos
· 2.3.5. Tempo de vida
· 2.4. Constantes
· 2.4.1. Definição
· 2.5. Variáveis na prática
· 2.5.1. Roteiro de prática
· 3. Tipos de dados e expressões em Python
· 3.1. Tipos de dados padrão
· 3.1.1. Conceitos
· 3.1.2. Tipos numéricos
· 3.1.3. O tipo int
· 3.1.4. O tipo float
· 3.1.5. O tipo complex
· 3.1.6. O tipo bool
· 3.1.7. Operadores numéricos
· 3.1.8. Operadores booleanos
· 3.2. Relação de precedência entre operadores
· 3.3. Conversões de tipos de dados
· 3.4. Tipos de dados e expressões na prática
· 3.4.1. Roteiro de prática
· 4. Atribuição, entrada e saída de dados em Python
· 4.1. Variáveis: formas de atribuição
· 4.1.1. Sentenças de atribuição
· 4.1.2. Operadores de atribuição compostos
· 4.1.3. Troca de variáveis
· 4.2. Programação em Python
· 4.2.1. O primeiro programa em Python
· 4.2.2. Saída de dados com a função print()
· 4.2.3. Entrada de dados com a função input()
· 4.2.4. A função eval()
· 4.3. Formatação de dados de saída
· 4.3.1. Impressão de sequências
· 4.4. Atribuição, entrada e saída de dados na prática
· 4.4.1. Roteiro de prática
1. Linguagem Python
1.1. Visão geral
 Python é uma linguagem de programação classificada como de alto nível. Ela viabiliza instruções intuitivas que simplificam o processo de aprendizado técnico em comparação com linguagens de baixo nível. Nestas últimas, o desenvolvedor precisa se expressar de maneira próxima à arquitetura do dispositivo, distanciando-se da comunicação humana tradicional. Python destaca-se pela sintaxe acessível, flexibilidade e aplicabilidade em áreas como automação, desenvolvimento web e análise de dados. 
1.2. Histórico
 Criada e lançada pelo holandês Guido van Rossum em 1990. Seu projeto foi concebido para possibilitar clareza de codificação em aplicações de pequeno e grande porte, priorizando a legibilidade por meio do uso de espaços em branco com valor sintático significativo. 
1.3. Características da linguagem Python
· Ser multiparadigma: Suporta o paradigma estruturado, a orientação a objetos e elementos do paradigma funcional (uso extensivo de bibliotecas, suporte a funções anônimas com lambda e chamadas recursivas). 
· Ser interativa: Permite testes diretos pelo prompt interativo (REPL), exibindo diagnósticos em tempo real para instruções e depurações rápidas. 
· Ser híbrida quanto ao método de implementação: Combina aspectos de compilação e interpretação. O programa-fonte gera um código intermediário independente do sistema operacional, executado por meio de uma máquina virtual (PVM). 
· Ser portável: Executa sem necessidade de alterações estruturais em diferentes plataformas e sistemas operacionais, como Linux, Windows, macOS e Unix. 
· Ser extensível: Permite a integração e o desenvolvimento de módulos tanto de alto nível quanto de baixo nível para expandir o interpretador. 
· Suportar bancos de dados: Integração com os principais SGBDs (MySQL, PostgreSQL, SQLite, ElephantSQL, MongoDB, entre outros). 
· Suportar interface com usuário: Criação de GUIs com o auxílio de bibliotecas específicas como Tkinter, wxPython, PyGUI, Pyforms, CEF Python, Dabo e Flexx. 
· Possibilidade de ser usada como linguagem de script: Permite a automação e integração de outros programas, além de viabilizar compilação para bytecode para sistemas maiores. 
· Permitir o desenvolvimento de aplicações Web: A biblioteca padrão suporta protocolos de internet (HTML, XML, JSON, IMAP, FTP) e fluxos de correio eletrônico. 
· Permitir a criação de aplicações comerciais: Distribuída sob licença de código aberto aprovada pela OSI (Open Source Initiative), o que autoriza seu uso comercial gratuito. 
1.4. Instalando o Python
1.4.1. Instalação do PyCharm
O PyCharm é um ambiente de desenvolvimento integrado (IDE) mantido pela JetBrains voltado para Python. Ele provê recursos de produtividade como autocompletar inteligente, ferramentas integradas de depuração, gerenciamento de projetos e integração com sistemas de controle de versão. Sua instalação para fins gerais baseia-se na versão gratuita Community, recomendando-se o idioma inglês durante a configuração para facilitar a consulta a documentações globais. 
1.4.2. Teste do PyCharm
A validação do ambiente pode ser feita diretamente pelo Python Console interno. Comandos interativos permitem inicializar variáveis diretamente (ex.: x = 5) e exibir seus valores em tempo real na saída padrão por meio da função print(x). 
1.5. Principais características
1.5.1. Blocos
Em Python, os blocos de instruções são delimitados obrigatoriamente pela indentação, em contraste com linguagens como C ou Java, que utilizam delimitadores explícitos como chaves {}. 
· A abertura de qualquer bloco é sinalizada pelo caractere de dois pontos : posicionado no encerramento da instrução superior. 
· O recuo convencional adotado para compor o corpo interno do bloco é de 4 espaços à esquerda. 
· Declarações situadas na mesma coluna física de indentação pertencem ao mesmo nível de hierarquia lógica, e declarações com recuos mais profundos subordinam-se às estruturas que as antecederam (como estruturas de seleção if/else ou laços for). 
1.5.2. Comentários
Trechos textuais informativos que não são processados nem executados pelo interpretador: 
· Comentário de uma linha: Utiliza o símbolo cerquilha #. 
· Comentário de várias linhas: Delimitado por três aspas duplas no início e três ao fim (""" ... """). Em C, a sintaxe equivalente utiliza // para linha única e /* ... */ para blocos. 
1.5.3. Boas práticas de programação
· Inclusão de comentários: Documentar a finalidade de rotinase algoritmos complexos melhora a manutenibilidade e o trabalho em equipe. 
· PEP (Python Enhancement Proposals): Conjunto oficial de propostas de melhorias da comunidade Python. A PEP 8 destaca-se como o guia oficial de estilo e padronização visual da escrita de código Python. 
1.6. Python básico na prática
1.6.1. Roteiro de prática
Execução guiada de comandos no console da IDE para a realização de cálculos aritméticos, como o cálculo de médias aritméticas simples por meio de atribuições numéricas a variáveis e posterior exibição estruturada. 
2. Variáveis em Python
2.1. Variáveis
2.1.1. Conceitos
Variáveis funcionam como abstrações lógicas e simbólicas associadas a endereços na memória do computador. Ao declarar um identificador, cria-se uma etiqueta ("apelido") para referenciar e recuperar o dado mantido nessa posição de armazenamento (análogo a caixas de correio residenciais). 
· Operador de atribuição: Representado pelo sinal de igualdade =. A expressão x = 10 associa o valor numérico 10 ao identificador x. 
· Declaração de variáveis: Python dispensa a declaração prévia de tipo (diferente de C e Java). A variável passa a existir no instante em que recebe sua primeira atribuição. Tentar acessar uma variável sem atribuição prévia provoca erro em tempo de execução (NameError, informando que o nome não foi definido). 
2.1.2. Identificadores de variáveis
Regras lexicais para composição de nomes de variáveis: 
· Podem conter letras maiúsculas e minúsculas, dígitos de 0 a 9 e o caractere sublinhado/underline _. 
· O primeiro caractere não pode ser um número. 
· São exemplos válidos: MinhaVariavel, _variavel, salario1, salario1_2. 
· São inválidos: 1variavel (inicia com dígito) e salario-1 (hífen interpretado como operador). 
· Sensibilidade a maiúsculas e minúsculas (case-sensitive): Nomes como MinhaVariavel e minhavariavel definem identificadores totalmente distintos. 
· Palavras reservadas: Não podem ser aproveitadas como variáveis (and, as, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is, lambda, not, or, pass, print, raise, return, try, while, with, yield). 
2.2. Conceito de amarração (Binding)
2.2.1. Amarrações
Amarração (binding) é o processo de vinculação técnica entre duas entidades dentro de uma linguagem de programação (ex.: vinculação entre identificador e tipo, operador e seu símbolo, variável e o valor alocado). O instante no qual a vinculação é fixada chama-se tempo de amarração: 
· Projeto da linguagem: Associação definitiva de operadores a seus símbolos (ex.: símbolo * associado à multiplicação) e definição de palavras-chave. 
· Implementação da linguagem: Definição interna das faixas limites dos tipos numéricos nos compiladores. 
· Compilação: Associação estrutural entre variáveis e seus respectivos tipos de dados. 
· Ligação (Link time): Conexão formal entre módulos compilados e rotinas de bibliotecas externas (em C com #include; em Python por import). 
· Carga (Load time): Substituição de endereços de memória lógicos/relativos por endereços físicos e absolutos da máquina. 
· Execução (Run time): Associação dinâmica entre variáveis e valores fornecidos dinamicamente em tempo de execução (como dados fornecidos pelo usuário via teclado). 
· Classificação temporal do binding:
· Cedo (early binding): Ocorre antes da execução (aumenta o desempenho e a velocidade, reduzindo a flexibilidade). 
· Tardio (late binding): Ocorre dinamicamente em execução (garante maior flexibilidade, reduzindo a velocidade). 
2.2.2. Amarrações de tipo
· Estática: Vinculação definida antes do início da execução do código, imutável até o final do processo (ex.: int a em linguagem C). 
· Dinâmica: A amarração de tipo consolida-se em tempo de execução, permitindo que a mesma variável mude de tipo ao longo do ciclo de vida do programa (caso de Python). 
· A função nativa type(objeto) inspeciona o tipo ao qual uma variável encontra-se associada em determinado instante. 
2.3. Escopo e tempo de vida
2.3.1. Escopo de visibilidade
Define a região do código-fonte onde uma variável é reconhecida e acessível. Tentar referenciar um nome fora de seu escopo de definição gera falha. 
2.3.2. Variáveis globais
Variáveis criadas diretamente no prompt interativo ou no corpo principal de um módulo (fora de qualquer função). Permanecem visíveis e acessíveis por todas as rotinas desse ambiente durante a execução. 
2.3.3. Variáveis locais
Variáveis criadas ou inicializadas internamente no bloco de uma função. Seu identificador existe estritamente durante o ciclo interno dessa função. 
· Quando uma variável local possui o mesmo nome de uma variável global, a local sobrepõe a global no escopo interno da função. 
· Se uma variável não for encontrada no escopo local da função, o interpretador estende a busca seguindo a ordem de resolução de escopo:
1. Chamada da função delimitadora. 
2. Variáveis do escopo global. 
3. Módulo de funções internas (builtins). 
· Para alterar o conteúdo de uma variável global a partir do corpo de uma função local, utiliza-se a palavra-chave reservada global. 
2.3.4. Escopos
· Estático: Resolução de escopo baseada na estrutura textual do código, analisada em tempo de compilação (ex.: C, C++, Java). 
· Dinâmico: Resolução baseada no encadeamento de chamadas dos métodos durante a execução (como adotado em Python). Pode impactar a velocidade e a facilidade de rastreamento estático do fluxo de dados. 
2.3.5. Tempo de vida
Conceito temporal (ao passo que o escopo é um conceito textual/espacial) que expressa a duração do intervalo de tempo no qual a variável aloca espaço físico na memória RAM: 
· Variáveis globais perduram durante toda a vida útil da aplicação. 
· Variáveis locais existem apenas durante o tempo em que o bloco ou a função a que pertencem está sendo executado. 
2.4. Constantes
2.4.1. Definição
Em Python não existe um tipo primitivo nem suporte nativo com palavra-chave específica (como const) para implementar constantes estritas. 
· Convenção de nomenclatura: Utilizam-se letras maiúsculas ou prefixos (como C_ ou CONSTANTE_NUMERICA, ex.: _PI = 3.141592, PRECISION = 0.001) para sinalizar aos outros desenvolvedores que aquele valor não deve ser alterado. 
· Embora essa convenção auxilie na padronização, a linguagem não bloqueia reatribuições por padrão. 
· Para forçar imutabilidade técnica estrita, é necessário o uso de recursos específicos, como o módulo constant ou o decorador @final pertencente ao pacote typing (introduzido a partir do Python 3.8). 
2.5. Variáveis na prática
2.5.1. Roteiro de prática
Exemplificação prática de binding em chamadas de sub-rotinas: declaração de funções que recebem múltiplos parâmetros (numéricos e textuais) e observação da associação entre argumentos passados na chamada externa e os parâmetros associados no interior da função. 
3. Tipos de dados e expressões em Python
3.1. Tipos de dados padrão
3.1.1. Conceitos
Python categoriza seus tipos de dados padrão nativos em grupos essenciais, com destaque para:
· Numéricos: Inteiros, reais e complexos. 
· Sequenciais: Cadeias de caracteres (strings), tuplas e listas. 
· Dicionários: Mapeamentos baseados em chave-valor. 
· Outros tipos internos: Classes, instâncias e tipos de exceções. 
3.1.2. Tipos numéricos
Compreendem inteiros (int), números de ponto flutuante (float) e números complexos (complex), com os booleanos (bool) integrando formalmente um subtipo da categoria inteira. 
3.1.3. O tipo int
Representa grandezas inteiras correspondentes ao conjunto matemático $\mathbb{Z}$. 
· Não possui limitação prévia de tamanho em bits (ao contrário do int de 32 ou 64 bits de C e Java); sua extensão máxima depende unicamente da memória física disponível na máquina. 
· Suporta o uso do caractere sublinhado _ como separador visual de milhares para simplificar a leitura de números extensos (ex.: 1_000_000). 
3.1.4. O tipo float
Representa números reais dotados de fração decimal ($\mathbb{R}$) em notação deponto flutuante. 
· O delimitador padrão é o ponto ., e não a vírgula (ex.: 50.0). 
· O uso acidental de vírgula (ex.: 50, 0) gera uma tupla contendo dois elementos, em vez de um dado real. 
· Comportamento em operações: Operações de adição, subtração e multiplicação entre números exclusivamente int geram int, porém a presença de ao menos um operando float converte o resultado global da expressão para float. 
· O operador de exponenciação ** gera resultado real caso a base seja fracionária. 
· A divisão padrão / sempre retorna um resultado float, mesmo entre números inteiros com divisão exata. 
· A divisão inteira (quociente) utiliza o operador // e a operação de módulo (resto da divisão inteira) utiliza o operador %. 
3.1.5. O tipo complex
Manipula expressões complexas descritas formalmente sob a forma $x + yj$, onde $x$ corresponde à porção real e $y$ expressa a porção imaginária (denotada pela letra j). O método r.conjugate() devolve o conjugado aritmético do número complexo associado, invertendo o sinal da sua parte imaginária. 
3.1.6. O tipo bool
Estrutura booleana que armazena exclusivamente os estados lógicos True (Verdadeiro) ou False (Falso). O operador unário not inverte o estado lógico de seu operando. 
3.1.7. Operadores numéricos
· Operações matemáticas aritméticas: 
· Soma: +
· Subtração: -
· Multiplicação: *
· Divisão tradicional: /
· Divisão inteira (quociente): //
· Resto da divisão: %
· Valor absoluto: abs(x)
· Exponenciação: **
· Operadores de comparação (retornam valor booleano): 
· Menor que: 
· Maior ou igual: >=
· Igualdade: == (compara valores, distinguindo-se do operador de atribuição =) 
· Diferença: !=
· Módulos da biblioteca padrão como math e fractions fornecem suporte a funções matemáticas complementares e manipulação de números racionais. 
3.1.8. Operadores booleanos
Processam lógica proposicional retornando respostas booleanas: 
· Conjunção lógica: and (retorna verdadeiro se ambas as condições forem verdadeiras). 
· Disjunção lógica: or (retorna verdadeiro se pelo menos uma condição for verdadeira). 
· Negação: not (inverte o valor lógico da proposição). 
3.2. Relação de precedência entre operadores
 Define a hierarquia sequencial de avaliação das expressões pelo interpretador. O uso de parênteses () sobrepõe a ordem implícita, forçando a avaliação das expressões internas com prioridade máxima. 
A ordem de precedência decrescente (da maior prioridade para a menor) é: 
1. Definições de listas e indexações: [...], x[...], x[i:j]
2. Exponenciação: **
3. Sinais unários: +x, -x
4. Operações multiplicativas: *, /, //, %
5. Operações aditivas: +, -
6. Operadores relacionais e de pertinência: in, not in, , >=, !=, ==
7. Operador lógico de negação: not
8. Operador lógico de conjunção: and
9. Operador lógico de disjunção: or
Regra de desempate: Operadores contidos no mesmo nível hierárquico são processados da esquerda para a direita. 
3.3. Conversões de tipos de dados
· Conversão implícita (coerção): Ocorre de forma transparente em expressões de tipos mistos, promovendo o operando para o tipo de dado de maior abrangência conjuntista (ex.: na expressão 5 + 0.68, o valor inteiro 5 é convertido implicitamente para 5.0 para que a soma ocorra no domínio float). 
· Valores booleanos: O Python converte implicitamente True para o inteiro 1 e False para 0. 
· Relação de abrangência: bool $\subset$ int $\subset$ float. 
· Conversão explícita (type casting): Quando o programador especifica formalmente a transformação via construtores de tipo: 
· int(x): Converte o operando para inteiro; no caso de ponto flutuante, a parte decimal é descartada por truncamento, sem arredondamento para o inteiro mais próximo. 
· float(x): Converte inteiros ou cadeias de caracteres numéricas em valores de ponto flutuante. 
· bool(x): Mapeia o operando para seu estado lógico correspondente. 
3.4. Tipos de dados e expressões na prática
3.4.1. Roteiro de prática
Exemplificação de conversões com dados externos fornecidos via teclado: captura de entradas de notas como strings via input(), conversão explícita para valores float, cálculo da média aritmética e formatação numérica com controle de casas decimais na saída formatada. 
4. Atribuição, entrada e saída de dados em Python
4.1. Variáveis: formas de atribuição
4.1.1. Sentenças de atribuição
· Atribuição simples: Atribui um valor diretamente a uma variável utilizando a sintaxe variavel = valor. 
· Atribuição múltipla: Permite atribuir valores a mais de uma variável simultaneamente na mesma linha de instrução (ex.: x, y = 2, 5, vinculando o valor 2 a x e o valor 5 a y). 
4.1.2. Operadores de atribuição compostos
Permitem aplicar uma operação matemática sobre a variável e reatribuir o resultado a ela mesma de forma condensada: 
· Soma e atribuição: += (ex.: x += 2 equivale a x = x + 2) 
· Subtração e atribuição: -= (ex.: x -= 2 equivale a x = x - 2) 
· Multiplicação e atribuição: *= (ex.: x *= 2 equivale a x = x * 2) 
· Divisão e atribuição: /= (ex.: x /= 2 equivale a x = x / 2) 
· Módulo e atribuição: %= (ex.: x %= 3 equivale a x = x % 3) 
· Diferença de sintaxe em relação a C: Python não possui os operadores unários de incremento e decremento pós/pré-fixados ++ e --. 
4.1.3. Troca de variáveis
Enquanto em linguagens convencionais como C ou Java a inversão de valores entre duas variáveis (a e b) exige uma variável intermediária/auxiliar (temp = a; a = b; b = temp;), em Python a operação é simplificada pela atribuição múltipla direta:
Python
a, b = b, a
Essa sintaxe dispensa variáveis temporárias e simplifica a manipulação de dados. 
4.2. Programação em Python
4.2.1. O primeiro programa em Python
A elaboração e execução de scripts em ambiente IDE ocorre pela criação de arquivos de texto terminados com a extensão oficial .py (ex.: primeiro_programa.py), que integram instruções de entrada, processamento e rotinas de apresentação de resultados. 
4.2.2. Saída de dados com a função print()
Apresenta informações no console da aplicação. Diferenças estruturais frente à função printf() de C: 
· A função print() salta automaticamente o cursor para a linha seguinte após a impressão, sem exigir o caractere de escape explícito \n. 
· Imprime variáveis diretamente sem a necessidade de especificadores de conversão explícitos (como %d, %f ou %s). 
· Pode receber como parâmetro cadeias literais de texto, variáveis com valores previamente calculados ou expressões complexas. 
4.2.3. Entrada de dados com a função input()
Permite receber dados fornecidos pelo usuário via terminal. 
· Ao contrário do C (que exige combinar printf() para a mensagem e scanf() para a leitura), a função input("Mensagem") exibe o texto de solicitação e pausa a execução até o usuário pressionar a tecla [ENTER]. 
· Comportamento da entrada: A função input() trata todo dado capturado invariavelmente como string (str), mesmo quando o usuário insere dígitos numéricos. 
· Para utilizar entradas do usuário em expressões matemáticas, é necessário realizar a conversão explícita para tipos numéricos (como int() ou float()), sob risco de erro de tipos (TypeError). 
4.2.4. A função eval()
Interpreta e avalia uma string de texto contendo uma expressão matemática válida, resolvendo o cálculo e retornando o resultado numérico final. Combinada com a função input(), permite interpretar diretamente fórmulas aritméticas fornecidas como entrada. 
4.3. Formatação de dados de saída
Mecanismos para estruturar a exibição de resultados de modo padronizado (como saídas para datas e horários): 
· Concatenação tradicional: Unir partes do texto usando o operador de soma + entre sequências de strings. 
· Método .format(): Adiciona marcadores de substituição compostos por chaves {} na string, preenchendo-os com os argumentos passados na chamada do método. 
· f-strings (strings formatadas): Sintaxe simplificada que prefixa a string com a letra f antes das aspas de abertura (ex.: f"{hora}:{minutos}"), interpolandoas variáveis diretamente dentro das chaves correspondentes. 
· Controle de formatação posicional:
· Largura de campo: A anotação {:4} ou {:5} reserva uma quantidade fixa de espaços para a exibição de um número; quando o número possui menos dígitos que o total especificado, espaços em branco são inseridos à esquerda por alinhamento padrão à direita. 
· Precisão decimal: A anotação {:8.5f} especifica a reserva global de 8 espaços de campo com limite fixo de exibição de 5 casas decimais para valores de ponto flutuante. 
4.3.1. Impressão de sequências
Python permite passar sequências completas (como strings e listas) diretamente como argumento na função print(), sem necessidade de percorrer os elementos individualmente em laços de repetição. 
· Fatiamento (slicing): Uso de índices entre colchetes para imprimir intervalos específicos de uma cadeia:
· O índice inicial começa em 0. 
· A notação [0:4] extrai os caracteres das posições 0, 1, 2 e 3, não incluindo o índice limite superior (posição 4). 
· A notação [2:8] extrai os elementos compreendidos entre os índices de 2 a 7. 
· Inversão de leitura: A notação com passo negativo [::-1] inverte a sequência, exibindo os caracteres da direita para a esquerda. 
4.4. Atribuição, entrada e saída de dados na prática
4.4.1. Roteiro de prática
Estruturação integrada de fluxos básicos de entrada, processamento e saída: 
1. Declaração e atribuição inicial de variáveis para armazenar parâmetros do sistema (ex.: preços unitários de itens). 
2. Captura interativa de dados de quantidade fornecidos pelo usuário via input(). 
3. Conversão de tipo de dados das quantidades para tipos numéricos compatíveis com cálculo matemático. 
4. Cálculo de totais por meio de operadores aritméticos. 
5. Exibição formatada dos resultados consolidados na tela via print(). 
Tema 4 - Python Estruturado
SUMÁRIO
· 1. Decisão e repetição em Python
· 1.1. Estruturas de decisão
· 1.1.1. Tratamento das condições
· 1.1.2. Estruturas de decisão
· 1.2. Estrutura de repetição for
· 1.2.1. As listas do tipo range()
· 1.2.2. A sintaxe da estrutura for
· 1.2.3. Exemplos com for
· 1.2.4. O laço for com uma string
· 1.2.5. Uso do laço for com qualquer sequência
· 1.3. Estrutura de repetição while e instruções auxiliares
· 1.3.1. Estrutura de repetição while
· 1.3.2. O laço while infinito
· 1.3.3. As instruções break, continue e pass
· 1.4. Tipos de dados sequenciais e dicionário
· 1.4.1. Tipos sequenciais
· 1.4.2. Strings
· 1.4.3. Listas
· 1.4.4. Tuplas
· 1.4.5. Range
· 1.4.6. Operadores sequenciais comuns
· 1.4.7. Dicionários
· 1.5. Estruturas de decisão e repetição na prática
· 1.5.1. Roteiro de prática
· 2. Conceitos de subprogramas e a sua utilização em Python
· 2.1. Subprogramas
· 2.1.1. O que são subprogramas?
· 2.1.2. Características gerais dos subprogramas
· 2.1.3. Definições básicas de subprogramas
· 2.1.4. Definindo e chamando subprogramas
· 2.2. Parâmetros, procedimentos e funções
· 2.2.1. Parâmetros em Python
· 2.2.2. O que são parâmetros?
· 2.2.3. Parâmetros formais e reais
· 2.2.4. Valores padrão para parâmetros
· 2.2.5. Procedimentos e funções
· 2.2.6. Ambientes de referenciamento local
· 2.2.7. Subprogramas aninhados
· 2.2.8. Métodos de passagens de parâmetros
· 2.3. Parâmetros, procedimentos e funções na prática
· 2.3.1. Roteiro de prática
· 2.4. Funções recursivas e docstrings
· 2.4.1. Recursividade
· 2.4.2. A função recursiva fatorial
· 2.4.3. A sequência de Fibonacci
· 2.4.4. Documentação de funções
· 2.5. Funções recursivas na prática
· 2.5.1. Roteiro de prática
· 3. Bibliotecas em Python
· 3.1. Importação de funções e módulos
· 3.1.1. Biblioteca padrão Python
· 3.1.2. Como usar uma função de módulo importado
· 3.2. Módulos básicos nativos do Python
· 3.2.1. Módulo math
· 3.2.2. Módulo random
· 3.3. Mais módulos nativos do Python
· 3.3.1. Módulo SMTPLIB
· 3.3.2. Módulo time
· 3.3.3. Módulo tkinter
· 3.4. Módulos nativos do Python na prática
· 3.4.1. Roteiro de prática
· 3.5. Pacotes externos
· 3.5.1. Usando pacotes externos
· 3.5.2. Criação do próprio módulo
· 4. Eventos em Python
· 4.1. Erros em um programa Python
· 4.1.1. Erros e exceções
· 4.2. Erros e exceções na prática
· 4.2.1. Roteiro de prática
· 4.3. Tratamento de exceções e eventos
· 4.3.1. Captura e manipulação de exceções
· 4.3.2. Captura de exceções de determinado tipo
· 4.3.3. Captura de exceções de múltiplos tipos
· 4.3.4. O tratamento completo das exceções
· 4.3.5. Tratamento de eventos
· 4.4. Tratamento de exceções na prática
· 4.4.1. Roteiro de prática
· 4.5. Tratamento de eventos na prática
· 4.5.1. Roteiro de prática
1. Decisão e repetição em Python
1.1. Estruturas de decisão
As estruturas de decisão (estruturas de controle de fluxo) viabilizam a seleção e execução de blocos de instruções específicos com base na avaliação lógica de critérios pré-estabelecidos. 
1.1.1. Tratamento das condições
Existe uma diferença essencial entre C e Python na manipulação condicional: 
· Python: Possui o tipo nativo bool, avaliando expressões diretamente como True ou False. 
· Linguagem C: Não possui tipo booleano nativo; trata qualquer valor numérico diferente de 0 como verdadeiro e valores iguais a 0 (ou vazios) como falsos. 
1.1.2. Estruturas de decisão
· Comando if: Executa o bloco subordinado se a condição testada for verdadeira. Todas as instruções subordinadas devem possuir indentação de 4 espaços. Instruções alinhadas à margem esquerda original situam-se fora do bloco condicional e executam independentemente do teste. 
· Cláusula else: Provê um caminho de execução alternativo quando a condição do if resulta em falso. 
· Cláusula elif: Contração sintática de else if. Permite encadear múltiplos testes condicionais sucessivos em ordem hierárquica. O interpretador avalia a sequência até identificar a primeira condição verdadeira; se nenhuma for satisfeita, o bloco opcional else é executado. 
1.2. Estrutura de repetição for
Permite iterar sobre os elementos constituintes de uma sequência, executando um bloco de comandos para cada item. 
1.2.1. As listas do tipo range()
A função range() gera sequências imutáveis de números inteiros conforme três assinaturas: 
1. Simples — range(stop): Recebe um único argumento; inicia em 0 e incrementa de 1 em 1 até o limite stop (exclusivo, sem incluí-lo). Exemplo: range(3) gera (0, 1, 2). 
2. Não iniciadas em 0 — range(start, stop): Define início e fim explícitos, mantendo incremento unitário padrão (fim exclusivo). Exemplo: range(2, 7) gera (2, 3, 4, 5, 6). 
3. Com passo — range(start, stop, step): Permite configurar a taxa de incremento (step). Exemplo: range(2, 9, 3) gera (2, 5, 8). 
1.2.2. A sintaxe da estrutura for
Estruturada pela sintaxe for item in sequencia: seguida por bloco indentado. A variável de controle assume sequencialmente cada valor da coleção. 
1.2.3. Exemplos com for
· Varredura de sequências geradas por range() para exibição de elementos. 
· Contadores numéricos sucessivos (ex.: range(11) para iterar de 0 a 10). 
· Construção de tabelas aritméticas (como tabuadas), combinando iterações e saídas formatadas com f-strings. 
1.2.4. O laço for com uma string
Como strings são sequências de caracteres individuais, o laço for pode iterar letra por letra ao longo do texto. Aplica-se em rotinas de soletração e em algoritmos de contagem de caracteres específicos. 
1.2.5. Uso do laço for com qualquer sequência
O for itera sobre coleções genéricas, destacando-se as listas: 
· Listas são coleções de dados mutáveis, delimitadas por colchetes [] e separadas por vírgulas. Podem armazenar elementos heterogêneos. 
· Aplicações do for em listas incluem a impressão de elementos textuais, acumulação de somatórios numéricos e transformações matemáticas item a item. 
1.3. Estrutura de repetição while e instruções auxiliares
1.3.1. Estrutura de repetição while
Executa repetidamente um bloco de código enquanto sua condição lógica permanecer verdadeira (True). No momento em quea expressão se torna falsa, o laço é encerrado e a execução passa para a instrução imediatamente seguinte. 
1.3.2. O laço while infinito
Formulado quando a condição expressa é permanentemente verdadeira (ex.: while True:). É empregado em rotinas que operam continuamente sem previsão estática de término, como o monitoramento contínuo de sensores de telemetria em intervalos fixos com chamadas de pausa temporal. 
1.3.3. As instruções break, continue e pass
· Instrução break: Interrompe e encerra imediatamente a execução do laço (for ou while), desviando o fluxo para a primeira linha após a estrutura. Em laços aninhados, o break encerra unicamente o laço interno no qual está inserido. 
· Instrução continue: Interrompe apenas a iteração corrente. O interpretador descarta as instruções restantes daquela rodada e retorna ao cabeçalho do laço para processar a próxima iteração. 
· Instrução pass: Funciona como um marcador de posição sintático nulo (no-op). Mantém a integridade estrutural em blocos onde a sintaxe exige comandos, mas nenhuma operação precisa ser executada naquele momento. 
1.4. Tipos de dados sequenciais e dicionário
1.4.1. Tipos sequenciais
Coleções ordenadas que compreendem listas, tuplas, objetos de intervalo (range) e strings (str). 
· Indexação direta: Inicia no índice 0 e avança com incrementos unitários positivos. 
· Indexação negativa: O índice -1 referencia o último item da sequência, decrescendo negativamente em direção ao primeiro elemento. 
1.4.2. Strings
Armazenam dados textuais (letras, números, espaços e símbolos). Python não adota o tipo char; um único caractere é processado como uma string de tamanho unitário. 
· Delimitadores: Podem ser delimitadas por aspas simples '...', aspas duplas "...", aspas simples triplas '''...''' ou aspas duplas triplas """...""". 
· Métodos embutidos de string:
· .upper(): Converte todos os caracteres para letras maiúsculas. 
· .lower(): Converte todos os caracteres para letras minúsculas. 
· .split(): Divide o texto com base em delimitadores (como o espaço em branco padrão), gerando uma lista com as substrings resultantes. 
1.4.3. Listas
Sequências mutáveis, utilizadas para abrigar conjuntos normalmente homogêneos. Podem ser declaradas por: 
· Par de colchetes vazios: []. 
· Colchetes com itens separados por vírgulas: [a, b, c]. 
· Compreensão de lista: [x for x in iteravel]. 
· Construtor de tipo: list() ou list(iteravel) (ex.: list('abc') gera ['a', 'b', 'c']). 
1.4.4. Tuplas
Sequências imutáveis, aplicadas ao empacotamento de itens heterogêneos ou conjuntos que não podem sofrer mutação após a criação. 
· Declaradas por parênteses vazios (), pela separação de itens por vírgulas (ex.: a, b, c ou (a, b, c)) ou pelo construtor tuple(iteravel). 
· A vírgula é o elemento sintático definidor da tupla; os parênteses são opcionais na maioria das declarações, exceto na criação de tuplas vazias. 
1.4.5. Range
Coleção imutável de valores numéricos utilizada em iterações de repetição fixa. Suporta definições de parada única range(stop), limites de abrangência range(start, stop) e passos arbitrários range(start, stop, step). 
1.4.6. Operadores sequenciais comuns
Operadores aplicáveis às sequências: 
· x in s: Retorna True se o elemento x estiver contido na sequência s. 
· x not in s: Retorna False se x for elemento de s. 
· s + t: Concatenação entre as sequências s e t. 
· n * s ou s * n: Concatena n cópias da sequência s. 
· s[i]: Acessa o caractere/item localizado no índice i. 
· len(s): Devolve o comprimento total (quantidade de elementos) de s. 
· min(s) e max(s): Retornam, respectivamente, o menor e o maior elemento de s. 
· Operadores relacionais ==, realizam comparações lexicográficas (ordem de dicionário) entre strings. 
1.4.7. Dicionários
 Estruturas associativas mapeadas pelo formato {chave: valor}. Permitem que os elementos sejam indexados por identificadores imutáveis (como strings ou números) definidos pelo desenvolvedor, e não por posições numéricas ordinais. 
1.5. Estruturas de decisão e repetição na prática
1.5.1. Roteiro de prática
Construção de rotinas algorítmicas integrando loops for e validações com if para filtrar números de 4 dígitos (intervalo de 1000 a 9999) cuja raiz quadrada inteira coincide com a adição dos valores formados por seus algarismos mais e menos significativos. 
2. Conceitos de subprogramas e a sua utilização em Python
2.1. Subprogramas
2.1.1. O que são subprogramas?
Blocos funcionais modulares que executam responsabilidades específicas dentro de um sistema maior. Em Python, subprogramas são implementados formalmente como funções. 
2.1.2. Características gerais dos subprogramas
· Ponto único de entrada: A execução da rotina inicia obrigatoriamente a partir de seu cabeçalho superior. 
· Suspensão do programa chamador: Quando a função é invocada, a execução da rotina chamadora é pausada até que a função termine. 
· Retorno ao chamador: Finalizada a execução, o controle do fluxo retorna exatamente ao ponto de origem da chamada. 
2.1.3. Definições básicas de subprogramas
· Definição de subprograma: Estabelece o nome, os parâmetros formais esperados e o bloco funcional de código a ser executado. 
· Chamada de subprograma: Instrução explícita que ativa a execução da função. 
· Ativação do subprograma: Estado em que a função permanece alocada e em execução ativa. 
· Cabeçalho do subprograma: Linha inicial contendo a palavra-chave de declaração, identificador da função e lista de parâmetros. 
2.1.4. Definindo e chamando subprogramas
· Definidos pela palavra reservada def, seguida do identificador e parênteses com os parâmetros. Não há especificação estática prévia de tipo dos parâmetros nem de tipo do retorno. 
· Natureza executável do def: Em Python, declarações def são instruções avaliadas em tempo de execução; uma função só pode ser chamada após a passagem do interpretador por sua sentença declarativa. 
2.2. Parâmetros, procedimentos e funções
2.2.1. Parâmetros em Python
Mecanismo que permite a uma função receber informações para o processamento. Formas de obtenção de dados: 
1. Acesso a variáveis globais: Leitura de identificadores externos (abordagem que aumenta o acoplamento do código). 
2. Passagem de parâmetros: Envio explícito de argumentos diretamente na chamada, técnica preferível por razões de modularidade e segurança de dados. 
2.2.2. O que são parâmetros?
Valores recebidos pelo cabeçalho da função e incorporados em seu corpo operacional como variáveis locais. 
2.2.3. Parâmetros formais e reais
· Parâmetros formais: Nomes declarados no cabeçalho durante a definição da função. 
· Parâmetros reais (argumentos): Valores literais, variáveis ou expressões fornecidos no momento da invocação da função. 
2.2.4. Valores padrão para parâmetros
Possibilidade de prefixar argumentos predefinidos no cabeçalho da função (ex.: parametro=valor). Se o chamador omitir esse dado na chamada, o interpretador assume automaticamente o valor padrão. O comando return delimita a entrega de um valor processado de volta ao chamador. 
2.2.5. Procedimentos e funções
 Segundo a taxonomia teórica de Sebesta (2018): 
· Procedimentos: Subprogramas operacionais que não retornam valor de saída ao final da execução. 
· Funções: Subprogramas projetados para calcular e retornar um valor resultante. 
· Em Python, todos os subprogramas são declarados como funções; subprogramas que omitem o retorno explícito devolvem tacitamente o objeto None, assumindo o comportamento conceitual de procedimentos. 
2.2.6. Ambientes de referenciamento local
 Conjunto de variáveis definidas dentro do escopo de um subprograma (variáveis locais): 
· Variáveis locais dinâmicas da pilha: São vinculadas à memória na ativação da rotina e desalocadas na pilha ao término da execução. Garantem suporte à recursão, mas exigem acessos de memória indiretos. Em Python, todas as variáveis locais são desta categoria. 
· Variáveis locais estáticas: Fixadas em células de memória prévias de forma permanenteaté o fim da execução geral. Possuem acesso direto, mas não suportam chamadas recursivas. 
· Sombreamento e palavra-chave global: Variáveis locais com mesmo identificador de globais sobrepõem-se no ambiente da função. Para modificar variáveis globais a partir do escopo local, exige-se a declaração explícita da palavra-chave global. 
2.2.7. Subprogramas aninhados
 Python suporta o aninhamento funcional, permitindo a definição de funções inteiras no interior do corpo estrutural de outras funções. 
2.2.8. Métodos de passagens de parâmetros
· Passagem por valor: Uma cópia dos dados do argumento real inicializa a variável formal local, isolando alterações da variável externa. 
· Passagem por referência: Transmite-se o endereço da variável externa, permitindo alterações diretas na célula de memória do chamador. 
· Passagem por atribuição (call by assignment): Modelo próprio de Python, onde todos os valores são referências para objetos. 
2.3. Parâmetros, procedimentos e funções na prática
2.3.1. Roteiro de prática
Implementação de validação de CPF fundamentada nas diretrizes formais da Receita Federal: 
· Composição de 11 dígitos numéricos com 2 dígitos verificadores finais. 
· Limpeza de caracteres não numéricos por fatiamento e substituição de strings. 
· Validação de restrições de exceção (como números contendo sequências repetidas). 
· Algoritmo de validação dos dígitos verificadores por cálculo sucessivo com a regra do módulo 11. 
2.4. Funções recursivas e docstrings
2.4.1. Recursividade
Processo algorítmico no qual uma função invoca a si mesma durante sua execução. Para evitar consumo infinito de memória da pilha e interrupção forçada pelo interpretador, uma função recursiva requer: 
1. Casos básicos (condições de parada): Casos com resultados diretos que encerram a cadeia de chamadas recursivas. 
2. Passos recursivos: Chamadas a si mesma utilizando parâmetros que convergem em direção aos casos básicos. 
2.4.2. A função recursiva fatorial
O fatorial $n!$ é definido matematicamente como:
$$n! = \begin{cases} 1, & \text{se } n = 0 \text{ ou } n = 1 \\ n \cdot (n - 1)!, & \text{se } n \ge 2 \end{cases}$$
 A função recursiva implementa o teste de parada para $n \le 1$ e retorna a multiplicação de $n$ pela chamada de si mesma com o argumento $n - 1$. 
2.4.3. A sequência de Fibonacci
 Série numérica onde os dois primeiros elementos são 1 e cada elemento subsequente resulta da soma de seus dois predecessores ($1, 1, 2, 3, 5, 8, 13, 21 \dots$). No algoritmo recursivo, se $n \le 2$ o retorno é 1; caso contrário, retorna a adição das chamadas recursivas para $n - 1$ e $n - 2$. 
2.4.4. Documentação de funções
· Docstrings: Literais de strings descritivas declaradas na primeira linha do corpo de uma função. 
· Permitem documentar formalmente o funcionamento, parâmetros e retorno de subprogramas. 
· Essa documentação é consultada e exibida no console por meio da função de ajuda embutida help(nome_funcao). 
2.5. Funções recursivas na prática
2.5.1. Roteiro de prática
 Solução do quebra-cabeça das Torres de Hanói com estratégia recursiva: 
· Movimentação de discos entre três hastes (origem, auxiliar e destino). 
· Regras: movimentar apenas um disco por vez e nunca sobrepor um disco de maior diâmetro sobre outro menor. 
· Resolução recursiva dividida em transferir $n-1$ discos para a torre intermediária, mover o disco maior restante para a torre definitiva e transferir a pilha intermediária de volta sobre ele. 
3. Bibliotecas em Python
3.1. Importação de funções e módulos
3.1.1. Biblioteca padrão Python
 Para manter o núcleo da linguagem leve e eficiente, muitas rotinas especializadas residem na Biblioteca Padrão (Python Standard Library). Essa biblioteca reúne mais de 200 módulos com classes, métodos e funções dedicados a finalidades específicas (como matemática, interfaces visuais e redes). 
3.1.2. Como usar uma função de módulo importado
Etapas necessárias para utilizar um recurso externo: 
1. Importação explícita com a palavra-chave import nome_modulo. 
2. Invocação dos recursos utilizando a notação de ponto: nome_modulo.nome_funcao(parametros). 
3.2. Módulos básicos nativos do Python
3.2.1. Módulo math
 Fornece funções matemáticas de precisão para operações com argumentos reais (não aceita números complexos): 
· sqrt(x): Raiz quadrada de $x$. 
· ceil(x): Menor inteiro maior ou igual a $x$ (arredondamento para cima). 
· floor(x): Maior inteiro menor ou igual a $x$ (arredondamento para baixo). 
· cos(x) e sin(x): Cosseno e seno em radianos. 
· log(x, b): Logaritmo de $x$ na base $b$. 
· Constantes numéricas fundamentais: pi ($3.141592...$) e e ($2.718281...$). 
3.2.2. Módulo random
 Implementa algoritmos geradores de números pseudoaleatórios para distribuições variadas: 
· Distribuições de valores reais:
· random(): Float no intervalo $[0.0, 1.0)$. 
· uniform(a, b): Float aleatório no intervalo $[a, b]$. 
· gauss(mu, sigma) e normalvariate(mu, sigma): Amostragem de distribuição normal/gaussiana através de média (mu) e desvio padrão (sigma). 
· Funções para números inteiros:
· randrange(stop) e randrange(start, stop[, step]): Seleciona uniformemente um número do intervalo sem instanciar um objeto range. 
· randint(a, b): Retorna um número inteiro aleatório contido no intervalo fechado entre $a$ e $b$. 
· Funções para sequências:
· choice(seq): Sorteia um elemento pontual de uma sequência não vazia. 
· shuffle(x): Embaralha os elementos de uma sequência mutável diretamente no lugar. 
· sample(pop, k): Retorna uma lista de tamanho $k$ contendo itens escolhidos da população sem reposição. 
3.3. Mais módulos nativos do Python
3.3.1. Módulo SMTPLIB
 Cria sessões cliente utilizando o protocolo SMTP para transferir e-mails pela rede. O fluxo de envio envolve: 
· Estabelecimento da conexão de soquete seguro com o servidor SMTP remoto via protocolo TLS. 
· Autenticação de usuário e senha por rotina de login. 
· Envio da mensagem via método de disparo e encerramento da conexão ao final. 
3.3.2. Módulo time
 Fornece funções voltadas ao controle de contadores temporais e datas: 
· time(): Retorna o total de segundos decorridos desde a data de referência (epoch, 00:00:00 UTC de 1º de janeiro de 1970). 
· ctime(segundos): Converte o número de segundos da epoch em uma string formatada legível com o horário local. 
· gmtime() e localtime(): Convertem a marcação em segundos em estruturas do tipo time.struct_time (tupla nomeada com campos como tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec, entre outros). 
· sleep(segundos): Suspende temporariamente a execução do processo pelo tempo especificado. 
3.3.3. Módulo tkinter
Interface padrão embutida no Python para criação de GUIs baseada no toolkit Tk. 
· Janela principal: Instanciada a partir da classe Tk(); exibida e mantida ativa por meio do loop de eventos acionado pelo método mainloop(). 
· Componentes visuais (widgets):
· Label: Rótulo de exibição textual ou de imagem. 
· Button: Botão interativo que recebe um rótulo textual (text) e vincula uma função de retorno ao parâmetro command para responder ao clique. 
· Gerenciadores de layout: O método .pack() centraliza e acomoda dinamicamente os widgets verticalmente na tela conforme a ordem de adição. 
3.4. Módulos nativos do Python na prática
3.4.1. Roteiro de prática
 Desenvolvimento de uma interface gráfica via tkinter reunindo campos de entrada de texto (Entry) para inserção de dois valores numéricos, botões operacionais com tratadores de clique e caixas de exibição para apresentar o resultado de operações aritméticas. 
3.5. Pacotes externos
3.5.1. Usando pacotes externos
 Comunidades de código aberto disponibilizam pacotes adicionais para complementar a linguagem. 
· PyPI (Python Package Index): Repositório público global de módulos e pacotes Python. 
· Gerenciador pip: Ferramenta padrão para instalar, atualizar e remover pacotes externos via linha de comando (pip install ). Requer que o caminho do diretório

Mais conteúdos dessa disciplina