Prévia do material em texto

/
DEFINIÇÃO
Apresentação da metodologia de desenvolvimento rápido de software (RAD) e sua aplicação prática
com o uso da linguagem de programação Python e frameworks para a aceleração do desenvolvimento.
PROPÓSITO
Compreender os conceitos, as fases e vantagens e desvantagens da RAD e apresentar a linguagem de
programação Python e frameworks para RAD.
OBJETIVOS
MÓDULO 1
Descrever a contextualização, os conceitos, princípios, as ferramentas e técnicas da metodologia de
desenvolvimento rápido de software (RAD)
/
MÓDULO 2
Identificar as fases da RAD
MÓDULO 3
Distinguir quando aplicar e quando não aplicar RAD
MÓDULO 4
Justificar o Python e as ferramentas (framework) para o desenvolvimento RAD
INTRODUÇÃO
O desenvolvimento de software tem como objetivo atender as demandas da sociedade, cada vez mais
complexas e com abrangência em diversas áreas. Logo nos primórdios da indústria de software,
aplicavam-se metodologias que seguiam etapas que não eram revistas e, no final dos projetos, muitas
vezes, desenvolvedores e clientes ficavam frustrados com o resultado obtido. Nesse sentido, a
necessidade de criar formas mais eficazes de desenvolver sistemas levou à criação da metodologia
rápida de desenvolvimento de software, mais conhecida pela sigla em inglês: RAD (Rapid Application
Development). Baseia-se na entrega de protótipos para os clientes, a fim de que possam ter uma noção
mais clara do progresso do desenvolvimento do software e que também possam colaborar com
comentários que permitam aos desenvolvedores fazer alterações para atender as expectativas do
cliente.
MÓDULO 1
 Descrever a contextualização, os conceitos, 
princípios, as ferramentas e técnicas da metodologia 
de desenvolvimento rápido de software (RAD)
/
 
Autor: SFIO CRACHO / Fonte: Shutterstock
CONTEXTUALIZAÇÃO
O desenvolvimento rápido de aplicações RAD (Rapid Application Development) é uma metodologia de
desenvolvimento de software com foco na entrega em um período muito inferior ao do ciclo de
desenvolvimento tradicional de software. Não se trata de uma entrega final, mas, sim, de um protótipo
do software. Para que isso seja possível, é feito um planejamento mínimo para obter um protótipo
rápido.
Na metodologia RAD, existe uma concentração no desenvolvimento dos principais módulos funcionais
do sistema. Essa versão inicial, que, apesar de limitada, já é funcional, é chamada de protótipo.
PROTÓTIPO DO SOFTWARE
Um protótipo de software é um modelo funcional que equivale funcionalmente a um componente
do produto. Ou seja, simula apenas alguns aspectos do produto e é útil para o entendimento e a
evolução do sistema final.
Na metodologia RAD, existe uma concentração no desenvolvimento dos principais módulos
funcionais do sistema. Essa versão inicial, que, apesar de limitada, já é funcional, é chamada de
protótipo.
PROTÓTIPO É muito útil para a compreensão do sistema
javascript:void(0)
/
Serve de demonstração para os clientes
É mais flexível para mudanças
Quando está mais evoluído, pode ser integrado ao produto completo para uma
entrega mais rápida da versão final
 Atenção! Para visualização completa da tabela utilize a rolagem horizontal
A RAD também pode ser aplicada para aperfeiçoar o treinamento prático de estudantes de computação,
auxiliando-os em seus futuros empregos. Isso porque os estudantes podem aplicar o conhecimento
adquirido nas aulas para desenvolver sistemas em etapas, conforme é proposto pela RAD. Como será
mostrado mais adiante, o fator humano é um importante requisito para a aplicação dessa metodologia,
então a sua aplicação para treinar recursos humanos pode acelerar a curva de aprendizado dentro de
um curto período.
 
Autor: aurielaki / Fonte: Shutterstock
Os projetos RAD seguem o modelo iterativo e incremental. As equipes de desenvolvimento são
pequenas, compostas por desenvolvedores, analistas de negócio e representantes de clientes. Um dos
aspectos mais importantes deste modelo é garantir que os protótipos desenvolvidos sejam
reutilizáveis para o projeto do sistema, ou seja, a ideia não é criar unidades descartáveis. Isso não
contradiz o fato de o protótipo ser flexível.
javascript:void(0)
/
MODELO ITERATIVO E INCREMENTAL
O desenvolvimento iterativo promove progressos sucessivos, em que o produto é refinado por
etapas. No modelo incremental, o software é entregue em pedaços, que são chamados de
incrementos. A ideia é que o software seja criado em ciclos curtos, com introdução de
funcionalidades, coleta de feedback e revisão.
O RAD FOCA NO DESENVOLVIMENTO RÁPIDO POR
MEIO DE ITERAÇÕES FREQUENTES E FEEDBACK
CONTÍNUO.
 VOCÊ SABIA
O modelo RAD foi introduzido pelo consultor de tecnologia e autor James Martin em 1991 (MARTIN,
1991). Surgiu como o reconhecimento da necessidade de atender o competitivo mercado de software,
que tem uma demanda contínua por novas aplicações. Uma característica que foi explorada para a
formalização da RAD foi a flexibilidade do desenvolvimento de software para projetar modelos de
desenvolvimento. Trata-se de uma combinação de sessões JAD, desenvolvimento de protótipos,
equipes SWAT, entregas com prazo de entrega e ferramentas CASE.
RAD
É muito prática em diversos ambientes modernos de desenvolvimento.
Apresenta uma abordagem útil para criar aplicações de comércio eletrônico e
aplicativos de dispositivos móveis.
Possui uma velocidade de entrega que pode determinar o posicionamento de uma
empresa em um ambiente de mercado muito competitivo.
/
 Atenção! Para visualização completa da tabela utilize a rolagem horizontal
Portanto, trata-se de uma metodologia importante a ser empregada para que as empresas lancem suas
aplicações antes de seus concorrentes.
OBSERVE NO FLUXO COMO INICIAR UM PROJETO RAD:
 
UMA DAS FORMAS DE INICIAR O PROJETO RAD É
ATRAVÉS DA APLICAÇÃO DA METODOLOGIA JOINT
APPLICATION DEVELOPMENT (JAD).
 
TRATA-SE DE UMA METODOLOGIA NA QUAL USUÁRIOS E
ANALISTAS PROJETAM O SISTEMA JUNTOS, SOB UMA
LIDERANÇA EM OFICINAS DE TRABALHO.
 
A IDEIA É POTENCIALIZAR O RESULTADO DO
DESENVOLVIMENTO ATRAVÉS DE DINÂMICAS DE GRUPO.
 
/
OU SEJA, DEFINIR OS OBJETIVOS E AS APLICAÇÕES DO
SISTEMA, DESDE A GERAÇÃO DE TELAS ATÉ A GERAÇÃO
DE RELATÓRIOS.
TEM COMO PRINCÍPIOS: DINÂMICA DE GRUPO; RECURSOS
AUDIOVISUAIS; PROCESSO ORGANIZADO E RACIONAL; A
ESCOLHA DO LOCAL; DOCUMENTAÇÃO COM A
ABORDAGEM WYSIWIG – “O QUE VOCÊ VÊ É O QUE VOCÊ
OBTÉM”.
A RAD foi a precursora do gerenciamento ágil de projetos. As características de prototipagem rápida e
ciclos de liberação e iterações mais curtos fortaleceram o posicionamento da RAD como um método
eficaz no desenvolvimento de software, tornando-se cada vez mais popular entre as empresas ágeis que
procuram métodos que acompanhem o crescimento de suas necessidades comerciais e de clientes.
Trata-se de uma metodologia orientada pelo feedback do usuário, e não por um planejamento detalhado
e caro.
Os métodos tradicionais de desenvolvimento de software, como, por exemplo, a metodologia de
desenvolvimento cascata, seguem modelos rígidos de processo. Isso significa que, nesses modelos
tradicionais, os clientes são pressionados a estabelecer os requisitos antes do início do projeto. A
iteração ao longo do projeto é baixa, o que complica o processo de mudança para novos requisitos e
ajustes de viabilidade.
/
 
Autor: astel design / Fonte: Shutterstock
CONCEITOS
Trata-se de uma abordagem interativa com o objetivo de produzir o desenvolvimento de software de alta
qualidade. O resultado da aplicação da RAD é um software com menor custo, menos erros e menor
tempo de desenvolvimento.
A RAD PODE SER CONSIDERADA UM TIPO DE TÉCNICA
ÁGIL.
(NAZ & KHAN, 2015).
A metodologia RAD combina diversas técnicas para acelerar o desenvolvimento de aplicações de
software. Outra forma pela qual a RAD é conhecida é como “Construção Rápida de Aplicações”, do
inglês Rapid Application Building (RAB). Um dos principais elementos da RAD é o desenvolvimento deprotótipos para chegar ao sistema final. Trata-se de um modelo adaptativo, uma vez que o
desenvolvimento é feito em iterações em que mudanças podem ser realizadas a partir dos comentários
do usuário. A ênfase está na criação rápida de um protótipo, em vez de um planejamento detalhado.
/
A METODOLOGIA RAD POSSUI QUATRO ELEMENTOS
FUNDAMENTAIS:
USO DE FERRAMENTAS PARA DAR SUPORTE AO
DESENVOLVIMENTO
O uso de ferramentas CASE facilita a automação no desenvolvimento de sistemas. Isso é obtido através
de recursos como geração de código e verificação automática de erros de consistência. As ferramentas
CASE, portanto, são usadas para gerar protótipos, dando, assim, suporte ao desenvolvimento iterativo,
possibilitando que os usuários finais acompanhem a evolução do sistema à medida que ele está sendo
construído.
METODOLOGIA BEM DEFINIDA
É seguido um processo formal de desenvolvimento com atividades em etapas e entregas intermediárias.
As tarefas são organizadas de modo a não negligenciar nenhum dos aspectos pré-acordados, e as
técnicas são documentadas para garantir que uma tarefa seja executada da maneira correta.
PESSOAS
Deve haver treinamento das pessoas tanto na metodologia de trabalho como no uso das ferramentas.
As tarefas devem ser distribuídas por pequenas equipes, que devem trabalhar bem juntas.
GESTÃO
O gerenciamento do projeto deve ser feito com rapidez. Isso é obtido através de oficinas de
Planejamento de Requisitos e Design de Sistema para extrair rapidamente os requisitos dos usuários.
Além disso, deve ser feita alocação de tempo fixo (Timebox) para entregar iterativamente o sistema
para os usuários.
TIMEBOX
Timebox é o tempo máximo estabelecido para atingir as metas, tomar uma decisão ou executar um
conjunto de tarefas
javascript:void(0)
/
ALÉM DISSO, EXISTEM DOIS TIPOS DE PROJETOS RAD:
INTENSIVO
FASEADO
Como visto até aqui, está claro que a criação rápida de protótipo é a base da RAD. Nas situações em
que os projetos são orientados por requisitos de interface do usuário, o desenvolvimento de protótipo é
uma escolha muito adequada, pois é normal que o usuário crie a ideia de como a interface do sistema
deve ficar ao longo do desenvolvimento do projeto. O desenvolvimento rápido de protótipos tem como
pré-requisito o uso de ferramentas com suporte a componentes gráficos. No mercado, desde a década
de 1990, existiam diversas ferramentas para esse fim, em que os programadores simplesmente podem
selecionar um componente gráfico e arrastá-lo para um formulário. Desse modo, as interações com os
usuários finais são mais produtivas, pois, constantemente, recebem um software operacional.
PRINCÍPIOS
Constantemente, os programadores são pressionados a entregar as aplicações em prazos curtos e,
muitas vezes, sabe-se com antecedência que o projeto terá de passar por modificações ao longo do
desenvolvimento. Essas situações são exemplos em que o desenvolvimento rápido é bastante útil, pois
ele está embasado exatamente na entrega rápida de protótipos que incorporam os comentários e as
solicitações dos usuários a cada entrega. Para ser eficaz, no entanto, a RAD tem alguns requisitos que
não são triviais. Alguns requisitos relacionados aos recursos humanos são os seguintes:
javascript:void(0)
javascript:void(0)
/
 
Autor: metamorworks / Fonte: Shutterstock
Equipe de desenvolvedores qualificada e motivada.
Usuários comprometidos com a participação ativa ao longo do projeto.
Comprometimento para atingir o resultado satisfatório. 
O desenvolvimento baseado na entrega de protótipos funcionais busca dar a oportunidade para que o
usuário possa interagir com o projeto antes de receber o sistema final. Dessa forma, poderá fazer
comentários e solicitações que guiarão os desenvolvedores na confecção do produto que atenda às
suas expectativas sob o ponto de vista de funcionalidades, recursos, interatividade do sistema
(experiência do usuário), relatórios, gráficos, entre outros.
O RAD É BASEADO EM ALGUNS PRINCÍPIOS BÁSICOS,
QUE SÃO (FITZGERALD, 1998):
ENVOLVIMENTO ATIVO DOS USUÁRIOS
A metodologia RAD reconhece que o envolvimento do usuário é necessário para reduzir problemas
caros de obtenção de requisitos. Além disso, os usuários podem rejeitar completamente os sistemas, se
não estiverem suficientemente envolvidos no desenvolvimento. No centro da abordagem da RAD, estão
as oficinas de design de aplicativos conjuntos (JAD) e planejamento de requisitos conjuntos.
EQUIPES PEQUENAS COM PODER DE DECISÃO
/
As vantagens da elaboração de equipes pequenas estão na redução de ruídos de comunicação e na
minimização de atrasos devido à burocracia que a hierarquia de uma metodologia tradicional impõe. Em
relação aos ruídos de comunicação, os canais que tratam dessa área aumentam proporcionalmente ao
tamanho da equipe, portanto equipes pequenas evitam a distorção e o conflito na comunicação. A
respeito da redução do tempo, empoderar a equipe aumenta as chances de cumprir os prazos por causa
da responsabilidade de tomada de decisão. As equipes têm o poder de tomar decisões sobre o design
(embora as mudanças sejam reversíveis).
ENTREGA FREQUENTE DE PRODUTOS
Diferentemente das metodologias de desenvolvimento tradicionais, em que os projetos podem levar
muito tempo para serem concluídos, a RAD procura reduzir o tempo de desenvolvimento. Portanto,
prazos mais curtos para o desenvolvimento são uma característica importante. Em vez de se concentrar
no processo, a RAD tem como premissa a entrega de produtos que satisfazem os requisitos funcionais.
DESENVOLVIMENTO INCREMENTAL E ITERATIVO
Outro princípio fundamental do RAD é que os sistemas evoluem de forma incremental em cada iteração.
A cada nova iteração, surgem novos requisitos que são incorporados ao sistema. Desse modo, os
sistemas evoluem através da prototipagem iterativa. Existe um entendimento no RAD que a
especificação de requisitos é um processo não determinístico e que evolui à medida que
desenvolvedores e usuários interagem com o protótipo do sistema.
ABORDAGEM TOP-DOWN
Uma vez que, na metodologia RAD, os requisitos não precisam ser completamente definidos logo no
início do projeto, eles são especificados em um nível apropriado ao conhecimento disponível no
momento. Estes são então elaborados através de prototipagem incremental. Os sistemas são
elaborados e confeccionados à medida que o conhecimento cresce. Além disso, como se trata de uma
abordagem de “cima para baixo” caracterizada por um curto período, todas as decisões são
consideradas reversíveis rapidamente.
UTILIZAÇÃO DE FERRAMENTAS DE AUTOMAÇÃO (CASE)
Trata-se de usar programas que facilitem a automação de processos, criação de diagramas, realização
de testes e quaisquer tarefas que facilitem as entregas dentro dos prazos pré-estabelecidos e,
obviamente, com qualidade. Além disso, essas ferramentas facilitam a reutilização de componentes que
podem ser usados ao longo do projeto.
O ponto fundamental na metodologia RAD é que se trata de uma abordagem colaborativa entre todas as
partes interessadas, que são: patrocinadores, desenvolvedores e usuários ao longo da vida de um
projeto.
/
FERRAMENTAS E TÉCNICAS
A RAD precisa ser suportada por ferramentas que auxiliem no desenvolvimento das aplicações
rapidamente. Entre as categorias de ferramentas que dão suporte à RAD para desenvolver projetos de
software estão:
Integração de dados
Ambientes de desenvolvimento
Ferramentas de coleta de requisitos
Ferramentas de modelagem de dados
Ferramentas de geração de código
Desde que a RAD foi formalizada, foram desenvolvidas muitas técnicas para a sua utilização. Cada uma
das técnicas tem suas particularidades, mas mantém a essência da RAD. No quadro a seguir, conheça
algumas dessas técnicas (Naz; Khan, 2015):
TÉCNICA PARTICULARIDADE
Modelo CBD
O método que descreve como componentes
antigos podem ser reutilizados com os novos.
RepoGuard
É um framework para integração de ferramentas de
desenvolvimento com repositórios de código-fonte.Adição dinâmica ágil
Técnicas usadas para integração do ágil para
tornar o projeto mais adaptável.
Método baseado em camadas para
desenvolvimento rápido de software
Baseado em camadas que segue o XP.
Análise de projeto de sistema baseado
em simulação
Desenvolvimento de ferramentas ágeis baseadas
em simulação.
javascript:void(0)
/
Uso de Ajax no RAD Prototipagem rápida em aplicativos e ferramentas
da Web.
Desenvolvimento de aplicativos
multiusuário em ambiente distribuído
rapidamente.
Middleware de comunicação.
Programação extrema Adição de reutilização ao XP.
 Atenção! Para visualização completa da tabela utilize a rolagem horizontal
XP
Extreme Programming (XP) consiste em uma metodologia de desenvolvimento de software que
tem como objetivo maximizar a qualidade do software e responder mais rapidamente às mudanças
nos requisitos do cliente
A ideia do uso das técnicas de RAD é de otimizar os resultados obtidos dentro do tempo estimado, que,
pela natureza da RAD, é curto. Essencialmente, um software é construído para atender a alguma
demanda, ou seja, existe uma razão para que seja confeccionado. Portanto, a interação com os usuários
auxilia o entendimento dos desenvolvedores para construir, agregar e incorporar esse entendimento em
um protótipo através de técnicas e ferramentas que acelerem a entrega e reduzam os desvios de
compreensão. A concordância sobre o propósito do sistema e a sua evolução é muito importante para o
sucesso do projeto. Tanto desenvolvedores como clientes devem estar envolvidos em interações formais
que fortaleçam o comprometimento de todos. 
A pressão por soluções de software confiáveis e em curtos prazos favoreceu a criação da metodologia
de desenvolvimento rápido de software (RAD). A ideia de entregar protótipos em um ciclo de
desenvolvimento incremental e iterativo permite que o usuário possa ter rapidamente uma visão clara de
como o sistema está progredindo e se existe alguma questão relacionada aos requisitos que precisa ser
aperfeiçoada. Portanto, a colaboração entre desenvolvedores e usuários suporta o desenvolvimento de
especificações mais precisas e validadas.
/
VÍDEO COM AVALIAÇÃO
Assista no vídeo a abordagem do especialista sobre a aplicação do RAD em comparação com as
metodologias ágeis existentes, diferenças e motivos para a escolha.
VERIFICANDO O APRENDIZADO
1. A JOINT APPLICATION DEVELOPMENT (JAD) É UMA METODOLOGIA DE
DESENVOLVIMENTO QUE TEM COMO OBJETIVO MELHORAR O
ENTENDIMENTO DO SISTEMA AINDA NO INÍCIO DO PROJETO. EM RELAÇÃO À
METODOLOGIA JAD, SELECIONE A OPÇÃO QUE DESCREVE CORRETAMENTE
UMA CARACTERÍSTICA DELA:
A) Desenvolvedores e usuários do sistema colaboram em oficinas de trabalho.
B) A documentação do sistema é feita detalhadamente, de modo a evitar ambiguidade do entendimento.
C) Desenvolve diversos protótipos em paralelo, de modo que o usuário possa selecionar entre eles qual
o mais próximo dos requisitos funcionais.
D) Trabalha com componentes reutilizáveis de outras versões, de modo a minimizar o tempo de entrega
dos protótipos.
2. A METODOLOGIA RAD TEM COMO OBJETIVO ENTREGAR O SISTEMA
RAPIDAMENTE E COM QUALIDADE. DESDE QUE SURGIU, OUTRAS
METODOLOGIAS EVOLUÍRAM A PARTIR DELA, MAS TODAS TÊM EM COMUM
OS PRINCÍPIOS DO RAD. EM RELAÇÃO AOS TIPOS DE PROJETO RAD,
/
SELECIONE A OPÇÃO QUE DESCREVE CORRETAMENTE UMA
CARACTERÍSTICA DELA:
A) Existem dois tipos bem caracterizados de RAD: com e sem participação do usuário ao longo das
iterações do projeto.
B) Em todos os tipos de RAD, é necessário que haja reuniões entre desenvolvedores e usuários com
dedicação intensiva por curtos períodos, de modo a produzir unidades de sistema utilizáveis.
C) Como o RAD é uma metodologia de desenvolvimento flexível, o mais importante é que o
desenvolvedor termine o software rapidamente.
D) O projeto é desenvolvido em etapas e com a inclusão de novas funcionalidades.
GABARITO
1. A Joint Application Development (JAD) é uma metodologia de desenvolvimento que tem como
objetivo melhorar o entendimento do sistema ainda no início do projeto. Em relação à
metodologia JAD, selecione a opção que descreve CORRETAMENTE uma característica dela:
A alternativa "A " está correta.
 
A principal característica da metodologia JAD são as oficinas de trabalho, em que desenvolvedores e
usuários interagem e colaboram para o entendimento dos requisitos do sistema.
2. A metodologia RAD tem como objetivo entregar o sistema rapidamente e com qualidade.
Desde que surgiu, outras metodologias evoluíram a partir dela, mas todas têm em comum os
princípios do RAD. Em relação aos tipos de projeto RAD, selecione a opção que descreve
CORRETAMENTE uma característica dela:
A alternativa "D " está correta.
 
A colaboração entre usuários e desenvolvedores ao longo do projeto é uma característica fundamental
da RAD. O projeto é desenvolvido com interações e incrementos de funcionalidades. A operação dessa
metodologia pode ocorrer em fases, ou de modo intensivo.
MÓDULO 2
 Identificar as fases da RAD
/
 
Autor: mrmohock / Fonte: Shutterstock
CONCEITOS
A metodologia RAD é caracterizada pelo desenvolvimento do projeto através de etapas iterativas e
incrementais, onde um protótipo é entregue ao final de cada ciclo. A proposta é que haja redução nas
atividades relacionadas ao planejamento em detrimento do processo de desenvolvimento através de um
processo que se caracteriza por incrementos de funcionalidades a cada nova iteração. Desse modo, a
expectativa é que as equipes produzam mais em menos tempo, maximizando a satisfação do cliente,
uma vez que ele é envolvido no processo. Isso ocorre porque a RAD é estruturada para que as partes
interessadas interajam e possam detectar a necessidade de alterações do projeto em tempo real, sem a
necessidade de completar longos ciclos de desenvolvimento, e os desenvolvedores possam realizar as
implementações rapidamente ao longo das iterações.
/
 
Autor: fotoinfot / Fonte: Shutterstock
O ciclo de vida da RAD foi projetado para direcionar os desenvolvedores na criação de soluções de
software que atendam às necessidades dos usuários. Este ciclo de vida trata das atividades que são
necessárias para definir o escopo e os requisitos de negócios, além das atividades para projetar,
desenvolver e implementar o sistema. Na abordagem de James Martin (MARTIN, 1991), a metodologia
RAD possui quatros fases distintas, que são:
FASE 1
FASE 2
FASE 3
FASE 4
PLANEJAMENTO DE REQUISITOS
As partes interessadas – usuários, gerentes e desenvolvedores – estudam as necessidades de
negócios, escopo do projeto, restrições e requisitos do sistema. A gerência só autoriza a continuidade do
projeto depois que os membros das equipes concordam sobre o entendimento dos requisitos do
sistema.
DESIGN DO USUÁRIO
/
São desenvolvidos modelos e protótipos – através da interação de usuários e desenvolvedores – para
representar todos os processos, entradas e saídas do sistema. Para isso, são usadas uma combinação
de técnicas JAD (Joint Application Development) e ferramentas CASE para representar as demandas do
usuário em modelos de trabalho.
CONSTRUÇÃO
É nesta fase que os protótipos são desenvolvidos. A interação entre usuários e desenvolvedores
continua, para que haja sugestões sobre alterações, ajustes, ou melhorias, à medida que unidades do
sistema – como telas ou relatórios reais, por exemplo – são desenvolvidas.
TRANSIÇÃO
São feitos processamento de dados, testes, mudança para o novo sistema e treinamento do usuário.
 RESUMINDO
O planejamento de requisitos está focado em determinar as metas e expectativas do projeto e quais são
os potenciais problemas que podem ser impeditivos para o desenvolvimento do software. No caso da
RAD, onde a entrega rápida de resultados é um dos objetivos principais, a identificação prévia dos
requisitos funcionais é muito importante. Na fase de design do usuário, a interação entre os
desenvolvedores e os usuários é constante no desenvolvimento de modelos e protótiposque abordam
todos os processos, entradas e saídas do sistema. Na fase de construção, converte o protótipo
aprovado da fase de design do usuário em um modelo de trabalho. Como já houve bastante interação
entre usuários e desenvolvedores na fase anterior, agora o foco dos desenvolvedores está na
construção do modelo de trabalho final. Por fim, na fase de transição, o produto está pronto para ser
lançado. Aqui, o usuário deve passar por treinamento para começar a usar o sistema.
Existem outras abordagens sobre a divisão das fases da RAD. Por exemplo, uma das mais conhecidas
é a de James Kerr (KERR & HUNTER, 1994), em que existem cinco fases distintas, que são:
FASE 1
FASE 2
FASE 3
/
FASE 4
FASE 5
MODELAGEM DE NEGÓCIOS
Nesta fase, é feita a obtenção de informações a respeito dos requisitos funcionais do sistema reunidas
por várias fontes relacionadas aos negócios, ou seja, o modelo de negócios do produto em
desenvolvimento é tratado em termos de fluxo de informações, que são obtidas a partir de vários canais
de negócios, tais como entrevistas com usuários do sistema e outras fontes de informação que auxiliem
no entendimento do negócio que será tratado. Essas informações são então combinadas, para criar uma
documentação que será utilizada para modelar o ciclo de vida dos dados: como os dados podem ser
usados, quando são processados e a sua transformação em informações que serão utilizadas por
alguma área, ou por algum setor específico do negócio. Portanto, é feita uma análise com viés comercial
a fim de encontrar os dados vitais para os negócios: como podem ser obtidos, como e quando são
processados e quais são os fatores que os transformam em informações úteis.
MODELAGEM DE DADOS
Todas as informações que foram obtidas durante a fase modelagem de negócios são analisadas para
formar conjuntos de objetos de dados essenciais para os negócios. Através da análise, as informações
são agrupadas, de modo que sejam úteis para a empresa, como, por exemplo, na determinação de
quais são as entidades principais que serão tratadas pelo sistema. A qualidade de cada grupo de dados,
então, é examinada e recebe uma descrição precisa. Em seguida, é feito mapeamento que relaciona
esses grupos entre si e qual o significado desses relacionamentos, conforme definido na etapa
modelagem de negócios. Avançando um pouco mais, agora deve-se identificar e definir os atributos de
todos os conjuntos de dados. Também é estabelecida e definida em detalhes de relevância para o
modelo de negócios a relação entre esses objetos de dados.
MODELAGEM DE PROCESSOS
Esta fase é a etapa da metodologia RAD em que todos os grupos de dados coletados durante a etapa
modelagem de dados são analisados sob o ponto de vista de processamento, ou seja, como os dados
são convertidos em informações úteis. Durante a fase de modelagem de processos, mudanças e
otimizações podem ser feitas, e os conjuntos de dados podem ser definidos com mais detalhes.
/
Quaisquer descrições para adicionar, remover ou alterar os objetos de dados também são criadas
durante esta fase. A ideia é a seguinte: os conjuntos de objetos de dados definidos na fase de
modelagem de dados são convertidos para estabelecer o fluxo de informações de negócios necessário
para atingir objetivos de negócios específicos conforme o modelo de negócios. A modelagem de
processamento dos dados para alterá-los, ou utilizá-los para fazer quaisquer outras operações que os
transformem, é definida nesta fase. Aqui, também são feitas descrições dos processos para adicionar,
excluir, recuperar ou modificar um objeto de dados.
GERAÇÃO DA APLICAÇÃO
Nesta fase, todas as informações coletadas são codificadas e é construído o sistema que será usado
para criar o protótipo. Os modelos de dados criados são transformados em protótipos reais que podem
ser testados na próxima fase. O sistema real é construído, e a codificação é feita usando ferramentas de
automação para converter modelos de processo e dados em protótipos reais.
TESTE E MODIFICAÇÃO
Neste momento, são feitos testes dos protótipos criados. Cada módulo é testado de modo a identificar e
adaptar os componentes para criar o produto mais eficaz. Como a maioria dos elementos já foi
examinada anteriormente, a expectativa é que haja grandes problemas com o protótipo. O tempo total
de teste é reduzido no modelo RAD, pois os protótipos são testados independentemente durante cada
iteração. No entanto, o fluxo de dados e as interfaces entre todos os componentes precisam ser
exaustivamente testados com uma cobertura de teste completa. Como a maioria dos componentes de
programação já foi testada, o risco de problemas importantes é minimizado.
O princípio-chave do processo RAD é a redução de atividades burocráticas para se concentrar em um
processo iterativo de design e construção, permitindo que as equipes realizem mais em menos tempo,
sem afetar a satisfação do cliente. As fases de prototipagem e construção rápida podem ser repetidas,
até que o proprietário e os usuários do produto se sintam seguros de que o protótipo e a forma como foi
construído atendem aos requisitos do projeto.
/
 
Autor: McLittle Stock / Fonte: Shutterstock
Nos métodos tradicionais, como a metodologia cascata, por exemplo, demora bastante até que os
desenvolvedores recebam comentários dos usuários, aumentando, assim, as chances de ser necessário
refazer partes do sistema, ou seja, retrabalho. Nesse sentido, um dos maiores benefícios da RAD
são os comentários dos usuários através da constante interação. O ponto do projeto em que fica
mais evidente essa interação está nos componentes de UI/UX do sistema. Com os protótipos, os
usuários podem ter mais clareza sobre a forma como o projeto está avançando, e os desenvolvedores
podem medir riscos na escolha de tecnologias que venham prejudicar a entrega do projeto, podendo,
assim, fazer escolhas em tempo hábil.
UI/UX
O termo UI faz referência a “interface com o usuário” no sentido de telas e demais componentes
interativos. Já o termo UX é usado para se referir à “experiência do usuário” com o sistema, ou
seja, a melhor forma do usuário interagir com o sistema no aspecto ergonômico de como entrar
com dados e obter informações.
CICLO DE DESENVOLVIMENTO
javascript:void(0)
/
O ciclo de desenvolvimento da metodologia RAD começa com as partes interessadas – usuários e
desenvolvedores – definindo um conjunto de requisitos do projeto, que é equivalente ao que seria feito
durante o escopo do projeto nos ciclos de desenvolvimento tradicionais. Esse estágio de planejamento é
“rápido”, pois a ênfase da metodologia RAD está nas iterações de construção de protótipos que são
mais importantes para o sucesso final de um projeto. Todos os envolvidos no projeto – desenvolvedores,
clientes, usuários e equipes de software – são levados a interagir entre si, de modo a determinar os
requisitos do projeto e, em caso de problemas, quais estratégias serão aplicadas durante o
desenvolvimento.
OS REQUISITOS INCLUEM:
Metas
Expectativas
Cronogramas
Orçamento
Espera-se que o cliente forneça a visão para o produto, e, em colaboração com outras partes
interessadas, são realizadas pesquisas para finalizar os requisitos com a aprovação de cada parte
interessada. É necessário que todos os interessados fiquem convencidos de que o entendimento do
projeto está claro desde o início do ciclo de desenvolvimento, pois isso ajuda as equipes a evitar falhas
de comunicação e erros dispendiosos.
 ATENÇÃO
Outro ponto importante a ser destacado é que um dos princípios fundamentais da RAD é a capacidade
de alterar os requisitos em qualquer momento do ciclo de desenvolvimento.
LEVANTAMENTO DE REQUISITOS
Logo no início do levantamento de requisitos, é feita uma pesquisa do ambiente interno para
compreender de que forma atender o projeto que será iniciado. Logo depois, é desenvolvido o escopo
do sistema proposto. Os processos de negócios e os dados com os quais o sistema trabalhará são
usadospara definir as suas respectivas funcionalidades. Características como benefícios, custos e
/
riscos potenciais do sistema são identificadas. Passa-se, então, para a documentação de possíveis
problemas de gerenciamento, e, por fim, formaliza-se o escopo do sistema. Faz-se também uma
estimativa dos recursos e do tempo de implementação. Se o custo e a duração do desenvolvimento já
forem definidos, é necessário analisar com mais cuidado o escopo do projeto para verificar se é viável.
OFICINAS JAD
Para completar a análise de negócios e de dados do sistema, são feitas as oficinas JAD, em que são
realizados revisões e detalhamento do escopo do sistema para garantir que as entregas ocorram dentro
do prazo. Um exemplo de resultado obtido dessa fase são a definição das regras de negócios a serem
aplicadas em cada atividade e os atributos de cada entidade. Aqui, elementos de UI/UX, tais como
layouts provisórios de telas e dos principais relatórios, são desenvolvidos. Além disso, um esboço do
projeto do sistema é desenvolvido. Com a conclusão do design, passa-se a mapear as funcionalidades
do sistema com seus componentes de interação.
VALIDAÇÕES DOS PROTÓTIPOS
A consistência do projeto é confirmada através das sucessivas iterações, em que são apresentados
protótipos para os usuários validarem. Através de testes, são identificados erros, ou a necessidade de
se fazer ajustes no sistema. Ainda nesta fase, são iniciadas estratégias para a implementação do
sistema. Em determinado momento, deve-se finalizar o escopo do projeto e o plano de implementação.
Por fim, os resultados das interações entre desenvolvedores e usuários são incorporados ao projeto e
ao plano de transição. Se tudo for aprovado, passa-se para a fase de construção rápida.
BANCO DE DADOS
Agora, com o ambiente de desenvolvimento concluído, a próxima etapa é o projeto de banco de dados,
que deve ser construído conforme a estrutura de dados desenvolvida na fase de design do usuário. O
sistema passa a integrar as funcionalidades de banco de dados com os componentes de interação
visual. Aplicam-se, agora, os testes, que devem ser executados com dados que simulem situações reais
e auxiliem na detecção de possíveis falhas, para que sejam devidamente tratadas, e na documentação
do sistema. Cada componente do sistema e as funcionalidades são verificadas de acordo com os
requisitos do usuário. Por fim, são iniciados os preparos para a fase de transição através dos planos de
trabalho e de contingência.
TRANSIÇÃO
Nesta última fase, a de transição, são feitos treinamentos para o usuário utilizar o sistema antes que
seja colocado em produção. Em seguida, o sistema é colocado em produção e, por fim, instalado no
cliente. Configurações de hardware, instalações de bibliotecas e demais configurações são concluídas
nesta etapa. A última tarefa a ser terminada é a aceitação do sistema por parte do usuário, conforme o
que foi estabelecido na etapa inicial do projeto.
Após a definição do escopo do projeto, as equipes iniciam a construção dos modelos e protótipos. O
objetivo é demonstrar para o cliente um design funcional o mais rápido possível.
/
 
DESENVOLVEDORES E DESIGNERS – QUE DESENVOLVEM
TELAS E COMPONENTES INTERATIVOS – TRABALHAM EM
COLABORAÇÃO COM OS CLIENTES ATÉ QUE O PRODUTO
ESTEJA PRONTO, PARA QUE OS REQUISITOS FUNCIONAIS
SEJAM ATENDIDOS.
 
ESSA ETAPA É REPETIDA À MEDIDA QUE O PROJETO É
CONSTRUÍDO.
 
DURANTE A FASE INICIAL DE PROTOTIPAGEM, OS
DESENVOLVEDORES FOCAM SEUS ESFORÇOS EM
ELEMENTOS ESSENCIAIS DO SISTEMA PARA PRODUZIR
UM PRODUTO QUE SEJA ACEITÁVEL PELO PROPRIETÁRIO
DO PRODUTO.
 
/
O USO DE PROTÓTIPOS CONSTRUÍDOS RAPIDAMENTE
INCENTIVA O ENVOLVIMENTO DO USUÁRIO NOS TESTES
DO SISTEMA E, COMO CONSEQUÊNCIA, SÃO OBTIDOS
COMENTÁRIOS QUE PODEM SER UTILIZADOS PARA
APERFEIÇOAR O TRABALHO QUE ESTÁ SENDO
EXECUTADO, EM VEZ DE TENTAR FAZER AVALIAÇÕES
ABSTRATAS DE UM DOCUMENTO DE DESIGN.
 
COM ESSES COMENTÁRIOS, OS DESENVOLVEDORES
PODEM AJUSTAR OS MODELOS DE FORMA INCREMENTAL,
ATÉ QUE SE ATENDA AOS REQUISITOS DO PROJETO. A
EXPERIÊNCIA COMPARTILHADA ENTRE AS PARTES
INTERESSADAS É OBTIDA ATRAVÉS DA BOA
COMUNICAÇÃO. O APRENDIZADO HABILITA A
IDENTIFICAÇÃO RÁPIDA DO QUE FUNCIONA E O QUE NÃO
FUNCIONA.
A LIBERAÇÃO RÁPIDA DE PROTÓTIPOS AUMENTA AS
CHANCES DE DESCOBRIR ERROS PRECOCEMENTE, O
QUE LEVA AO AUMENTO DA CONFIABILIDADE DO
SISTEMA. ATRAVÉS DA CRIAÇÃO DE PROTÓTIPOS, A
EQUIPE DE DESENVOLVIMENTO PODE AVALIAR A
VIABILIDADE DE COMPONENTES COMPLEXOS.
CONSEQUENTEMENTE, AUMENTA-SE A ROBUSTEZ DO
/
SOFTWARE, ALÉM DE FACILITAR ADIÇÕES DE DESIGN
FUTURAS.
O DESENVOLVIMENTO RÁPIDO TORNA POSSÍVEL
QUE PROTÓTIPOS EVOLUAM PARA A VERSÃO
COMERCIAL DO SISTEMA, OU SEJA, QUE AS
VERSÕES PARCIAIS PROGRIDAM PARA O
SOFTWARE QUE VAI ATENDER ÀS EXPECTATIVAS
DO CLIENTE. ATRAVÉS DE INCREMENTOS AO
LONGO DAS ITERAÇÕES, NOVOS COMPONENTES E
NOVAS ALTERAÇÕES SÃO FEITAS. AS EQUIPES DE
DESENVOLVIMENTO USAM FERRAMENTAS
COMPUTACIONAIS QUE VIABILIZAM O PROGRESSO
RÁPIDO PARA A VERSÃO FINAL DO SISTEMA. NA
METODOLOGIA RAD, A MAIORIA DOS PROBLEMAS
E AJUSTES SÃO TRATADOS DURANTE A FASE DE
PROTOTIPAGEM ITERATIVA.
Nas metodologias tradicionais, os desenvolvedores consomem muito tempo com atividades que não
estão diretamente ligadas ao desenvolvimento do projeto. No caso da RAD, são feitos muitos testes,
aumentando, assim, as chances de que o resultado satisfaça as expectativas do cliente. A colaboração
entre desenvolvedores e usuários finais auxilia na construção de interfaces e funcionalidades que
melhorarão todos os aspectos do produto. Os clientes fornecem informações detalhadas com sugestões
de alterações – ajustes, ou novas ideias – que resolvem os problemas à medida que são descobertos.
A metodologia RAD se baseia no desenvolvimento iterativo e incremental. Ela é dividida em fases,
caracterizando-a, assim, como um método com definição de procedimentos que devem ser seguidos
para se atingir a meta do projeto: atender às necessidades do cliente dentro de um prazo curto e sem
erros, ou, pelo menos, com o mínimo possível de erros. A existência de mais de uma abordagem para
tratar as suas fases não muda a essência do processo, que se caracteriza pela interação constante
entre usuários e desenvolvedores.
/
VÍDEO COM AVALIAÇÃO
Assista no vídeo a apresentação das fases do RAD exemplificando com um caso prático.
VERIFICANDO O APRENDIZADO
1. AS FASES DA METODOLOGIA RAD AUXILIAM NO ENTENDIMENTO DO
PROJETO E, PORTANTO, NA CONSTRUÇÃO DE UM SISTEMA COM MENOS
ERROS. NESSE SENTIDO, SELECIONE A OPÇÃO CORRETA SOBRE AS FASES
DA METODOLOGIA RAD:
A) A coleta de dados pode ser feita em qualquer uma das fases da metodologia RAD, desde que seja
necessário complementar alguma informação.
B) A fase de modelagem de processos inicia mediamente após a estruturação dos dados em objetos de
negócio.
C) A modelagem de negócios está focada nos negócios da empresa cliente. A partir de uma visão
holística, é feito um refinamento do entendimento até chegar aos requisitos do sistema.
D) Apesar de a RAD ser uma metodologia flexível, todas as fases devem ser bem documentadas; em
especial, as transições entre elas.
2. INDEPENDENTEMENTE DA METODOLOGIA QUE SEJA UTILIZADA PARA
DESENVOLVER UM SOFTWARE, SEMPRE SERÁ NECESSÁRIO EXECUTAR
TESTES PARA VERIFICAR SE HÁ ALGUM ERRO E, DESSE MODO, TOMAR AS
/
AÇÕES MAIS ADEQUADAS. EM RELAÇÃO À METODOLOGIA RAD, SELECIONE
A OPÇÃO CORRETA SOBRE OS TESTES DE SOFTWARE:
A) Os testes sempre devem ser feitos no final do ciclo de uma iteração.
B) Os testes devem ser focados exclusivamente nas funcionalidades que foram acrescentadas na
iteração.
C) Dada a flexibilidade da metodologia RAD, os testes podem ser executados em qualquer momento do
ciclo de vida do desenvolvimento.
D) Testes de software envolvem a alocação de pessoas treinadas e outros recursos computacionais,
além de consumirem bastante tempo, portanto só devem ser realizados quando houver um consenso
entre desenvolvedores e usuários.
GABARITO
1. Asfases da metodologia RAD auxiliam no entendimento do projeto e, portanto, na construção
de um sistema com menos erros. Nesse sentido, selecione a opção CORRETA sobre as fases da
metodologia RAD:
A alternativa "B " está correta.
 
As fases da metodologia RAD devem ser executadas em sequência, pois são complementares. No caso
da modelagem de processos, é necessário que os dados já tenham sido organizados em objetos de
negócio na fase de modelagem de dados.
2. Independentemente da metodologia que seja utilizada para desenvolver um software, sempre
será necessário executar testes para verificar se há algum erro e, desse modo, tomar as ações
mais adequadas. Em relação à metodologia RAD, selecione a opção CORRETA sobre os testes de
software:
A alternativa "A " está correta.
 
Os testes de software são uma etapa essencial no ciclo de vida de desenvolvimento do software. No
caso da metodologia RAD, os testes são executados ao final de cada ciclo iterativo. É fato que, de modo
geral, os testes são caros, mas o que a metodologia RAD faz é reduzir o custo deles, uma vez que uma
versão só começará se a anterior tiver sido aprovada; logo, existe a expectativa de que o sistema tenha
poucos problemas para serem verificados e corrigidos.
/
MÓDULO 3
 Distinguir quando aplicar e quando não aplicar RAD
 
Autor: Friends Stock / Fonte: Shutterstock
CONCEITOS
A metodologia RAD tem por objetivo fazer a entrega dos sistemas em menos tempo e com menos erros
do que os métodos tradicionais de desenvolvimento. No entanto, para implementar esta metodologia, as
empresas precisam satisfazer algumas condições, que são (BERGER & BEYNON-DAVIES, 2009):
 
Autor: 4 PM production / Fonte: Shutterstock
/
PESSOAS
Profissionais qualificados e com rápida adaptação, além de trabalhar bem em equipe.
 
Autor: SFIO CRACHO / Fonte: Shutterstock
GERENCIAMENTO
Equipes com poder de decisão para evitar perda de tempo, o que é comum nos modelos tradicionais.
/
 
Autor: REDPIXEL.PL / Fonte: Shutterstock
USO DE FERRAMENTAS COMPUTACIONAIS (CASE)
Programas que facilitem criação de diagramas e interface com usuário, componentes reutilizáveis (APIs,
frameworks e templates, por exemplo) e de fácil manutenção.
A aplicação da RAD gera sistemas cujas telas e demais componentes são padronizados, devido ao uso
de ferramentas com bibliotecas e templates reutilizáveis. No entanto, algumas características, como
desempenho do sistema e análise de risco, são menos tratadas, pois são atividades que demandam
tempo em qualquer projeto. Portanto, a RAD é mais adequada para softwares de baixa
complexidade.
Nesta parte do texto, é natural associar a RAD a uma metodologia ágil, inclusive alguns autores fazem
essa associação, pois, de fato, há muitas semelhanças entre as duas metodologias e, portanto, as
vantagens e desvantagens de ambas seriam idênticas. Entretanto, existem algumas diferenças entre
elas. Na RAD, há uma limitação de trabalhar com várias equipes, enquanto no desenvolvimento ágil isso
ocorre de modo normal. Outro ponto a ser considerado é o cumprimento dos prazos. Na RAD, o
comprometimento é com a rapidez e qualidade das entregas nas iterações, na expectativa, é claro, de
que isso se reflita para o projeto como um todo. No caso dos métodos ágeis, existem prazos a cumprir
do ponto de vista global do projeto.
 ATENÇÃO
/
A RAD nem sempre é adequada para ser aplicada a um projeto, como será discutido mais adiante.
Existem casos, inclusive, em que métodos tradicionais são mais pertinentes. Trata-se de uma
metodologia que funciona muito bem sob certas circunstâncias e disponibilidade de recursos e que, em
outros casos, não é recomendada, como veremos.
METODOLOGIA RAD – VANTAGENS E
DESVANTAGENS
O modelo RAD tem por objetivo a entrega rápida, pois o tempo total de desenvolvimento é reduzido
devido à reutilização dos componentes e ao desenvolvimento paralelo. Para que funcione bem, a RAD
precisa de profissionais qualificados e que o cliente também se comprometa a colaborar a fim de que os
protótipos evoluam para o sistema desejado no prazo determinado. Caso não haja esse compromisso
de ambos os lados, a metodologia poderá falhar.
 
Autor: G-Stock Studio / Fonte: Shutterstock
Apesar da rapidez e qualidade da entrega serem as principais vantagens das RAD, também há
desvantagens em relação à escalabilidade dos projetos e à demanda por recursos. Sobre a rapidez da
entrega, isso é obtido através do uso de ferramentas que auxiliam a conversão de requisitos em código,
permitindo, assim, que os desenvolvedores e usuários possam interagir através de protótipos que já são
funcionais. A respeito da melhoria da qualidade, com a RAD, será tão melhor quanto um software
entregue que atende às necessidades dos usuários, onde são necessárias poucas intervenções para
correção de erros, implicando, assim, em baixos custos de manutenção.
/
Portanto, a aplicação da RAD tem muitos benefícios para o desenvolvimento do projeto, em especial por
integrar as equipes de software e seus clientes. Os times de desenvolvimento têm um aumento da sua
produtividade, uma vez que rapidez e agilidade são prioridades. Isso melhora os resultados do projeto e
torna possível que as entregas ocorram nos prazos estimados. Agora, clique e saiba algumas das
principais vantagens do uso de um método RAD (Berger & Beynon-Davies, 2009):
PRINCIPAIS VANTAGENS:
INTEGRAÇÃO ANTECIPADA DO SISTEMA E REDUÇÃO DE
RISCOS
A entrega rápida de protótipos que funcionam por parte das equipes da RAD viabiliza que as empresas
façam revisões das funcionalidades do projeto desde o início do ciclo de vida do software. Todos os
aspectos que se referem ao sistema podem ser reavaliados, devido às iterações frequentes e pelos
comentários e sugestões dos usuários, permitindo a análise do progresso dos trabalhos de forma
mensurável, que determina se os cronogramas e orçamentos estão no caminho certo. A integração com
outros sistemas e serviços é feita no final de um ciclo de vida de desenvolvimento, como ocorre nas
metodologias tradicionais. Os testes são realizados durante cada iteração, de modo que as partes
interessadas identifiquem e analisem os erros e tratem as vulnerabilidades, resolvendo-os rapidamente,
para que não impactem no progresso do desenvolvimento. Redução no risco significa redução nos
custos.
ADAPTABILIDADE E COMPARTIMENTAÇÃO DOS
COMPONENTES DO SISTEMA
Durante o desenvolvimento, é mais fácil fazer modificações no software, ou seja, enquanto o projeto não
é concluído, o software é maleável. É claro que alterações devem ser realizadas com cuidado, pois, por
menor que possam parecer, podem afetar todo o sistema. De modo geral, os desenvolvedores podem
usar essa flexibilidade para criar protótipos ao longo do processo. Dada essa característica iterativa,
designers e desenvolvedores são incentivados a criar componentes funcionais e independentes que
sejam reutilizáveis.
VERSÕES ITERATIVAS E MENOR TEMPO DE COLOCAÇÃO
NO MERCADO
O uso de ferramentas que suportam o desenvolvimento fortalece as equipes de desenvolvimento a
entregar protótipos prontos, ou seja, utilizáveis, para produção mais rápida do que o desenvolvimento
feito pelas metodologias tradicionais. As equipes devem ser pequenas, pois a ideia é que o trabalho
“repetitivo” seja feito por essas ferramentas, pois, assim, ocorre o aumento da produtividade. As
/
iterações frequentes incentivam a quebra das tarefas, o que é conhecido como “granularização”. Essas
tarefas são atribuídas aos membros da equipe, conforme a especialidade e experiência de cada um.
FEEDBACK CONSTANTE DO USUÁRIO
Trata-se de uma das principais características da RAD. A eficiência e a qualidade do projeto aumentam
com a comunicação regular e o feedback constante dos usuários finais. A estrutura iterativa e o acesso
aos componentes de UI / UX de um sistema aumentam ainda mais a importância do feedback dos
usuários. O fato de os desenvolvedores terem a oportunidade de apresentar paraos usuários os
protótipos que construíram faz com que fiquem mais confiantes de que estão no caminho certo para
satisfazer o cliente quando o produto final é entregue.
Uma das principais características da metodologia RAD é a entrega de protótipos funcionais.
Exatamente por isso, a escalabilidade dos projetos é reduzida, pois a aplicação da metodologia sem
adaptações inviabiliza a interação com o usuário para um sistema complexo. Este assunto será tratado
um pouco mais adiante neste texto. A limitação do tempo de desenvolvimento das iterações é uma
característica muito importante para fazer as entregas rápidas, porém é um limitador para a
implementação de recursos mais avançados. Portanto, embora a RAD tenha diversos benefícios, há
situações para as quais a metodologia não é adequada. Por exemplo, a RAD não funciona bem em
projetos onde o risco técnico é alto. A seguir, clique e saiba sobre algumas das desvantagens da RAD
(BERGER & BEYNON-DAVIES, 2009):
PRINCIPAIS DESVANTAGENS:
NECESSIDADE DE EQUIPES TECNICAMENTE MUITO
QUALIFICADAS
A RAD depende fortemente das habilidades de modelagem – de dados e processos –, e, além disso, é
necessário que os profissionais tenham rápida adaptação, pois, devido à natureza da metodologia, é
possível haver mudanças significativas ao longo das iterações. Portanto, uma equipe bem qualificada é
essencial para identificar e entregar os requisitos de negócios.
FOCO EXIGENTE NA INTERFACE
Os clientes fazem a avaliação da qualidade de uma solução com base no que eles podem interagir em
um protótipo. A RAD é caracterizada por iterações nas quais são implementadas novas funcionalidades
– incrementos – e, ao final delas, são entregues protótipos. Os clientes podem avaliar os progressos a
cada novo lançamento. Devido à rapidez com que os protótipos são implementados, às vezes, os
desenvolvedores não aplicam as melhores práticas no projeto, preocupando-se, essencialmente, com o
/
que deve ser entregue para satisfazer as necessidades imediatas do usuário. Isso pode gerar dívidas
técnicas, o que pode implicar em problemas quando for entregar a versão final do sistema.
REQUER ALTO NÍVEL DE COMPROMETIMENTO DE TODAS
AS PARTES INTERESSADAS
Nos métodos de desenvolvimento tradicionais, os requisitos funcionais são definidos no início do projeto
e não são revisitados posteriormente; portanto, clientes e equipes de desenvolvimento não interagem ao
longo do projeto. Já na RAD, o entendimento do projeto evolui à medida que é feito; logo, a colaboração
entre as partes interessadas é essencial. Caso isso não ocorra, pode haver um comprometimento muito
sério da qualidade do projeto.
REQUER SISTEMAS MODULARES E É DIFÍCIL PARA
PROJETOS DE GRANDE ESCALA
A natureza da RAD em fazer entregas rápidas ao longo das iterações demanda foco nas partes
essenciais do sistema. Desse modo, outros elementos importantes, como questões de segurança,
desempenho e tratamento de erros, por exemplo, podem ficar comprometidos. Outro ponto que deve ser
considerado é que, para fazer entregas “rápidas” de protótipo, a RAD demanda ferramentas que são
padronizadas, ou seja, o desenvolvedor tem pouca flexibilidade no desenvolvimento. Para projetos de
baixa complexidade, essa é uma característica muito interessante, mas, para projetos de grande escala,
em que há muitas outras tecnologias envolvidas, a RAD não é adequada.
COMPARAÇÃO DE RAD COM OUTRAS
METODOLOGIAS
RAD
A primeira e mais importante diferença entre a RAD e as demais metodologias de desenvolvimento
é a concentração dos esforços pelo desenvolvimento rápido com entregas constantes de
protótipos.
Na RAD trabalha-se com uma única equipe de desenvolvimento, com poucos membros. A ideia é
melhorar a qualidade da comunicação e a transferência rápida de informações.
Na RAD, é fundamental envolver o usuário em todo o processo de desenvolvimento.

/

OUTRAS METODOLOGIAS
Nos outros modelos, de modo geral, a preocupação principal é entregar um produto funcional para
o cliente.
Enquanto em outras metodologias trabalha-se com equipes maiores divididas em diferentes
especializações, como, por exemplo, o modelo para equipe ágil,
Nas metodologias tradicionais, usuários são envolvidos apenas no início e no final do ciclo de
desenvolvimento do projeto.
Como foi apresentado no começo deste módulo, a RAD e as metodologias ágeis têm muitos pontos em
comuns. De fato, a RAD é um predecessor das metodologias ágeis, embora essas últimas sejam mais
abrangentes do que uma metodologia de desenvolvimento. Suas principais diferenças estão no
estabelecimento de um cronograma de entregas, na importância dos comentários dos usuários para o
projeto e no desenvolvimento focado em desenvolver protótipos do projeto – que é o caso da RAD – em
detrimento do desenvolvimento de características do projeto – que é o caso das metodologias ágeis.
METODOLOGIA RAD – QUANDO APLICAR E
QUANDO NÃO APLICAR
A metodologia RAD é adequada para determinados tipos de desenvolvimento, como, por exemplo,
quando a interatividade do front-end dos sistemas é uma característica muito importante em detrimento
da complexidade do back-end (BERGER & BEYNON-DAVIES, 2009).
QUANDO APLICAR
QUANDO NÃO APLICAR
QUANDO APLICAR
/
A RAD não é adequada para as seguintes situações: desenvolvimento de sistemas críticos em tempo
real; sistemas de infraestrutura muito grandes e quando os requisitos funcionais precisam ser
especificados detalhadamente ainda no início do projeto. Para complementar, a aplicação da RAD não é
adequada quando o sistema deve interagir com outros sistemas já existentes.
QUANDO NÃO APLICAR
A RAD é adequada para projetos de pequena escala com equipes também otimizadas de quatro a oito
pessoas. No caso de projetos de grande escala, caso seja aplicada a RAD, é necessário que sejam
divididos em projetos menores e mais facilmente gerenciáveis. Além disso, é preciso que haja o
envolvimento das partes interessadas, de modo a maximizar o entendimento do sistema. Para isso, as
equipes precisam ter poderes para tomar decisões.
EQUIPES PRECISAM TER PODERES PARA TOMAR
DECISÕES
A capacidade de poder tomar decisões reduz o tempo para realizar modificações sem que haja a
necessidade de aprovação por outros níveis hierárquicos dentro da organização. Portanto, a
comunicação eficaz no desenvolvimento entre as partes interessadas é bastante importante na
RAD.
Nas oficinas de trabalho, em que ocorrem as reuniões entre usuários e desenvolvedores, são usadas
ferramentas e técnicas de modelagem para confirmar e documentar o entendimento dos requisitos. Além
disso, o desenvolvimento de protótipos auxilia de modo concreto a possibilidade de avaliar se o caminho
escolhido para o desenvolvimento do sistema está correto através dos comentários dos usuários.
De forma resumida, a metodologia RAD é adequada desde que as seguintes condições sejam
satisfeitas, clique para conhecê-las:
CONDIÇÕES PARA APLICAÇÃO
Disponibilidade de profissionais experientes e comprometidos com um processo de
desenvolvimento intensivo e contínuo.
Comprometimento do cliente para participar efetivamente do desenvolvimento do projeto avaliando
os protótipos e contribuindo com comentários que deem suporte para que os desenvolvedores
javascript:void(0)
/
avancem no desenvolvimento com aperfeiçoamentos e ajustes.
Seu cliente está disposto a seguir cronogramas do projeto e um cronograma para conclusão do
modelo? Todas as partes interessadas precisam estar presentes para aplicar efetivamente essa
metodologia.
É necessário que o sistema possa ser dividido em módulos.
Também é necessário ter à disposição programas e infraestrutura adequada para aplicar a RAD.
Para a aplicação da RAD, o projeto, a estrutura tecnológica da organização e a própria cultura da
empresa precisam estar adequados para que o desenvolvimento do sistema seja bem-sucedido.
A RAD funciona perfeitamente para sistemas que podem ser divididos em módulos. Em especial, esses
são alguns exemplos para os quaisa RAD se encaixa bem:
Sistemas que podem ser modularizados.
Aspectos de interatividade com o usuário UI/UX são muito importantes no projeto.
Ter à disposição profissionais qualificados no uso de ferramentas adequadas ao desenvolvimento
rápido; em especial, no uso de frameworks.
Os clientes entendem a importância da interatividade com os desenvolvedores e têm a expectativa
de receber protótipos ao longo do projeto.
Desde o início do projeto, já é conhecido que haverá mudanças durante o processo de
desenvolvimento.
Essas são algumas situações em que é esperado que a RAD funcionará bem. A RAD é uma
metodologia de desenvolvimento com processos bem definidos, em que a colaboração entre usuários e
desenvolvedores é fundamental para que os projetos tenham sucesso. A fim de que possa ser aplicada,
algumas condições precisam ser satisfeitas. Além de possuir vantagens, a RAD possui desvantagens no
sentido que não é adequada para sistemas complexos e de grande escala.
VÍDEO COM AVALIAÇÃO
Assista no vídeo a abordagem de casos práticos, exemplificando a aplicabilidade ou não da metodologia
RAD.
/
VERIFICANDO O APRENDIZADO
1. A METODOLOGIA DE DESENVOLVIMENTO RÁPIDO DE SOFTWARE (RAD)
SURGIU PARA SUPRIR A NECESSIDADE DE REDUZIR O TEMPO DE ENTREGA
DOS SISTEMAS E A QUANTIDADE DE ERROS. NO ENTANTO, PARA SER USADA,
ELA DEVE SATISFAZER ALGUNS CRITÉRIOS. NESSE SENTIDO, SELECIONE A
OPÇÃO CORRETA SOBRE OS CRITÉRIOS QUE DEVEM SER SATISFEITOS PARA
APLICAR A METODOLOGIA RAD:
A) É adequada para projetos de infraestrutura de larga escala.
B) A complexidade dos projetos não é um fator impeditivo.
C) A RAD não é adequada para projetos de grande escala.
D) Projetos de banco de dados distribuídos satisfazem os critérios para aplicabilidade da metodologia
RAD.
2. A METODOLOGIA RAD POSSUI CARACTERÍSTICAS QUE SÃO
CONSIDERADAS VANTAGENS EM RELAÇÃO AOS MÉTODOS TRADICIONAIS,
COMO, POR EXEMPLO, O MÉTODO CASCATA. NESTE SENTIDO, SELECIONE A
OPÇÃO CORRETA SOBRE AS VANTAGENS DA METODOLOGIA RAD:
A) Necessidade de equipe altamente qualificada.
B) Desenvolver componentes reutilizáveis.
C) Deve haver um esforço inicial da modelagem de dados que não pode ser modificada ao longo do
projeto.
/
D) É adequada para sistemas complexos.
GABARITO
1. A metodologia de desenvolvimento rápido de software (RAD) surgiu para suprir a necessidade
de reduzir o tempo de entrega dos sistemas e a quantidade de erros. No entanto, para ser usada,
ela deve satisfazer alguns critérios. Nesse sentido, selecione a opção CORRETA sobre os
critérios que devem ser satisfeitos para aplicar a metodologia RAD:
A alternativa "C " está correta.
 
A metodologia RAD é adequada para projetos de pequena e média escalas, nos quais as interações
entre desenvolvedores e usuários são viáveis e auxiliam o entendimento e desenvolvimento do sistema.
2. A metodologia RAD possui características que são consideradas vantagens em relação aos
métodos tradicionais, como, por exemplo, o método cascata. Neste sentido, selecione a opção
CORRETA sobre as vantagens da metodologia RAD:
A alternativa "B " está correta.
 
A colaboração entre usuários e desenvolvedores ao longo do projeto é uma característica fundamental
da RAD. O projeto é desenvolvido com interações e incrementos de funcionalidades. A operação dessa
metodologia pode ocorrer em fases, ou de modo intensivo.
MÓDULO 4
 Justificar o Python e as ferramentas (framework) para o desenvolvimento RAD
/
 
Autor: Rawpixel.com / Fonte: Shutterstock
CONTEXTUALIZAÇÃO
Uma das principais características da RAD é o desenvolvimento de protótipos, de modo que
desenvolvedores e usuários possam interagir em um sistema funcional:
 
DESSA FORMA, OS USUÁRIOS PODEM USAR O
SOFTWARE, AINDA QUE TENHA LIMITAÇÕES, E FAZER
COMENTÁRIOS E SUGESTÕES.
 
OS COMENTÁRIOS AUXILIAM OS DESENVOLVEDORES A
TOMAR DECISÕES QUE MAXIMIZEM A SATISFAÇÃO DOS
USUÁRIOS.
/
E COM A VALIDAÇÃO DO PROTÓTIPO, OS
DESENVOLVEDORES MONTAM UM PLANO DE TRABALHO
PARA ATENDER AOS REQUISITOS DEFINIDOS PELOS
USUÁRIOS.
NESSE SENTIDO, FAZER USO DE FERRAMENTAS DE
DESENVOLVIMENTO RÁPIDO É FUNDAMENTAL
PARA QUE HAJA BOA TRADUÇÃO ENTRE IDEIAS E
REPRESENTAÇÕES VISUAIS E FUNCIONAIS.
A utilização de ferramentas que acelerem o desenvolvimento auxilia na redução do tempo de
lançamento no mercado. No ambiente competitivo do mercado de software, trata-se de uma
característica muito importante. Frameworks facilitam a codificação e padronizam o uso de recursos;
desse modo, a “reusabilidade” de componentes é um dos benefícios que são obtidos e que podem
ajudar no desenvolvimento de novos módulos do sistema.
A seguir, serão apresentadas características da linguagem Python, porém já pode ser adiantado que a
sintaxe dela é bem mais simples do que muitas outras linguagens do mercado, como o Java, por
exemplo. Portanto, escolher o Pyhton como linguagem de desenvolvimento de um projeto pode reduzir
consideravelmente o tempo de produção. A ideia é simples: supondo que o número de linhas que um
desenvolvedor pode produzir em determinado intervalo é limitado, escolher uma linguagem de sintaxe
mais simples ajuda a aumentar a produtividade.
/
 
Autor: dencg / Fonte: Shutterstock
QUE OUTRA RAZÃO VOCÊ APRESENTA PARA A
ESCOLHA DA LINGUAGEM PYTHON?
RESPOSTA
PYTHON
javascript:void(0)
/
Python é uma linguagem de programação muito usada para diversos fins. Ela possui muitos pacotes
para diferentes tipos de aplicações, bibliotecas de GUI, além de ser uma linguagem de programação
“enxuta”, no sentido de que sua sintaxe é mais simples do que muitas outras linguagens.
Dadas essas características, entre outras que serão tratadas um pouco mais adiante neste texto, o
Python é uma linguagem adequada para a aplicação da metodologia RAD.
Linguagem
Python
Outro ponto que fortalece a escolha do Python para projetos RAD é que muitos
frameworks são baseados nela com o objetivo de acelerar o desenvolvimento e
garantir desempenho e extensibilidade do código.
É uma linguagem de tipo dinâmico, interpretada e de alto nível. Nela, é possível
desenvolver programas estruturados, orientados a objetos e, até mesmo, aplicar
conceitos de linguagens funcionais. Possui uma sintaxe que a diferencia de
outras linguagens de programação, como Java, C ++ e Java Script.
Para fazer o desenvolvimento de um sistema em Pyhton, é necessário utilizar
um ambiente de desenvolvimento, e um dos mais usados é o Spyder (Spyder,
2020), mas existem muitos outros.
 Atenção! Para visualização completa da tabela utilize a rolagem horizontal
 SAIBA MAIS
A instalação dos pacotes no Pyhton também é bem simples, de modo geral. Normalmente, basta digitar:
“pip install nome-do-pacote”. Em algumas situações, pode-se ter um pouco mais de trabalho por causa
da compatibilidade de versões. Essa questão de configurações de versões, inclusive, é um problema
que abrange os projetos de desenvolvimento de modo geral e, sem o apoio de uma equipe focada em
questões que incluam esse tipo de problema, perde-se bastante tempo no projeto.
ENTRE OS MOTIVOS PARA ESCOLHER O PYTHON EM
PROJETOS RAD, ESTÃO:
PORTABILIDADE
/
LICENÇA DE CÓDIGO ABERTO
INTEGRAÇÃO COM OUTROS SISTEMAS
DESENVOLVIMENTO RÁPIDO
OTIMIZAÇÃO DE DESEMPENHO
LINGUAGEM INTERPRETADA
PORTABILIDADE
Pode-se trabalhar com Python em diversos sistemas operacionais.
LICENÇA DE CÓDIGO ABERTO
As distribuições do Python são gratuitas e de código aberto sem restrições do uso da licença.
INTEGRAÇÃO COM OUTROS SISTEMAS
Já existem muitos pacotes desenvolvidos para Python que abrangem aplicações de bancos de dados,
Web, interfaces gráficas, ciências de dados, entre muitos outros.
DESENVOLVIMENTO RÁPIDO
Por possuir uma sintaxe mais simples do que muitas outras linguagens de programação e, além disso,
ter diversos pacotes e frameworks, o Python é uma linguagem muito apropriada para projetos RAD, em
que a velocidade do desenvolvimento é considerada um fator fundamental.
OTIMIZAÇÃO DE DESEMPENHO
O Python possui tratamentos específicospara manipulação de listas e de dados de grande porte que
otimizam o desempenho do sistema, inclusive para aplicações de big data.
/
LINGUAGEM INTERPRETADA
Torna mais simples fazer o uso interativo com o programa. No caso de desenvolvimento de protótipos,
trata-se de uma característica prática.
Outra vantagem de usar o Python é que a comunidade de usuários é ampla, formada por pessoas com
bastante conhecimento e prestativas. Uma das grandes preocupações de qualquer projeto é sobre o
suporte que será fornecido ao longo do desenvolvimento; no caso do Python, a comunidade é ativa, ou
seja, as pessoas realmente se esforçam para responder a perguntas de diversos níveis de
conhecimento. O nível de suporte técnico disponível, gratuitamente, é considerável.
 SAIBA MAIS
Para obter mais detalhes sobre a linguagem Python, sugere-se visitar sua página eletrônica (Python
3.8.5 documentation, 2020).
FERRAMENTAS (FRAMEWORK) PARA O
DESENVOLVIMENTO RAD
A linguagem Python em si – com seus diversos pacotes disponíveis para instalação gratuita – é uma
escolha muito apropriada para desenvolver projetos RAD, mas, além disso, também possui diversos
frameworks que auxiliam no ganho de velocidade do tempo de entrega, além de padronizar o
desenvolvimento dos sistemas. Com uma interface gráfica obtida rapidamente, o usuário pode interagir
com o desenvolvedor com mais qualidade, ou seja, facilita a comunicação entre as partes interessadas,
além de manter a motivação no projeto.
OBSERVE ABAIXO OS TIPOS DE FRAMEWORKS
SUPORTADOS PELO PYTHON.
FRAMEWORKS (PYTHON)
/
1
FULL-STACK:
Fornecem uma solução completa de todos os requisitos para o desenvolvedor, desde a geração e
validação de formulários até a disponibilização de modelos layouts.
MICROFRAMEWORK:
São frameworks que oferecem uma quantidade mínima de serviços. Normalmente, são usados para o
recebimento de solicitações, roteamento, despacho e o retorno de uma resposta HTTP.
2
3
FRAMEWORK ASSÍNCRONOS:
Trata-se de um tipo de microframework que permite lidar com grande conjunto de conexões simultâneas.
A estrutura assíncrona é usada para gerenciar operações de longa duração, como transformações de
dados.
Ao longo dos últimos anos, o Python tem atraído mais desenvolvedores devido à facilidade de
aprendizado e diversidade de aplicações que abrange. A combinação de Python e RAD permite
desenvolver rapidamente protótipos que abrangem diversos tipos de aplicações, além do fato de que a
/
aplicação poderá operar em múltiplas plataformas. A seguir, serão tratados alguns exemplos de
frameworks em Python para desenvolvimento de GUIs e de aplicações para Web.
FRAMEWORKS GUI PARA PYTHON
A Interface Gráfica do Usuário (GUI) é um aspecto essencial para que possa haver interação com o
sistema; portanto, o desenvolvimento de recursos interativos, ainda nos protótipos, possibilita que o
usuário tenha uma percepção mais clara de como o projeto está progredindo. Existem diversos
frameworks para Python que tratam desses tipos de recursos, tais como botões, ícones, campos de
texto, gráficos, e assim por diante.
 
Autor: mrmohock / Fonte: Shutterstock
CLIQUE E VEJA A SEGUIR, ALGUNS FRAMEWORKS GUI
PARA PYTHON:
TKINTER
PYQT
PYSIDE
KIVY
/
WXPYTHON
TKINTER
É uma biblioteca que já está embutida na instalação padrão do Python que permite desenvolver
interfaces gráficas (TCL DEVELOPER XCHANGE, 2020).
PYQT
É uma biblioteca de componentes gráficos do Python. Ela não é instalada com o Python, além disso tem
diferentes tipos de licença (PYQT, 2020).
PYSIDE
É um software livre que executa nos sistemas operacionais Windows, Mac e Linux (PYSIDE, 2020).
KIVY
É um framework de código aberto, em que é possível desenvolver aplicativos “multi-touch” para
dispositivos móveis e computadores (KIVY, 2020).
WXPYTHON
É um kit de ferramentas de código aberto que possui suporte para as plataformas Windows de 32 bits,
Unix e Mac OS X (WXPYTHON).
Cada um desses frameworks possui particularidades que podem torná-los mais adequados para
determinados projetos. Em especial, o framework Tkinter é o framework GUI mais usado do Python.
TKINTER
O framework GUI mais usado do Python, possui componentes que podem ser organizados para facilitar
a interatividade com os usuários. O Tkinter possui três classes para gerenciar a organização dos
/
componentes. São elas:
Método pack (): organiza os componentes em blocos antes de posicioná-los no componente pai.
Método grid (): faz a configuração dos componentes em forma de tabela.
Método place (): o posicionamento do componente é feito em um local específico.
Um dos motivos para o Tkinter ser muito usado é que ele já faz parte da biblioteca padrão do Python e é
utilizado pelo framework Web Django – que é o framework Web mais usado – para fazer páginas Web.
Portanto, não há necessidade de instalá-lo, e, por ser usado pelo Django, torna mais fácil encontrar
documentação e exemplos de como usá-lo. Entre os principais componentes do Tkinter, estão:
Button: trata-se de um componente botão. Para adicioná-lo no sistema, basta escrever
w=Button(master,option=value).
Canvas: é usado para aplicar design e layouts complexos. Para adicioná-lo no sistema, basta
escrever w=Canvas(master, option=value).
CheckButton: é aplicado para selecionar uma opção. Para adicioná-lo no sistema, basta escrever
w=CheckButton(master, option=value).
Entry: usado para entrar texto. Para adicioná-lo no sistema, basta escrever w=Entry(master,
option=value).
Frame: é usado para agrupar e organizar componentes. Para adicioná-lo no sistema, basta
escrever w=Frame(master, option=value).
Label: exibe uma caixa onde se pode inserir texto. Para adicioná-lo no sistema, basta escrever
w=Label(Master, option=value).
MenuButton: é usado para criar “menus de topo”. Para adicioná-lo no sistema, basta escrever
w=MenuButton(Master, option=value).
Menu: cria menu. Para adicioná-lo no sistema, basta escrever w=Menu(master, option=value).
Message: usado para exibir múltiplas linhas sem texto editável. Para adicioná-lo no sistema, basta
escrever w=Message(master, option=value).
/
Scale: é um componente deslizante que permite selecionar valores de uma escala específica. Para
adicioná-lo no sistema, basta escrever w=Scale(master, option=value).
Todos esses componentes estão disponíveis no Tkinter.
 RECOMENDAÇÃO
Demais frameworks também possuem diversos recursos, portanto a escolha de um framework é uma
decisão que deve ser feita no início do projeto.
FRAMEWORKS WEB PARA PYTHON
Um framework Web é um conjunto de pacotes que habilitam os desenvolvedores a desenvolver
aplicações para Web, ou serviços, sem ter de implementar excesso de detalhes, como protocolos,
soquetes ou gerenciamento de processos/threads. A maioria dos frameworks para Web focam no
desenvolvimento de aplicações do lado do servidor. A responsabilidade pelas comunicações e pela
infraestrutura ficam sob a responsabilidade do framework, permitindo que o desenvolvedor possa se
concentrar na lógica do sistema.
 
Autor: Rawpixel.com / Fonte: Shutterstock
/
Os frameworks dão suporte para diversas atividades, como interpretar solicitações – obtenção de
parâmetros de formulário, gerenciamento de cookies e de sessões –, produzir respostas (apresentação
de dados, como o formato JSon, por exemplo) e fazer armazenamento persistente de dados. É
característico de aplicações Web que haja vários tipos diferentes de camadas de programação,
geralmente empilhadas umas sobre as outras. Nesse sentido, os frameworks facilitam o rápido
desenvolvimento de protótipos.
De modo geral, um framework Web é formado por um conjunto de bibliotecas e um arquivo principal,
onde é feita, de fato, a programação. A maioria dos frameworks para aplicações Web incluem padrões
que devem ter:
ROTEAMENTO 
DE URL
OBJETOS DE 
SOLICITAÇÃO E RESPOSTA
TEMPLATE 
ENGINE
SERVIDOR WEB DE 
DESENVOLVIMENTO
ROTEAMENTO DE URL
Trata de solicitações HTTP recebidas por parte específica do código Python.OBJETOS DE SOLICITAÇÃO E RESPOSTA
Agrupa as informações recebidas, ou enviadas, para o navegador de um usuário.
TEMPLATE ENGINE
São normalmente usados como um formato intermediário escrito por desenvolvedores para produzir um
ou mais formatos de saída, normalmente, HTML, XML ou PDF.
/
SERVIDOR WEB DE DESENVOLVIMENTO
Executa um servidor HTTP em máquinas de desenvolvimento. Quando os arquivos são atualizados,
recarrega automaticamente o código do lado do servidor.
SAIBA MAIS
Existem frameworks Web para Python diversos. Dentre eles, estão:
Django: é um framework de código aberto que é muito bem-sucedido para criar sites complexos
baseados em dados. Possui modelos, bibliotecas e APIs que dão suporte na criação de projetos
de desenvolvimento da Web escaláveis (Django, 2020).
TurboGears: é um framework que usa a arquitetura MVC (Model View Control), que ajuda no
rápido desenvolvimento de aplicações Web (Turbogears, 2020).
Flask: é um framework que suporta o envio de solicitações REST (Flask, 2020).
Bottle: é um framework distribuído como um módulo de arquivo único, sem dependências além da
biblioteca padrão do Python. Suporta o envio de solicitações com suporte a URL, bancos de dados
de chave/valor e modelos e um servidor HTTP interno (Bottle, 2020).
CherryPy: é um framework que fornece as funcionalidades CRUD (Criar, Recuperar, Atualizar e
Excluir) (CherryPy, 2020).
Falcon: é um framework para o desenvolvimento de programas de pequena escala; usa a
arquitetura REST e tem disponível vários pacotes complementares para facilitar o
desenvolvimento.
O Python possui muitos outros pacotes que servem para operações numéricas, manipulações de listas e
impressão de gráficos que são usados, por exemplo, em aplicações de Ciências de Dados, como:
Numpy: com funções para operações matemáticas e lógicas em matrizes (NumPy, 2020).
Pandas: aplicada, especialmente, na análise de dados (Pandas, 2020).
Matplotlib: é uma biblioteca de plotagem que auxilia na criação de gráficos e plotagens 2D, que
incluem gráficos de barras, histogramas e muitos outros usando scripts Python.
A abrangência do Python é extensa com frameworks e bibliotecas que podem ser usadas para diversos
tipos de aplicações.
/
A linguagem Python tem características que a tornam uma escolha adequada para aplicação em
projetos RAD. Além de ter uma biblioteca e pacotes que cobrem diversos tipos de aplicações, também
possui frameworks que são bem documentados e que facilitam a criação de protótipos.
VÍDEO COM AVALIAÇÃO
O vídeo apresenta frameworks em Python e como utilizá-los no desenvolvimento de sistemas
empregando a metodologia RAD.
VERIFICANDO O APRENDIZADO
1. A METODOLOGIA RAD TEM POR OBJETIVO O DESENVOLVIMENTO RÁPIDO
DE SOFTWARE. SELECIONE A OPÇÃO CORRETA QUE JUSTIFICA A ESCOLHA
DO PYTHON PARA PROJETOS RAD:
A) Suporta os conceitos de orientação a objetos e, como se sabe, é o paradigma de programação mais
adequado para desenvolvimento rápido de aplicações.
B) A capacidade de integrar-se com linguagens muito eficientes, como C, garante a velocidade do
desenvolvimento.
C) Possui uma sintaxe enxuta com pacotes e frameworks que padronizam o desenvolvimento.
D) Sua integração com pacotes de segurança aumentam a proteção do sistema.
/
2. A ESCOLHA DE UM FRAMEWORK PARA UM PROJETO RAD DEVE LEVAR EM
CONSIDERAÇÃO DIVERSAS CARACTERÍSTICAS. A MAIS IMPORTANTE DELAS
É A CAPACIDADE DE ENTREGAR PROTÓTIPOS AO FINAL DE CADA ITERAÇÃO.
NESSE SENTIDO, SELECIONE A OPÇÃO CORRETA QUE JUSTIFICA A ESCOLHA
DE DETERMINADO FRAMEWORK PARA UM PROJETO RAD:
A) As funções que são disponibilizadas por suas bibliotecas, a documentação disponível e a linguagem
de programação que é utilizada.
B) O uso das linguagens de programação mais modernas por serem tecnologicamente mais avançadas.
C) O tipo de licenciamento do framework e de suas bibliotecas e seus pacotes.
D) Possui componentes GUIs mais agradáveis para o usuário, estimulando, assim, a motivação e
colaboração no projeto.
GABARITO
1. A metodologia RAD tem por objetivo o desenvolvimento rápido de software. Selecione a opção
CORRETA que justifica a escolha do Python para projetos RAD:
A alternativa "C " está correta.
 
A linguagem Python possui uma sintaxe mais simples do que muitas outras linguagens de programação;
além disso, dispõe de bibliotecas e frameworks que são bem documentados e facilitam o
desenvolvimento.
2. A escolha de um framework para um projeto RAD deve levar em consideração diversas
características. A mais importante delas é a capacidade de entregar protótipos ao final de cada
iteração. Nesse sentido, selecione a opção CORRETA que justifica a escolha de determinado
framework para um projeto RAD:
A alternativa "A " está correta.
 
Existem muitos frameworks disponíveis no mercado, e cada um tem características que os tornam mais
adequados para um projeto RAD. A documentação certamente é fundamental para a escolha com
exemplos de como usar o framework. Além disso, ter uma linguagem de programação com uma sintaxe
mais simples facilita o desenvolvimento rápido de aplicações.
/
CONCLUSÃO
 
Autor: puhhha / Fonte: Shutterstock
CONSIDERAÇÕES FINAIS
Ao longo do texto, foram apresentados os conceitos da metodologia RAD, suas fases, vantagens e
desvantagens e ferramentas – mais especificamente, frameworks – para o desenvolvimento rápido de
software.
Como foi apresentado no tema, a RAD precisa que alguns requisitos sejam atendidos para que ela
possa ser aplicada de maneira eficaz. O mais importante desses requisitos é a colaboração intensa do
usuário, a fim de avaliar a qualidade do desenvolvimento do projeto através de comentários para os
desenvolvedores.
Além disso, a linguagem Python foi descrita como uma escolha adequada para o desenvolvimento de
projetos RAD, além de diversos frameworks que abrangem desde o desenvolvimento de interface
gráfica com o usuário, aplicações Web, até aplicações específicas para Ciências de Dados.
/
REFERÊNCIAS
BERGER, H.; BEYNON-DAVIES, P.: The utility of rapid application development in large-scale,
complex projects. Information Systems Journal, 2009. 19 (6), 549– 570.
bottlepy. Consultado em meio eletrônico em: 4 ago. 2020.
cherrypy. Consultado em meio eletrônico em: 4 ago. 2020.
Django. Consultado em meio eletrônico em: 4 ago. 2020.
flask. Consultado em meio eletrônico em: 4 ago. 2020.
Fitzgerald, B. A Preliminary Investigation of Rapid Application Development in Practice,
Proceedings of 6th International Conference on Information Systems Methodologies, editors
Wood-Harper AT, Jayarantna N., Wood J R G, pp. 77–87, 1998.
Kerr, J.; Hunter, R. Inside RAD: How to Build Fully Functional Computer Systems in 90 Days or Less.
New York: McGraw-Hill, 1994.
Kivy. Consultado em meio eletrônico em: 4 ago. 2020.
Martin, J. Rapid Application Development, Macmillan, USA, 1991.
matplotlib. Consultado em meio eletrônico em: 4 ago. 2020.
NAZ, R.; KHAN, M. N. A. Rapid applications development techniques: A critical review, Int. J. Softw.
Eng. its Appl., vol. 9, nº. 11, pp. 163–176, 2015.
NumPy. Consultado em meio eletrônico em: 4 ago. 2020.
Pandas. Consultado em meio eletrônico em: 4 ago. 2020.
PyQt. Consultado em meio eletrônico em: 4 ago. 2020.
PySide. Consultado em meio eletrônico em: 4 ago. 2020.
Python 3.8.5 documentation. Consultado em meio eletrônico em: 4 ago. 2020.
Spyder. Consultado em meio eletrônico em: 4 ago. 2020.
Tcl Developer Xchange. Consultado em meio eletrônico em: 4 ago. 2020.
The Falcon Web Framework. Consultado em meio eletrônico em: 4 ago. 2020.
turbogears. Consultado em meio eletrônico em: 4 ago. 2020.
wxPython. Consultado em meio eletrônico em: 4 ago. 2020.
/
EXPLORE+
Acesse o site oficial do Python para ler sobre conceitos da linguagem e de aplicações GUI, além de
poder fazer downloads de diversos pacotes para desenvolvimento rápido.
Acesse o site oficial da IEEE e procure artigos que tratam do desenvolvimento rápido de software
aplicado para Web e Internet dasCoisas.
CONTEUDISTA
Sérgio Assunção Monteiro
 CURRÍCULO LATTES
javascript:void(0);
/
DEFINIÇÃO
Formas de armazenamento e recuperação de dados em arquivos e diretórios, utilizando a linguagem de
programação Python.
PROPÓSITO
Compreender os passos necessários para manipulação de arquivos e strings, utilizando boas práticas e
tratamento de exceção, para garantir o correto funcionamento do programa.
 RECOMENDAÇÃO
Antes de iniciar o conteúdo deste tema, sugerimos que tenha o software Python 3.7 instalado em seu
computador. Ele será utilizado nos módulos deste tema.
Você pode pesquisar e baixar o Python 3.7 no site oficial do Python.
Para programar os exemplos apresentados neste módulo, utilizamos a IDE Pycharm Community. Você
pode baixar essa IDE gratuitamente no site oficial da JetBrains.
/
Baixe os  CÓDIGOS FONTE PYTHON, deste tema, para lhe auxiliar na realização
das atividades.
OBJETIVOS
MÓDULO 1
Identificar as funções de manipulação de arquivos
MÓDULO 2
Reconhecer as funções de manipulação de strings
MÓDULO 3
Descrever as exceções na manipulação de arquivos e outras operações
INTRODUÇÃO
Uma das razões pela qual o Python se popularizou foi a facilidade de programar utilizando essa
linguagem.
A manipulação de arquivos em Python não é diferente. Os criadores se preocuparam em disponibilizar
aos desenvolvedores o que realmente importa!
Com nome de métodos intuitivos, como read (Ler) (ler) e write (Escrever) (escrever), e tratamentos
de exceções específica para cada problema, o Python disponibiliza uma simples e poderosa forma de
trabalhar com arquivos.
Neste tema, veremos como manipulá-los de forma correta, garantido que o programa rode sem
problemas.
javascript:void(0);
/
 
Autor: Trismegist san / Fonte: Shutterstock
É muito comum ajustarmos e prepararmos um texto antes de incluí-lo em um arquivo. Ajustes como
remover espaço em branco, colocar todas as letras maiúsculas, substituir palavras e adicionar conteúdo
de variável são alguns exemplos.
Esses ajustes podem ser realizados a partir de métodos de manipulação de strings, que também serão
tratados neste tema.
MÓDULO 1
 Identificar as funções de manipulação de arquivos
 
Autor: Wright Studio / Fonte: Shutterstock
/
CONCEITOS
ABRINDO UM ARQUIVO
Neste módulo, veremos as operações básicas de manipulação de arquivos:
Abrir.
Fechar.
Ler.
Escrever.
A primeira operação que precisamos realizar, independentemente se vamos ler o conteúdo de um
arquivo ou adicionar um conteúdo, é abrir o arquivo.
Para abrir um arquivo, o Python disponibiliza a função interna chamada open. Essa função está
disponível globalmente, ou seja, não é preciso importá-la.
A função open retorna um objeto do tipo arquivo. Sua forma mais simples de utilização tem a seguinte
sintaxe:
ARQUIVO = OPEN (CAMINHO)
 
 
Utilizamos a função open com o parâmetro caminho. Esse parâmetro é uma string que representa a
localização do arquivo no sistema de arquivos.
No exemplo a seguir, vemos como é fácil abrir um arquivo.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Script inicial e sua saída.
 
Autor: Autor / Fonte: Autoria própria (2020).
À esquerda da imagem, temos a árvore de diretório, onde podemos verificar a existência dos arquivos
script_inicial.py e teste.txt, ambos no mesmo diretório EAD.
 
Autor: Autor / Fonte: Autoria própria (2020).
Ao centro, temos o código do nosso script e, à direita, a saída do console.
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 1 do script, utilizamos a função open para abrir o arquivo teste.txt. Isso já é suficiente para
termos um objeto do tipo arquivo e começar a manipulá-lo.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 3, imprimimos a frase “Arquivo aberto com sucesso!” apenas para verificar se o programa foi
executado sem problemas.
Nesse exemplo, o caminho utilizado para abrir o arquivo foi “teste.txt”, pois o script e o arquivo que
abrimos estão no mesmo diretório.
Porém, não precisamos nos limitar a manter os arquivos e scripts no mesmo diretório.
Veja como o Python trata o acesso aos arquivos a seguir.
O caminho de um arquivo pode ser classificado em dois tipos:
ABSOLUTO
CAMINHO ABSOLUTO
Caminho absoluto é a referência completa para se encontrar um arquivo ou diretório. Ele deve começar
com uma barra ( / ) ou o rótulo do drive ( C:, D: ...).
Exemplo:
open(“C:\Downloads\arquivo.txt”) – utilizado em ambientes MS Windows.
open(“/home/usuario/arquivo.txt”) – utilizado em ambientes Linux.
RELATIVO
CAMINHO RELATIVO
Caminho relativo é a referência para se encontrar um arquivo ou diretório a partir de outro diretório.
Normalmente, a partir do diretório de onde o script está.
Exemplo:
/
open(“arquivo.txt”), para os casos em que o arquivo está no mesmo diretório do script.
open(“../arquivo.txt”), para os casos em que o arquivo está no diretório acima do script.
A seguir, vamos criar um script que ilustra as diferentes formas de referenciar um arquivo com caminhos
absolutos e relativos.
Neste exemplo, alteramos um pouco a forma de exibir o conteúdo.
 
Autor: Autor / Fonte: Autoria própria (2020).
Script1, sua saída e arquivo dados1.txt.
 
Autor: Autor / Fonte: Autoria própria (2020).
À esquerda, temos nossa árvore de diretórios.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Ao centro, o script1.py.
 
Autor: Autor / Fonte: Autoria própria (2020).
À direita, o arquivo dados.txt, e, abaixo, a saída do console do Python. Na linha 1 do script1.py,
importamos o módulo os do Python.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 4, utilizamos a função open para abrir o arquivo “dados1.txt”, que se encontra no mesmo
diretório do nosso script. Nessa linha, utilizamos o caminho relativo. Observe que, como o arquivo
dados1.txt está na mesma pasta EAD que o script1.py, basta escrever o nome do arquivo como
argumento.
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 5, vamos abrir o mesmo arquivo dados1.txt, utilizando o caminho absoluto (completo), que, no
nosso exemplo, é: "C:/EAD/dados1.txt".
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Nas linhas 8 e 9, vamos abrir o arquivo dados2.txt, que se encontra na pasta documentos. Na linha 8,
utilizamos o caminho relativo desse arquivo para abri-lo: "documentos/dados2.txt", enquanto, na linha 9,
utilizamos o caminho absoluto: "C:/EAD/documentos/dados2.txt".
O Python também disponibiliza algumas funções para exibir os caminhos absolutos e relativos de um
arquivo ou diretório.
Na linha 11, utilizamos a função path.relpath para imprimir o caminho relativo do arquivo1, a partir
do nome do arquivo passado como parâmetro.
Na linha 12, utilizamos a função path.abspath para exibir o caminho absoluto do mesmo arquivo.
Observe que, mesmo utilizando o caminho relativo para abrir o arquivo (linha 4), é possível obter o
caminho absoluto utilizando a função abspath. Isso pode ser verificado na saída do console.
Na linha 14, utilizamos a função interna print para imprimir a variável arquivo1. Verifique, na saída
do console, onde foi impressa a representação do objeto arquivo1:
<_IO.TEXTIOWRAPPER NAME='DADOS1.TXT' MODE='R'
ENCODING='CP1252'>
 
Neste módulo, vamos tratar apenas de arquivos do tipo texto, ou seja, objetos TextIOWrapper. A seguir,
vamos apresentar os diferentes modos de acesso aos arquivos.
javascript:void(0)
/
<_IO.TEXTIOWRAPPER NAME='DADOS1.TXT'
MODE='R' ENCODING='CP1252'>
Desmembrando essa saída, temos: o tipo do objeto, TextIOWrapper, que trata de arquivos de
texto; o nome do arquivo, name='dados.txt'; o modo de acesso ao arquivo, mode='r'; e a
codificação do arquivo, encoding='cp1252'.]
MODOS DE ACESSO A UM ARQUIVO
Quando abrimos um arquivo, precisamos informar ao Python o que desejamos fazer, ou seja, qual será
o modo (mode) de acesso ao arquivo. O modo é um dos parâmetros da função open, e cada modo é
representado por uma string.
Os principais modos são:
R: LEITURA (READ)
 
W:ESCRITA (WRITE)
 
A: ACRESCENTAR (APPEND)
 
O modo padrão da função open é o modo leitura (“r”).
Esses modos podem ser combinados. Para informar que desejamos ler e escrever em um arquivo,
utilizamos a string “r+”, por exemplo.
O Python também nos permite diferenciar arquivos texto de arquivos binários, como uma imagem, por
exemplo. Para informar que desejamos abrir um arquivo binário, adicionamos a string “b” ao modo,
/
ficando “rb”, “wb” e “ab”.
A tabela a seguir resume os modos de acesso a arquivos.
Caractere Significado
'r' Abre o arquivo para leitura (default).
'w' Abre o arquivo para escrita, truncando o arquivo primeiro.
'x' Cria um arquivo para escrita e falha, caso ele exista.
'a' Abre o arquivo para escrita, acrescentando conteúdo ao final do arquivo, caso ele exista.
'b' Modo binário.
't' Modo texto (default).
'+' Abre o arquivo para atualização (leitura ou escrita).
 Modos de abertura de arquivos em Python. Fonte: Adaptado de Python (2020).
 Atenção! Para visualização completa da tabela utilize a rolagem horizontal
ATRIBUTOS DE UM ARQUIVO
O objeto do tipo arquivo contém alguns atributos importantes, como name, mode e closed, expostos no
script a seguir.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Script2, sua saída e arquivo dados.txt.
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 1, abrimos o arquivo utilizando a função open. Como não explicitamos o parâmetro mode, o
arquivo será aberto no modo leitura (“r”).
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 3, imprimimos o atributo name do objeto arquivo. Esse atributo contém o nome do arquivo.
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 4, imprimimos o atributo mode do objeto arquivo. Esse atributo contém o modo de acesso do
arquivo (r, w, a, rb ...).
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 5, imprimimos o atributo closed do objeto arquivo. Essa atributo serve para verificar se um
arquivo está ou não fechado.
Os valores de cada atributo podem ser verificados no console abaixo da imagem.
FECHANDO UM ARQUIVO
Após realizar a operação desejada no arquivo, precisamos liberá-lo. Para isso, utilizamos o método
close(), que libera a memória alocada pelo interpretador e o uso do arquivo por outros programas, por
exemplo.
A seguir, vamos utilizar o script do exemplo anterior como base e adicionar uma chamada ao método
close() e verificar o atributo closed novamente.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
 Script3, sua saída e seu arquivo dados.txt.
Em relação ao script do exemplo anterior, adicionamos, na linha 7, uma chamada ao método close() do
objeto arquivo.
Na linha 9, imprimimos novamente a propriedade closed, onde podemos observar que seu valor agora é
True.
LENDO O CONTEÚDO DE UM ARQUIVO
Agora que já sabemos abrir e fechar um arquivo, vamos ver as formas de ler seu conteúdo.
O Python disponibiliza três métodos para leitura do conteúdo de um arquivo-texto:
READ()
READLINE()
READLINES()
READ()
Retorna todo o conteúdo de um arquivo como uma única string.
/
READLINE()
Retorna uma linha de um arquivo, incluindo os caracteres de final de linha (\n ou \r\n), e avança o cursor
para a próxima linha.
READLINES()
Retorna uma lista onde cada item da lista é uma linha do arquivo.
Na imagem a seguir, Figura 5, temos três scripts, em que cada um utiliza um dos métodos descritos
anteriormente para leitura do arquivo.
TRÊS SCRIPTS
Em cada um dos scripts, vamos abrir o mesmo arquivo dados.txt dos exemplos anteriores, ler o
conteúdo, verificar o tipo de conteúdo retornado por cada método de leitura e imprimir o valor
canônico (real) do conteúdo lido.
Observe que explicitamos o modo de operação como leitura (“r”).
 
Autor: Autor / Fonte: Autoria própria (2020).
Scripts 4, 5 e 6 e suas respectivas saídas.
javascript:void(0)
/
 
Autor: Autor / Fonte: Autoria própria (2020).
No script4.py, mais à esquerda, abrimos o arquivo na linha 1 e, na linha 3, utilizamos o método read()
do objeto arquivo para ler o conteúdo de dados.txt e armazená-lo na variável conteudo.
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 5, verificamos o tipo do conteúdo retornado pelo método read(), utilizando a função interna
type. Conforme exibido no console, a variável conteudo é um objeto do tipo str (string).
 
Autor: Autor / Fonte: Autoria própria (2020).
/
Na linha 8, imprimimos o conteúdo em si, porém utilizamos a função interna repr para mostrar o
conteúdo real contido da variável conteudo. Observe que foi retornado todo o texto existente no arquivo
dados.txt, que também pode ser verificado no console.
No script5.py, seguimos os mesmos passos do script anterior, porém, na linha 3, utilizamos o
método readline().
Na linha 5, verificamos que o tipo do conteúdo retornado pelo método readline() também é um
objeto do tipo str (string).
Na linha 8, imprimimos a representação do conteúdo que contém apenas a primeira linha do
arquivo dados.txt (incluindo o caractere de final de linha \n). Isso aconteceu porque, quando
abrimos o arquivo utilizando o modo leitura (‘r’), o cursor interno de leitura fica posicionado no
início do arquivo.
Se chamarmos novamente o método readline(), linha 10, será retornado à próxima linha do
arquivo, que foi impressa na linha 13. Confira a saída do script 5 no console abaixo dele.
 
Fonte: Autor/Shutterstock
/
 
Fonte: Autor/Shutterstock
No script6.py, seguimos novamente os mesmos passos, mas, desta vez, utilizamos o método
readlines().
Na linha 5, verificamos que o tipo do conteúdo retornado pelo método readlines() é um objeto do
tipo list (lista).
Na linha 8, imprimimos o conteúdo retornado, que é uma lista onde cada item da lista é uma
linha do arquivo. Veja a saída desse script no console abaixo dele.
Além dos três métodos apresentados anteriormente, os objetos do tipo arquivo são iteráveis. Com isso,
podemos utilizar o laço for diretamente sobre os objetos desse tipo.
No exemplo ao lado, vamos mostrar como iterar diretamente sobre um arquivo.
Na linha 1, abrimos o arquivo da mesma maneira que fizemos nos exemplos anteriores.
Na linha 4, utilizamos o laço for para iterar diretamente sobre a variável arquivo. Para cada
iteração, recebemos uma nova linha do arquivo, disponibilizada na variável linha, impressa na
linha 5. Observe a saída do console abaixo da figura.
/
 
Fonte: Autor/Shutterstock
 Script7 e sua saída. Fonte: Autoria própria (2020).
 DICA
1 - Quando precisamos abrir um arquivo muito grande, é inviável utilizar os métodos read e readlines,
pois eles retornam todo o conteúdo do arquivo de uma só vez, seja na forma de string, seja na forma de
lista. Isso pode consumir todos os recursos do computador, travando seu programa.
Nesses casos, precisamos chamar o método readline inúmeras vezes até o final do arquivo ou iterar
diretamente sobre o objeto do tipo arquivo.
2 - Após utilizar qualquer um dos métodos para leitura do arquivo apresentados anteriormente, não
podemos utilizá-los novamente. Isso acontece porque o cursor estará posicionado ao final do arquivo, e
as chamadas aos métodos read, readline ou readlines retornarão vazias.
PARA SITUAÇÕES EM QUE PRECISAMOS LER O
CONTEÚDO DE UM ARQUIVO MAIS DE UMA VEZ,
TEMOS DUAS OPÇÕES. NA SUA OPINIÃO, QUAIS
SÃO ELAS?
/
RESPOSTA
Fechar e abrir novamente o arquivo.
Utilizar o método seek(n), passando como argumento o número da linha onde desejamos posicionar o
cursor. A chamada seek(0) retorna o cursor para o início do arquivo.
Depois de conhecer a resposta correta, confira, a seguir, o exemplo do script8, onde exploramos
na prática essa situação.
 
Autor: Autor / Fonte: Autoria própria (2020).
 Script8 e sua saída.
NA LINHA 1
javascript:void(0)
javascript:void(0)
/
Abrimos o arquivo em modo leitura.
NA LINHA 3
Lemos todo seu conteúdo utilizando o método read, que é impresso na linha 5. Veja no console à direita
da imagem.
NA LINHA 7
Utilizamoso método read para ler novamente o conteúdo do arquivo e atribuímos o valor retornado à
variável conteudo_releitura. Na linha 9, imprimimos o conteúdo dessa variável, que, conforme exibido no
console, é uma string vazia ('').
Para contornar esse problema, fechamos e abrimos o arquivo novamente, linhas 11 e 14,
respectivamente. Na linha 16, utilizamos novamente o método read e imprimimos o conteúdo retornado
na linha 18. Observe que, mais uma vez, conseguimos acessar todo o conteúdo do arquivo.
Para demonstrar a utilização do método seek, no mesmo arquivo que já estava aberto,
arquivo_reaberto, utilizamos o método seek(0), linha 20. Imprimimos mais uma vez o conteúdo correto
do arquivo na linha 23.
Toda a sequência pode ser acompanhada pelo console.
Todos os três métodos apresentados anteriormente aceitam como parâmetro a quantidade de bytes que
desejamos ler.
O valor padrão para esse parâmetro é -1, o que corresponde a todo o arquivo.
ESCREVENDO CONTEÚDO EM UM ARQUIVO
Nesta seção, vamos mostrar como, a partir da função open, escrever conteúdo em um arquivo.
A primeira modificação é alterar o modo de acesso ao arquivo. Para escrita de texto, podemos utilizar o
modo w (write) ou o modo a (append):
O modo w abre o arquivo para escrita, truncando o arquivo em primeiro lugar. Caso ele não exista,
será criado um.
O modo a abre o arquivo para escrita, acrescentando conteúdo ao final dele, caso ele exista. Caso
contrário, será criado um arquivo.
javascript:void(0)
javascript:void(0)
/
O Python disponibiliza dois métodos para escrita de conteúdo em um arquivo texto, para o modo w e
para o modo a. Os métodos write e writelines são descritos a seguir:
WRITE (TEXTO)
Escreve todo o conteúdo passado como parâmetro no arquivo.
WRITELINES (ITERÁVEL)
Escreve cada item do iterável (exemplo: lista) no arquivo.
No exemplo a seguir, vamos criar dois scripts para mostrar o uso do modo w. No primeiro, script9,
vamos utilizar o método write. No segundo, script10, vamos utilizar o método writelines.
 
Autor: Autor / Fonte: Autoria própria (2020).
Script 9 e 10 e suas respectivas saída.
 
Autor: Autor / Fonte: Autoria própria (2020).
javascript:void(0)
javascript:void(0)
/
No script9, abrimos o arquivo dados_write.txt para escrita utilizando o modo w na linha 1.
 
Autor: Autor / Fonte: Autoria própria (2020).
Escrevemos os conteúdos utilizando o método write, conforme linhas 2 e 3, e fechamos o arquivo, como
exposto na linha 4.
 
Autor: Autor / Fonte: Autoria própria (2020).
Observe como ficou o arquivo dados_write.txt, abaixo do script9, após a execução desse script.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
No script10, criamos uma lista chamada linhas na linha 1. Abrimos o arquivo dados_write.txt para
escrita na linha 4, utilizando o mesmo modo de acesso ao arquivo, modo w. Para escrever o conteúdo
da lista linhas no arquivo, utilizamos o método writelines, linha 5.
 
Autor: Autor / Fonte: Autoria própria (2020).
Verifique também o conteúdo do arquivo dados_writelines.txt após a execução do script, abaixo do
script10 na figura.
 DICA
1 - Fique atento, pois o Python não insere quebra de linha (‘\n’) entre os elementos da lista. Precisamos
fazer isso manualmente!
2 - Como o modo w trunca o arquivo, ou seja, remove todo o conteúdo do arquivo, caso ele exista,
podemos executar esses scripts repetidas vezes e, ainda assim, o resultado será sempre o mesmo.
/
No próximo exemplo, vamos mostrar como utilizar o modo append (a) para adicionar conteúdo a um
arquivo já existente.
Para isso, vamos abrir o arquivo dados_write.txt, criado pelo script9, utilizando o modo a. Utilizamos
esse modo para acrescentar conteúdo a um arquivo. Confira, a seguir, o script11.
 
Autor: Autor / Fonte: Autoria própria (2020).
Script11 e sua saída.
 
Autor: Autor / Fonte: Autoria própria (2020).
Em primeiro lugar, na linha 1, abrimos o arquivo dados_write.txt utilizando o modo escrita a (append).
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 3, utilizamos o método write para acrescentar o texto "\nConteúdo adicional." ao final do
arquivo dados_write.txt.
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 5, fechamos o arquivo.
 
Autor: Autor / Fonte: Autoria própria (2020).
Observe como ficou o conteúdo final do arquivo à direita da imagem, onde a nova frase foi posicionada
corretamente ao final do arquivo.
/
BOAS PRÁTICAS
Uma boa prática ao lidar com arquivos é utilizar a palavra reservada with, disponibilizada pelo Python.
Ela garante que o arquivo será fechado adequadamente após utilizarmos o arquivo, não sendo
necessário chamar o método close explicitamente.
A sintaxe de utilização do with é:
WITH OPEN(CAMINHO, MODO) AS NOME: (SEU CÓDIGO
INDENTADO)
 
Iniciamos com a palavra reservada with, seguida da função open, a palavra reservada as, um nome de
variável que receberá o objeto do tipo arquivo e dois pontos. Todo o código indentado posteriormente
está dentro do contexto do with, no qual o arquivo referenciado pela variável nome estará disponível.
Veja como utilizar o with no exemplo a seguir. Clique nas setas e acompanhe.
 
Autor: Autor / Fonte: Autoria própria (2020).
Script12 e sua saída.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 3, utilizando a sintaxe do with, o arquivo dados.txt é aberto no modo leitura e atribuído à
variável arquivo. Esta variável está disponível em todo o escopo do with, linhas 4, 5 e 6.
 
Autor: Autor / Fonte: Autoria própria (2020).
Nas linhas 4 e 5, iteramos sobre o conteúdo do arquivo e imprimimos linha por linha.
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 6, imprimimos o nome do arquivo.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Verifique as saídas no console à direita.
VÍDEO COM AVALIAÇÃO
Assista ao vídeo e veja como acontece a manipulação de arquivos no Python.
Para acompanhar o vídeo e poder executar o programa, baixe os arquivos neste  LINK
VERIFICANDO O APRENDIZADO
1. NO EXERCÍCIO DA FIGURA A SEGUIR, TEMOS O SCRIPT
EXERCICIO_1_MODULO_1.PY E O ARQUIVO DE TEXTO EXERCICIO_1.TXT. 
 
javascript:void(0);
/
 
AUTOR: AUTOR / FONTE: AUTORIA PRÓPRIA (2020).
 EXERCÍCIO 1 DO MÓDULO 1.
 
 
IDENTIFIQUE, NAS ALTERNATIVAS A SEGUIR, QUAL O CONTEÚDO DO
ARQUIVO EXERCICIO_1.TXT APÓS EXECUTAR O SCRIPT. DESCONSIDERE
EVENTUAIS LINHAS EM BRANCO. 
 
A) Teste5 - Teste6 - Teste7 - Teste8
B) Teste7 - Teste8
C) Teste1 - Teste2 - Teste7 - Teste8
D) Teste1 - Teste2 - Teste3 - Teste4 - Teste5 - Teste6 - Teste7 - Teste8
2. IMAGINE QUE FOMOS CONTRATADOS PARA DESENVOLVER UM PROGRAMA
EM QUE UMA DAS FUNCIONALIDADES É EXTRAIR A PRIMEIRA LINHA DE UM
ARQUIVO. DURANTE OS TESTES, VERIFICAMOS QUE A FUNÇÃO QUE
DESENVOLVEMOS PARA EXTRAIR AS LINHAS, EXTRAIR_LINHA, PRECISAVA
SER REFEITA, POIS, COMO OS ARQUIVOS ERAM MUITO GRANDES, A FUNÇÃO
CONSUMIA MUITA MEMÓRIA, TRAVANDO O PROGRAMA. 
 
/
 
AUTOR: AUTOR / FONTE: AUTORIA PRÓPRIA (2020).
 EXERCÍCIO 2 DO MÓDULO 1.
 
 
DENTRE AS OPÇÕES DE SCRIPTS MOSTRADAS NA IMAGEM, IDENTIFIQUE A
OPÇÃO QUE ATENDE AO PROBLEMA APRESENTADO. 
 
A) script_a.py.
B) script_b.py.
C) script_c.py.
D) script_d.py.
GABARITO
1. No exercício da figura a seguir, temos o script exercicio_1_modulo_1.py e o arquivo de texto
exercicio_1.txt. 
 
/
 
Autor: Autor / Fonte: Autoria própria (2020).
 Exercício 1 do módulo 1.
 
 
Identifique, nas alternativas a seguir, qual o conteúdo do arquivo exercicio_1.txt após executar o
script. Desconsidere eventuais linhas em branco. 
 
A alternativa "B " está correta.
 
Sempre que utilizamos o modo de acesso w para abrir um arquivo, o conteúdo do arquivo é apagado
(truncado). Na linha 11, realizamos a abertura do arquivo utilizando esse modo, excluindo todo conteúdo
existente. Nas linhas 12 e 13, escrevemos o conteúdo final que constará no arquivo: Teste 7 e Teste 8.
2. Imagine que fomos contratados para desenvolver um programa em que uma das
funcionalidades é extraira primeira linha de um arquivo. Durante os testes, verificamos que a
função que desenvolvemos para extrair as linhas, extrair_linha, precisava ser refeita, pois, como
os arquivos eram muito grandes, a função consumia muita memória, travando o programa. 
 
/
 
Autor: Autor / Fonte: Autoria própria (2020).
 Exercício 2 do módulo 1.
 
 
Dentre as opções de scripts mostradas na imagem, identifique a opção que atende ao problema
apresentado. 
 
A alternativa "D " está correta.
 
Quando lidamos com arquivos muito grandes, devemos utilizar o método readline() ou iterar diretamente
sobre o arquivo. Esses métodos retornam uma linha por vez do arquivo, sem ler todo seu conteúdo,
resolvendo o problema de leitura de arquivos muito grandes.
MÓDULO 2
 Reconhecer as funções de manipulação de strings
 
Autor: BEST-BACKGROUNDS / Fonte: Shutterstock
/
CONCEITOS
MÉTODOS DE MANIPULAÇÃO DE STRINGS
Durante a vida de programador, é muito comum nos depararmos com situações em que precisamos
realizar alguns ajustes e operações sobre os textos lidos de arquivos.
Ajustes como remover espaço em branco, colocar todas as letras maiúsculas, substituir e contar
palavras são alguns exemplos.
Neste módulo, veremos alguns métodos presentes nos objetos do tipo str (string), que são muito
utilizados em conjunto com a manipulação de arquivos.
 
Autor: isak55 / Fonte: Shutterstock
MÉTODO STRIP
Como mostrado nos scripts da figura 5 (script5), ao ler o conteúdo do arquivo, o Python retorna os
caracteres de final de linha (\r e \n). Muitas vezes, essa informação não é necessária, principalmente se
estivermos tratando uma linha de cada vez.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Dependendo do objetivo, esses caracteres são considerados lixo e podem atrapalhar o processamento
que desejamos realizar. Para remover esses caracteres e também espaços em branco adicionais, o tipo
str disponibiliza o método strip(). Este método remove esses caracteres do início e do final da linha.
Observe o uso deste método no exemplo a seguir. Clique nas setas para acompanhar cada ação.
 
Autor: Autor / Fonte: Autoria própria (2020).
Scripts 13a e 13b, suas respectivas saídas e seu arquivo dados13.txt.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Neste exemplo, vamos abrir o arquivo dados13.txt, exibido à direita da figura, e imprimir o conteúdo de
cada linha desse arquivo. Vamos utilizar o método repr para verificar o real conteúdo da string.
 
Autor: Autor / Fonte: Autoria própria (2020).
O script está separado em duas partes, a e b, de forma a se perceber melhor o resultado da utilização
do método strip().
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Na primeira parte, script13a, abrimos o arquivo no modo leitura, utilizando o with na linha 1, iteramos
sobre o objeto arquivo na linha 3 e imprimimos o conteúdo de cada linha na linha 4.
 
Autor: Autor / Fonte: Autoria própria (2020).
Observe, no console abaixo do script13a, que os espaços em branco no início de cada linha e os
caracteres de nova linha (\n) estão presentes na string.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Na segunda parte, script13b, abrimos o mesmo arquivo e iteramos da mesma forma. Porém, desta vez,
“limpamos” a linha utilizando o método strip, na linha 4. Este método retorna uma nova string, que é
armazenada na variável linha_limpa. Em seguida, na linha 5, imprimimos a representação dessa
variável.
 
Autor: Autor / Fonte: Autoria própria (2020).
Observe a saída do console e verifique que os caracteres em branco do início da linha e os caracteres
de nova linha foram removidos.
Um exemplo real de utilização do strip é quando desejamos contar a quantidade de linhas com algum
conteúdo em um arquivo. Dependendo do tamanho do arquivo, é inviável remover manualmente as
linhas em branco. Para resolver esses problemas, podemos utilizar o método strip, como mostrado a
seguir.
Neste exemplo, vamos abrir o mesmo arquivo do exemplo anterior, dados13.txt, e iterar sobre
cada linha, incrementando um contador, que será impresso no final.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Para melhor ilustrar, vamos mostrar como contar as linhas sem usar o método strip, script14a, com o
strip script14b.
Scripts 14a e 14b e suas respectivas saídas.
 
Autor: Autor / Fonte: Autoria própria (2020).
No primeiro script, abrimos o arquivo em modo leitura na linha 1, criamos e inicializamos uma variável
inteira contador, linha 3, e iteramos seu conteúdo linha a linha, utilizando o loop for, linha 4.
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 5, verificamos se a variável linha, do tipo str, contém algum conteúdo.
Lembrete: Uma variável do tipo string testa para falso apenas se seu conteúdo for vazio ('' ou ""); caso a
string contenha, pelo menos, um espaço, ela testará verdadeiro.
Continuando, na linha 6, caso exista algum conteúdo, incrementamos o contador.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Para o primeiro script, o contador obteve valor 7, indicando que o arquivo contém 7 linhas, conforme
console abaixo do script14a.
 
Autor: Autor / Fonte: Autoria própria (2020).
No segundo script, escrevemos praticamente o mesmo código, iniciando pela abertura do arquivo na
linha 1, e assim por diante. A exceção é a linha 5, que testa o conteúdo da variável linha após utilização
do método strip(). Observe que, agora, contamos corretamente o número de linhas com algum
conteúdo, 3.
MÉTODOS COUNT E SPLIT
Outra atividade muito comum na manipulação de arquivos é a contagem do número de vezes que
determinada palavra aparece. O Python disponibiliza o método count para strings, que recebe como
parâmetro a palavra que desejamos contar e retorna o total de ocorrências dela. Sua sintaxe é a
seguinte:
CONTAGEM = VARIAVEL_STRING.COUNT(PALAVRA)
 
/
Nela, a variavel_string é uma variável do tipo str e palavra é a string que desejamos contar.
Veja, no exemplo a seguir, como utilizamos o método count para contar a quantidade de vezes em que
aparece a palavra “Olá”, no arquivo dados13.txt.
 
Autor: Autor / Fonte: Autoria própria (2020).
Script 15, sua saída e arquivo dados13.txt.
 
Autor: Autor / Fonte: Autoria própria (2020).
Após abrir o arquivo na linha 1, utilizamos o método read, linha 2, para retornar todo o conteúdo do
arquivo como uma única string e armazená-lo na variável texto.
Na linha 3 utilizamos o método count da variável texto, passando como argumento à string “Olá”.
 
Autor: Autor / Fonte: Autoria própria (2020).
O total de ocorrências da palavra “Olá” foi armazenado na variável contador, que foi impressa na linha
4.
Observe que o total de ocorrência está correto: 3.
/
Apesar de ser muito simples a utilização do método count do tipo str, pode gerar alguns efeitos
indesejáveis, pois esse método também conta as palavras que contêm parte da string passada como
argumento.
 EXEMPLO
Considere a frase “Eu amo comer amoras no café da manhã.”. Se utilizarmos o método count, com a
string “amo” como argumento, o retorno será 2, pois o método irá considerar tanto a palavra amo quanto
a palavra amoras.
Para contornar esse problema, podemos “quebrar” uma frase em palavras e depois verificar se cada
palavra é igual à string que buscamos.
Isso nos leva a outro método muito utilizado em processamento de textos, o método split(), que é usado
para quebrar uma string em partes menores, retornando uma lista com essas partes. Sua sintaxe é a
seguinte:
LISTA_TERMOS = VARIAVEL_STRING.SPLIT(SEPARADOR)
 
No exemplo, a variavel_string é uma variável do tipo str, e separador é uma string que desejamos utilizar
como ponto de quebra do texto. O retorno desse método é uma lista de strings.
Digamos que desejamos usar o método split com separador ‘–‘ na frase: “Amo futebol – Gosto de
basquete”.
O resultado seria uma lista onde o primeiro elemento é a string “Amo futebol ” e o segundo elemento é
string “ Gosto de basquete”.
Casonenhum separador seja passado como argumento, o Python irá utilizar um ou mais espaços como
separador padrão.
 DICA
A string utilizada como separador não aparecerá em nenhum elemento da lista retornada.
/
Confira, no exemplo a seguir, em que o método split é utilizado em três frases diferentes para mostrar o
comportamento deste método.
 
Autor: Autor / Fonte: Autoria própria (2020).
Script 16 e sua saída.
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 1, temos a primeira frase: “Eu amo comer amoras no café da manhã”. Utilizamos o método split
sem argumentos, linha 2, e imprimimos a lista retornada na linha 3.
Observe pelo console que cada item da lista é uma palavra da frase.
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 5, temos a segunda frase: "Amora abacaxi abacate banana". Utilizamos o método
split, também, sem argumentos, linha 6, e imprimimos a lista retornada na linha 7.
Observe pelo console que, mesmo havendo muitos espaços em branco entre as palavras da frase, a
lista contém apenas as palavras, sem nenhum espaço adicional. O Python é esperto o suficiente para
detectar vários espaços contínuos e tratá-los como um único separador.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 9, temos a última frase: "Carro,moto,avião". Desta vez, utilizamos o método split passando uma
vírgula ( , ) como argumento, linha 10. O resultado é uma lista contendo apenas as palavras, sem o
separador, conforme podemos ver pelo console.
Agora que sabemos como funciona o método split, no próximo exemplo, vamos utilizar esse método
para realizar a contagem da palavra “amo” na frase do exemplo anterior: “Eu amo comer amoras no café
da manhã.”. Vamos aproveitar para comparar os resultados obtidos pelos métodos count e split.
 
Autor: Autor / Fonte: Autoria própria (2020).
Script 17 e sua saída.
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 1, definimos nossa variável frase com o conteúdo descrito anteriormente.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 4, utilizamos o método count do tipo str para contar diretamente o número de ocorrências da
string ‘amo’ na frase.
Pelo console, vemos que o resultado da contagem foi 2. Uma ocorrência pela palavra amo e outra pela
palavra amora.
 
Autor: Autor / Fonte: Autoria própria (2020).
Para realizar a contagem da mesma frase usando o split, vamos criar um contador, linha 7, e quebrar a
frase em palavras utilizando o método split, linha 8.
 
Autor: Autor / Fonte: Autoria própria (2020).
/
Na linha 9, vamos iterar sobre cada palavra utilizando a variável termo. Para cada termo, comparamos
se seu valor é igual a string ‘amo’, linha 10. Caso seja igual, incrementamos o contador, linha 11.
Observe que desta vez alcançamos o resultado correto para a contagem, 1.
 DICA
Para evitar iterar sobre a lista, criar contador e realizar comparações, podemos utilizar o método count
da lista, que obteremos o mesmo resultado. Confira o código na imagem.
 
Autor: Autor / Fonte: Autoria própria (2020).
 Script 18 e sua saída.
Após definida a frase, linha 1, e quebrada em palavras com o método split, linha 3, utilizamos o método
count da lista lista_termos para contar a ocorrência da string ‘amo’. Observe que o resultado também
está correto.
MÉTODO JOIN
Assim como há a necessidade de quebrar uma frase em uma lista de palavras, podem existir situações
em que ocorra o inverso, ou seja, temos uma lista de palavras ou frases e desejamos concatená-las em
uma única string.
Para essa operação, utilizamos o método join do tipo str, que retorna uma única string com todos os
elementos da lista concatenados, utilizando determinado conector. Sua sintaxe é a seguinte:
STRING_FINAL = “CONECTOR”.JOIN(ITERAVEL)
 
/
Onde ‘conector’ é a string que será utilizada entre os elementos da lista que serão concatenados (ex. ‘, ‘)
e iteravel é um iterável, como uma lista ou tupla.
No exemplo a seguir, vamos unir os elementos de uma lista utilizando dois conectores diferentes: o
conector vírgula (‘, ‘) e o conector de nova linha (‘\n’). Após a união, vamos gravar o conteúdo em um
arquivo para mostrar o resultado.
 
Autor: Autor / Fonte: Autoria própria (2020).
Script 19 e arquivos texto1.txt e texto2.txt.
 
Autor: Autor / Fonte: Autoria própria (2020).
Em primeiro lugar, na linha 1, criamos a lista minha_lista, que será utilizada nos dois exemplos.
 
Autor: Autor / Fonte: Autoria própria (2020).
No primeiro exemplo, na linha 3, utilizamos o método join com o conector ‘, ‘ e atribuímos o resultado à
variável texto1.
O resultado dessa variável foi gravado no arquivo texto1.txt, que pode ser visto na imagem.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
No segundo exemplo, na linha 7, fazemos a junção dos elementos da mesma lista utilizando o conector
‘\n’.
O resultado da junção foi gravado no arquivo texto2.txt, que pode ser visto à direita da imagem. Com
isso, fomos capazes de colocar cada elemento da lista em uma linha do arquivo.
Observe que o Python foi esperto o suficiente para não adicionar o conector ao último elemento. Isso
pode ser percebido pelo resultado do arquivo texto1.txt.
MANIPULAÇÃO DE VARIÁVEIS EM STRINGS
Até o momento, realizamos operações sobre strings pré-existentes. No entanto, é muito comum
precisarmos juntar valores de variáveis com strings.
Agora, veremos algumas funções relacionadas às strings, começando pela formatação de strings (string
formatting).
A formatação de strings permite ajustar como uma string será exibida ou gravada em um arquivo, por
exemplo. Ajustes como: número de casas decimais em float, exibição de datas, inclusão de variáveis e
espaçamento são alguns dos exemplos.
Existem basicamente três formas de realizar a formatação de strings. São elas:
Utilizando f-strings (formatted string literals).
Utilizando o método format() das strings.
Fazendo manualmente.
Veremos como utilizar f-strings, recurso adicionado na versão 3.6 do Python.
javascript:void(0)
/
F-STRINGS
Os f-strings são tipos especiais de strings que aceitam uma notação especial para permitir a
inclusão de expressões diretamente na string.
F-STRINGS
O objetivo principal da criação das f-strings foi facilitar a formatação de strings.
Para definimos uma variável f-string, precisamos incluir, antes das aspas que definem uma
string, a letra f (ou F), como, por exemplo:
MINHA_STRING = F”OLÁ MUNDO {EXPR}”
 
Dentro das f-string, podemos utilizar expressões em Python entre as chaves, delimitadas pelos
caracteres { e }.
Essas expressões incluem variáveis ou literais. Inclusive, podemos fazer chamada para funções ou
utilizar métodos de variáveis dentro desses delimitadores.
Todo o conteúdo entre os caracteres { e } é substituído pelo resultado da expressão e interpolados à
string.
No exemplo a seguir, vamos comparar a manipulação manual de strings com a utilização de f-string.
Também vamos mostrar alguns exemplos de uso de literais mais sofisticados dentro de f-strings.
 
LITERAIS
javascript:void(0)
/
Literal é algo que o interpretador reconhece como uma sintaxe válida (exemplo: 2 > 3 retorna
False, [1, 2]) retorna uma lista.
 
Autor: Autor / Fonte: Autoria própria (2020).
Script 20 e sua saída.
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 1, definimos a variável nome, do tipo string, que será utilizada ao longo do script.
Na linha 3, mostramos como incluir o valor da variável nome no meio de outra string, utilizando o
processo manual de concatenação de strings por meio do operador ‘+’.
/
 
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 4, utilizamos a sintaxe da f-string para incluir o valor da variável nome também no meio de outra
string.
Observe que:
A IDE PyCharm já detectou que temos uma expressão entre as chaves e alterou a cor para
destacar esse elemento.
No console, o resultado das variáveis minha_string e minha_fstring1 foi o mesmo, porém a sintaxe
daf-string é muito mais clara e simples de ser utilizada e entendidas.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 5, temos o mesmo exemplo da linha anterior, porém chamamos o método upper do tipo str para
colocar todas as letras em maiúsculo. Isso foi feito diretamente na expressão!
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 6, utilizamos uma soma na expressão entre chaves, que foi calculada corretamente, conforme
console.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
Na linha 7, utilizamos o comparador booleano >, que também foi avaliado corretamente.
 
Autor: Autor / Fonte: Autoria própria (2020).
No último exemplo, na linha 8, utilizamos o operador IN para verificar a pertinência de um número em
uma lista, que, mais uma vez, foi avaliado corretamente.
Observe como é fácil e intuitiva a utilização de f-string!
No próximo exemplo, vamos mostrar algumas funcionalidades adicionais de formatação de string
utilizando f-string, como a definição de largura de uma string, formatação de float e de datas.
/
 
Autor: Autor / Fonte: Autoria própria (2020).
 Script 21 e sua saída.
Para facilitar o entendimento, o script21 foi dividido em três trechos. O primeiro trecho, entre as linhas 3
e 6, trata da formatação de largura do conteúdo de expressões, que serve, principalmente, para alinhar
conteúdo de texto. No segundo trecho, das linhas 10 a 16, mostramos como formatar floats. No terceiro
trecho, das linhas 20 a 24, mostramos como formatar datas. Clique a seguir para conhecer cada trecho
citado.
LINHAS 3 ATÉ 6
No primeiro trecho, definimos uma lista chamada frutas na linha 3 e, na linha 4, percorremos cada item
dessa lista.
Para cada item, montamos a f-string minha_fruta, que contém o nome da fruta e o número de letras que
a fruta tem. Destacamos essa linha a seguir:
 
Autor: Autor / Fonte: Autoria própria (2020).
 Destaque f-string.
Para indicar a largura, ou melhor, o número de espaços que o conteúdo de uma variável deve ocupar,
devemos utilizar a sintaxe {variavel:n}, onde temos o nome da variável, seguida de dois pontos (:) e o
número de espaços (n) que se deve ocupar.
Caso o tamanho do conteúdo da variável seja menor que o número n, serão incluídos espaços em
branco até completar esse tamanho. A posição dos espaços adicionados depende do tipo da variável.
Para variáveis do tipo string, os espaços são adicionados à direita, enquanto para variáveis do tipo
inteiro, os espaços são adicionados à esquerda.
Caso o tamanho do conteúdo da variável seja maior que o número n, a formatação será ignorada.
/
Retornando ao exemplo, desejamos imprimir o nome da fruta de forma que ela ocupe 12 espaços
({fruta:12}), e o número de letras da fruta deve ocupar apenas três espaços ({len(fruta):3}). Observe o
resultado obtido no console à direita.
LINHAS 10 ATÉ 16
No segundo trecho, definimos uma variável float na linha 10 e criamos três f-strings para exibir esse
conteúdo.
A formatação com f-string nos permite um controle maior de como será exibido um número do tipo float,
no qual podemos definir a largura e o número de casas decimais que devem ser exibidos. A sintaxe para
formatar um float é a seguinte:
{VARIAVEL_FLOAT:LARGURA.PRECISAO F}
 
Pelo exemplo, temos o nome da variável do tipo float seguida de dois pontos (:), a largura total que o
número deve ocupar, incluindo as casas decimais, e o ponto (separador de decimal), seguido de um
ponto (.), o número de casas decimais (precisao) e a letra “f”, que deve estar junto à precisão. A largura
é opcional.
Na primeira f-string, na linha 11, utilizamos a expressão {pi:.1f}, ou seja, queremos que seja exibido o
valor da variável pi com uma casa decimal apenas. Como não especificamos a largura, ela será
calculada de forma a acomodar toda a parte inteira do float.
Na f-string da linha 12, utilizamos a expressão {pi:6.1f}, que indica que o número deve ocupar seis
espaços, sendo que, necessariamente, deve ter uma casa decimal.
Na última f-string, linha 13, utilizamos a expressão {pi:.4f}, para que seja exibido o número com quatro
casas decimais.
Observe, no console, como ficaram os resultados.
LINHAS 20 ATÉ 24
No terceiro e último trecho, vamos mostrar como formatar datas em expressões f-string.
Na linha 20, definimos a variável data com a data atual, utilizando o método datetime.now().
Na linha 21, criamos uma f-string para exibir o valor da variável data sem informar ao Python qual
formatação ele deve utilizar ({data}). Com isso, a data foi impressa no formato padrão: 2020-08-13
10:50:32.262037.
Na linha 22, utilizamos a expressão {data:%d/%m/%Y}, que indica que desejamos exibir a data no
formato “dia/mês/ano” (13/08/2020). Veja o resultado no console à direta.
/
 DICA
O Python disponibiliza outras maneiras de formatar datas. Pesquise mais sobre o módulo datetime na
documentação oficial para descobrir outras.
VÍDEO COM AVALIAÇÃO
Assista, no vídeo, a manipulação de strings com Python.
Para acompanhar o vídeo e poder executar o programa, baixe os arquivos neste  LINK
VERIFICANDO O APRENDIZADO
1. NO SCRIPT DA IMAGEM A SEGUIR, EXECUTAMOS UMA SEQUÊNCIA DE
MÉTODOS DE MANIPULAÇÃO DE STRING SOBRE O ARQUIVO TEXTO
EXERCÍCIO_1_MODULO_2.TXT, TAMBÉM NA FIGURA, E GRAVAMOS O
RESULTADO NO ARQUIVO RESULTADO1.TXT. 
 
javascript:void(0);
/
 
AUTOR: AUTOR / FONTE: AUTORIA PRÓPRIA (2020).
 EXERCÍCIO 1 DO MÓDULO 2.
 
 
IDENTIFIQUE, NAS RESPOSTAS A SEGUIR, QUAL O RESULTADO CORRETO
CONTIDO NO ARQUIVO RESULTADO1.TXT. 
 
A) Novo conteúdo - Banana - Uva - Laranja
B) Novo conteúdo Banana - Novo conteúdo Uva - Novo conteúdo Laranja
C) Banana - Uva - Laranja
D) Novo conteúdo Banana - Novo conteúdo Uva - Novo conteúdo Laranja
CONSIDERE QUE ESTAMOS DESENVOLVENDO UM PROGRAMA E, EM
DETERMINADO PONTO, TEMOS UMA VARIÁVEL CHAMADA FRASE COM A
SEGUINTE STRING: “ÔMEGA;OPALA;MONZA”. 
 
QUAL DOS SEGUINTES MÉTODOS DEVEMOS UTILIZAR PARA CRIAR UMA
LISTA COM AS PALAVRAS ÔMEGA; OPALA E MONZA?
A) frase.split().
B) frase.strip().
C) frase.split(“;”).
D) “;”.join(frase).
GABARITO
/
1. No script da imagem a seguir, executamos uma sequência de métodos de manipulação de
string sobre o arquivo texto exercício_1_modulo_2.txt, também na figura, e gravamos o resultado
no arquivo resultado1.txt. 
 
 
Autor: Autor / Fonte: Autoria própria (2020).
 Exercício 1 do módulo 2.
 
 
Identifique, nas respostas a seguir, qual o resultado correto contido no arquivo resultado1.txt. 
 
A alternativa "B " está correta.
 
No script, na linha 2, lemos todo o conteúdo do arquivo utilizando o método read e, na sequência,
utilizamos o método split para quebrar o texto em palavras. Cada palavra é iterada na linha 5 e utilizada
para montar a f-string da linha 6. Para cada iteração, o conteúdo da f-string será: “Novo conteúdo” +
palavra + “ ”. Cada f-string gerada é escrita no arquivo resultado1.txt.
Considere que estamos desenvolvendo um programa e, em determinado ponto, temos uma
variável chamada frase com a seguinte string: “Ômega;Opala;Monza”. 
 
Qual dos seguintes métodos devemos utilizar para criar uma lista com as palavras Ômega; Opala
e Monza?
A alternativa "C " está correta.
 
O método split é utilizado para quebrar uma string em uma lista de palavras. O parâmetro passado para
esse método é utilizado como separador. Ao executar o comando frase.split(“;”), criamos a lista
[“Ômega”, “Opala”, “Monza”].
/
MÓDULO 3
 Descrever as exceções na manipulação de arquivos e outras operações
 
Autor: etamorworks / Fonte: Shutterstock
CONCEITOS
TRATAMENTO DE EXCEÇÕES
Quando trabalhamos com arquivos, é comum encontrarmos alguns problemas, como arquivo inexistente
e falta de permissão para escrever em um arquivo. A maioria desses problemas só pode ser detectada
durante a execução do programa.
Quando uma falha inesperada ocorre e o interpretador não consegue resolver o problema, dizemos que
houve uma exceção.
Nesses casos, precisamos informar ao interpretador como tratara exceção, para que o programa não
seja interrompido.
EXCEÇÃO.
A exceção é um evento que ocorre quando o programa se desvia do fluxo normal de execução
javascript:void(0)
/
PORÉM, SE A EXCEÇÃO É UM PROBLEMA
INESPERADO, COMO TRATÁ-LA?
Ao desenvolver um programa, precisamos procurar na documentação da biblioteca, do módulo ou da
própria linguagem de programação se as funcionalidades que vamos utilizar têm exceções mapeadas.
Essas exceções são problemas que podem ocorrer, e é nossa tarefa tratá-las.
Você deve estar se perguntando: “O que seria ‘tratar uma exceção’?”. Tratar uma exceção nada mais é
do que dizer ao Python o que fazer, ou quais instruções executar, quando ele encontrar um problema.
 
Autor: metamorworks / Fonte: Shutterstock
Para ilustrar, observe o fluxo a seguir.
Quando abrimos um arquivo em modo leitura e esse arquivo não existe, o Python lança uma exceção do
tipo FileNotFoundError.

Se não avisarmos ao Python o que fazer quando isso ocorrer, o programa será interrompido.

/
Nesse caso, um tratamento para essa exceção poderia ser: exibir um pop-up ao usuário informando que
o arquivo não existe.
No exemplo a seguir, vamos mostrar o que acontece quando uma exceção lançada não é tratada.
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
Script 22 e sua saída.
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
Na linha 1, imprimimos a string “Abrindo um arquivo”. Essa impressão serve para acompanhar a
execução do programa no console.
/
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
Na linha 3, abrimos o arquivo teste.txt no modo leitura. Esse arquivo não existe no diretório modulo3 no
qual estamos trabalhando, como podemos observar pela árvore de diretórios à esquerda da figura.
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
Ao executarmos o programa, recebemos um erro, destacado em vermelho no console. O nome do erro é
FileNotFoundError, e a sua descrição é No such file or directory (em tradução literal, não existe tal
arquivo ou diretório), seguido do nome do arquivo que apresentou o erro, teste.txt.
/
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
Essa exceção foi gerada, ou lançada, de acordo com o linguajar da computação, pois o Python não
sabia qual caminho tomar ao encontrar esse problema.
Observe que a linha 5 não foi executada, pois o programa parou sua execução assim que o problema foi
encontrado.
Para resolver isso, precisamos tratar a exceção, ou melhor, uma possível exceção. Esse tratamento
informa ao Python uma rota alternativa, caso ele encontre um problema.
Para tratar exceções, precisamos “envolver” o trecho de código passível de erro com a cláusula
try/except ou try/except/finally. Veremos apenas a cláusula try/except.
Veja a sintaxe ao lado:
O código crítico que desejamos executar deve estar no escopo do try, enquanto o código alternativo,
que será executado em caso de erro, deve estar no escopo do except.
Uma mesma operação pode lançar mais de um tipo diferente de exceção, em que, para cada tipo, Erro1
e Erro2, devemos ter uma cláusula except específica.
No exemplo da figura, a exceção está disponível por meio da variável erro, de onde podemos extrair
mais informações, como veremos a seguir.
/
 
Fonte: Autor/Shutterstock
 Sintaxe try/except.
Praticamente todas as exceções em Python são herdadas da classe Exception, ou seja, ela é uma
exceção muito genérica, lançada por diversos tipos de erros diferentes. Quanto mais genérica, mais
abrangente é a exceção.
 ATENÇÃO
Não é uma boa prática utilizar exceções abrangentes, pois elas podem silenciar erros que não
esperamos. O ideal é tratar as exceções utilizando a forma mais específica possível.
A seguir, apresentamos algumas exceções específicas relacionadas à manipulação de arquivos e alguns
motivos que podem gerar essas exceções:
FILEEXISTSERROR
Lançada quando tentamos criar um arquivo ou diretório já existentes.
FILENOTFOUNDERROR
Lançada quando tentamos abrir um arquivo ou diretório que não existem.
PERMISSIONERROR
Lançada quando não temos permissão para realizar uma operação
javascript:void(0)
javascript:void(0)
javascript:void(0)
/
Todas essas exceções herdam da exceção mais abrangente OSError, que, por sua vez, herda de
Exception.
Observe o exemplo a seguir, onde vamos tratar a exceção do exemplo anterior, utilizando a exceção
específica mais indicada: FileNotFoundError.
 
autor/shutterstock
Script 23 e sua saída.
 
autor/shutterstock
O primeiro passo é “envolver” o código que pode gerar problema com o try. Para isso, indentamos as
linhas 4 e 5.
/
 
autor/shutterstock
Para tratar o erro, precisamos explicitar qual o tipo de erro que vamos tratar. Nesse caso,
FileNotFoundError, como descrito na linha 6.
Indentamos as linhas 7 e 8 para indicar que elas fazem parte do escopo da exceção explicitada na linha
6.
 
Fonte: Autor/Shutterstock
Durante a execução do programa, ao executar a linha 4, o Python encontra um erro, pois tentamos abrir
o arquivo teste.txt para leitura, mas ele não existe. Como este código está dentro do escopo do try, o
interpretador interrompe imediatamente a execução do código contido nesse escopo e inicia a execução
/
do código do except correspondente ao erro FileNotFoundError. Ou seja, a execução salta da linha 4
para a linha 7.
Na linha 7, imprimimos a mensagem "Arquivo inexistente" e, na linha 8, imprimimos o problema
encontrado, disponível na variável erro.
Observe a sequência de execução pelas saídas no console.
Saiba que o Python só consegue tratar a exceção caso o erro esteja mapeado em algum except. Se o
interpretador não encontrar o except adequado, será gerado um erro, e o programa será interrompido.
Um problema clássico que ocorre quando lidamos com arquivos é tentar alterar o conteúdo de um
arquivo quando ele está aberto em outro programa. No caso do sistema operacional Windows 10, é
lançada uma exceção sobre permissão de acesso.
No exemplo ao lado, vamos criar mais um except para tratar o caso de não termos permissão para abrir
um arquivo, mostrando o tratamento do problema levantado no parágrafo anterior.
Neste exemplo, vamos tentar abrir o arquivo teste.pdf para escrita, linha 4, porém ele já se encontra
aberto em outro programa.
Observe que o fluxo de execução do programa saltou da linha 4 para a linha 10. Na linha 10, temos
o início do tratamento da exceção PermissionError, que foi justamente a exceção lançada pelo Python,
impressa pela linha 11, e que pode ser verificada no console.
Como dito anteriormente, o Python direciona o fluxo de execução para o trecho onde é realizado o
tratamento da exceção lançada.
 
Fonte: Autor/Shutterstock
 Script 24 e sua saída.
/
Vamos explorar mais operações referentes a arquivos e diretórios. Aproveitaremos também para mostrar
novas exceções que podem ser lançadas quando utilizamos tais operações.
OUTRAS OPERAÇÕES EM ARQUIVOS
Além das opções para leitura e escrita em arquivos, o Python disponibiliza um conjunto de operações
adicionais, como renomear e apagar arquivo, além de operações em diretórios, como listar arquivos de
diretórios, criar diretórios etc.
A partir de agora, apresentaremos algumas dessas operações.
Vamos iniciar pela operação de remover um arquivo, que está disponível por meio da função remove do
módulo os do Python.
A função remove tem a seguinte sintaxe:
>>> OS.REMOVE(CAMINHO)
 
Neste exemplo, temos o nome do módulo os, seguido de um ponto e o nome da função remove. Como
parâmetro, a função espera o caminho para um arquivo. Para remover diretório, devemos utilizar outra
função, rmdir.
Veja ao lado, onde mostramos a função remove.
Iniciamos o script com a importação do módulo os, na linha 1.
Neste exemplo, vamos remover o arquivo teste.txt, que se encontra no mesmo diretório do nosso script.
Observe a arvore de diretórios à esquerda.
Na linha 2, utilizamos a função remove, passando como argumento o caminho do arquivo que
desejamos remover.Como estamos no mesmo diretório, utilizamos apenas o nome do arquivo.
Pronto! Isso é suficiente para remover um arquivo.
/
 
Fonte: Autor/Shutterstock
 Script 25 e sua saída
Dentre as exceções lançadas ao usar a função remove, destacamos as seguintes:
FILENOTFOUNDERROR
PERMISSIONERROR
ISADIRECTORYERROR
FILENOTFOUNDERROR
Ocorre quando o arquivo não existe.
PERMISSIONERROR
Ocorre quando não temos permissão para alterar o arquivo.
ISADIRECTORYERROR
Ocorre quando tentamos remover um diretório usando a função remove, em vez de rmdir.
/
Observe a saída do console, onde tudo ocorreu conforme esperado e nenhuma exceção foi lançada.
A segunda operação que veremos, também muito comum, é a de renomear um arquivo. Essa operação
também está disponível no módulo os, mas por meio da função rename.
A função rename tem a seguinte sintaxe:
>>> OS.RENAME(ORIGEM, DESTINO)
 
 Nesse exemplo, temos o nome do módulo os, seguido de um ponto e o nome da função rename. Como
parâmetro, a função espera o caminho para o arquivo que desejamos renomear, origem, e o novo nome
do arquivo, destino.
Veja o exemplo ao lado, em que descrevemos o uso dessa função.
Na linha 1, importamos o módulo os, no qual será utilizada a função rename.
Na linha 4, chamamos a função rename com os parâmetros teste_alfa.txt (origem) e teste_beta.txt
(destino). Caso tudo ocorra bem, ao final da operação, teremos apenas o arquivo destino.
 
Fonte: Autor/Shutterstock
 Script 26 e sua saída.
A seguir, vamos falar sobre algumas exceções que podem ser lançadas quando utilizamos a função
rename. Não estamos tratando todas as opções possíveis, mas apenas as mais comuns.
FILENOTFOUNDERROR
javascript:void(0)
/
Ocorre quando a origem não existe.
PERMISSIONERROR
Ocorre quando não temos permissão para alterar o arquivo de origem ou não temos permissão para
escrita do destino.
FILEEXISTSERROR
Ocorre quando o arquivo de destino já existe.
Na figura do nosso exemplo, observe a árvore de diretórios à esquerda. Temos tanto o arquivo
teste_alfa.txt quanto o arquivo teste_beta.txt.
Observe a execução do script pelo console e veja que ele saltou da linha 4 para a linha 13. Isso ocorreu
porque, como o arquivo teste_beta.txt já existia, a exceção FileExistsError foi lançada.
 DICA
Para os casos em que desejamos renomear sobrescrevendo o arquivo destino, caso ele exista,
podemos utilizar a função replace, também do módulo os.
OPERAÇÕES EM DIRETÓRIOS
CRIANDO E REMOVENDO DIRETÓRIOS
Trabalhar com arquivos significa trabalhar com diretórios. Nesta seção, vamos mostrar as principais
funcionalidades relacionadas à manipulação de diretórios em Python.
Vamos começar pela criação e remoção de um diretório.
Para criar um diretório, utilizamos a função mkdir do módulo os, enquanto, para remover um diretório,
utilizamos a função rmdir, também do módulo os.
A sintaxe dessas duas funções são as seguintes:
javascript:void(0)
javascript:void(0)
/
>>> OS.MKDIR(CAMINHO)
 
>>> OS.RMDIR(CAMINHO)
 
Neste exemplo, temos o nome do módulo os, seguido de um ponto e o nome da função mkdir ou rmdir.
Como parâmetro, a função espera o caminho para o diretório.
Veja o exemplo a seguir, onde utilizamos essas duas funções.
 
Fonte:Shutterstock
 Scripts 28 e 29 e suas respectivas saídas.
No script 28, importamos o módulo os na linha 1 e, na linha 4, utilizamos a função
mkdir(“meu_diretorio”). O diretório meu_diretorio foi criado na mesma pasta onde o script28 se encontra.
Caso não tenhamos permissão para criar o diretório, será lançada a exceção PermissionError.
Caso o diretório já exista, a exceção FileExistsError é lançada.
No script29, na linha 4, utilizamos a função rmdir para remover o diretório meu_diretorio.
Caso não tenhamos permissão para remover o diretório, será lançada a exceção PermissionError.
Caso o diretório não exista, a exceção FileNotFoundError é lançada.
/
Para os casos em que o diretório a ser removido não esteja vazio, será lançada a exceção OSError.
Essa exceção é mais abrangente. Por isso, não temos como garantir, a princípio, que a exceção
lançada ocorre especificamente pelo fato de o diretório não estar vazio.
Nessas situações, precisamos analisar mais o erro, principalmente o número do erro, para verificar o
que realmente aconteceu. O número do erro está disponível no atributo errno do objeto erro.
Os códigos dos possíveis erros estão no módulo errno do Python e podem ser utilizados no tratamento
das exceções para descobrir o que realmente deu errado.
No exemplo a seguir, vamos mostrar esse problema mais de perto.
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
Script 30, sua saída e modulo errno.py.
/
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
À esquerda, no script30, importamos os módulos os e errno nas linhas 1 e 2.
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
Na linha 5, tentamos remover o diretório meu_diretorio utilizando a função rmdir. Como o diretório não
está vazio, a exceção OSError é lançada, e a execução do programa salta para a linha 8.
/
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
Na linha 8, imprimimos o número do erro por meio do atributo errno da variável erro. Observe que o
valor impresso foi 41. O erro 41 faz parte da numeração interna de erros do Python, que pode ser
verificado no modulo errno à direita da imagem, mapeado como ENOTEMPTY (não vazio).
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
Na linha 9, comparamos o erro gerado pelo programa com o código do erro ENOTEMPTY (erro 41).
Caso o resultado da comparação seja verdadeiro, teremos certeza de que o erro ocorreu, pois o diretório
não está vazio. Caso contrário, precisaremos analisá-lo novamente.
O WinError 145 é o erro nativo que o Windows retornou. Esse erro foi mapeado pelo Python para o erro
41.
/
 ATENÇÃO
Como a exceção OSError é mais abrangente que as outras exceções que estudamos, ela deve ficar por
último. Caso contrário, nunca alcançaremos as exceções mais específicas.
LISTANDO CONTEÚDO DE DIRETÓRIOS
Outra tarefa muito comum quando estamos tratando com arquivos é listar os arquivos presentes em um
diretório.
Para isso, podemos utilizar a função scandir do módulo os. Sua sintaxe é a seguinte:
>>> OS.SCANDIR(CAMINHO)
 
 Neste exemplo, temos o nome do módulo os, seguido de um ponto e o nome da função scandir. Como
parâmetro, a função espera o caminho para o diretório.
Como resultado, teremos um iterável (iterator) que retorna objetos do tipo os.DirEntry, que podem ser
arquivos ou diretórios. Dentre os atributos e métodos desse tipo de objetos, destacamos:
NAME
Nome do diretório ou arquivo.
PATH
Caminho completo do diretório ou arquivo.
IS_DIR()
Retorna verdadeiro se o objeto é um diretório.
IS_FILE()
Retorna verdadeiro se o objeto é um arquivo.
javascript:void(0)
javascript:void(0)
javascript:void(0)
javascript:void(0)
/
STAT()
Retorna alguns atributos do arquivo ou diretório, como tamanho.
No exemplo a seguir, vamos mostrar como utilizar essa função.
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
Script 31 e sua saída.
Neste exemplo, vamos percorrer os arquivos e diretórios da pasta meu_diretorio. A árvore de diretórios
pode ser verificada à esquerda da figura.
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
Na linha 1, importamos o módulo os, onde se encontra a função scandir.
javascript:void(0)
/
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
Na linha 4, utilizamos a função scandir utilizando o diretório “meu_diretorio” como argumento.
Armazenamos o retorno dessa função na variável entradas.
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
Na linha 6, iteramos cada entrada e, da linha 7 a 13, imprimimos algumas de suas propriedades.
 
Autor: Autor / Fonte: Fonte: Autoria própria (2020).
/
Observe a saída no console à direita.
VÍDEO COM AVALIAÇÃO
Assista, no vídeo, a explicação sobre manipulação de arquivos e diretórios com Python.
VERIFICANDOO APRENDIZADO
1. QUANDO REALIZAMOS OPERAÇÕES COM ARQUIVOS, É UMA BOA PRÁTICA
TRATAR AS EXCEÇÕES QUE PODEM OCORRER. QUAL É A SEQUÊNCIA DE
TRATAMENTO DE EXCEÇÕES QUE DEVEMOS UTILIZAR PARA GARANTIR QUE
AS EXCEÇÕES QUE PODEM SER LANÇADAS AO REMOVER UM ARQUIVO
UTILIZANDO A FUNÇÃO OS.REMOVE() SEJAM CAPTURADAS E TRATADAS
CORRETAMENTE? 
 
A) Exception - OSError - FileNotFoundError - PermissionError - IsADirectoryError
B) FileNotFoundError - PermissionError - Exception - OSError - IsADirectoryError
C) OSError - FileNotFoundError - PermissionError - IsADirectoryError - Exception
D) FileNotFoundError - PermissionError - IsADirectoryError - OSError - Exception
2. NO SCRIPT A SEGUIR, VAMOS UTILIZAR O MÉTODO SCANDIR PARA
MOSTRAR OS ARQUIVOS DO DIRETÓRIO EXPLICITADO NA LINHA 3. 
/
 
 
AUTOR: AUTOR / FONTE: AUTORIA PRÓPRIA (2020).
 EXERCÍCIO 2 DO MÓDULO 3.
 
 
CONSIDERE A ÁRVORE DE DIRETÓRIOS À ESQUERDA DA FIGURA E ASSINALE
A RESPOSTA QUE CONTÉM A SAÍDA DO PROGRAMA. 
 
A) arquivo1.txt - arquivo2.txt - imagem1.png - imagem2.png - exercicio_2_modulo_3.py - outro_script.py
B) downloads - imagens - outro_script.py
C) downloads - imagens - exercicio_2_modulo_3.py - outro_script.py
D) downloads - imagens
GABARITO
1. Quando realizamos operações com arquivos, é uma boa prática tratar as exceções que podem
ocorrer. Qual é a sequência de tratamento de exceções que devemos utilizar para garantir que as
exceções que podem ser lançadas ao remover um arquivo utilizando a função os.remove() sejam
capturadas e tratadas corretamente? 
 
A alternativa "D " está correta.
 
função os.remove() pode lançar as exceções FileNotFoundError, PermissionError e IsADirectoryError.
Para conseguir tratar essas exceções, isso precisa ser feito antes das exceções mais abrangentes
/
Exception e OSError. A opção D é a única na qual essas três exceções estão antes das mais
abrangentes.
2. No script a seguir, vamos utilizar o método scandir para mostrar os arquivos do diretório
explicitado na linha 3. 
 
 
Autor: Autor / Fonte: Autoria própria (2020).
 Exercício 2 do módulo 3.
 
 
Considere a árvore de diretórios à esquerda da figura e assinale a resposta que contém a saída
do programa. 
 
A alternativa "C " está correta.
 
Sint id proident in excepteur veniam deserunt exercitation. Consectetur deserunt pariatur quis officia ut et
eu labore consequat excepteur ea aliquip anim.
CONCLUSÃO
/
 
Autor: metamorworks / Fonte: Shutterstock
CONSIDERAÇÕES FINAIS
Neste tema, visitamos as principais ações que podemos realizar na manipulação de arquivos e
diretórios.
Vimos como abrir um arquivo, ler seu conteúdo e escrever novos conteúdos.
Aproveitamos para mostrar funções de manipulação de strings, que são normalmente relacionadas ao
tratamento de arquivos, como quebrar linhas em palavras e juntar listas de strings a um conector em
particular.
Além disso, entendemos as principais exceções geradas quando estamos trabalhando com arquivos, de
forma a tratá-las e garantir o correto funcionamento de nossos programas.
REFERÊNCIAS
Python. Python Software Foundation. Consultado em meio eletrônico em: 10 ago. 2020.
/
EXPLORE+
Além de manipular arquivos de texto, o Python permite a leitura e escrita de arquivos binários.
Como exemplo, podemos citar o tratamento de arquivos comprimidos. O Python possui um módulo
interno chamado gzip, que permite a leitura e escrita desse tipo de arquivo. Pesquise sobre o
módulo gzip e verifique os comandos de manipulação existentes.
Outro tipo de arquivo binário é a imagem. Apesar de o Python não ter um módulo interno que
suporte manipulação de imagens, existem bibliotecas gratuitas que dão esse suporte, como Pillow
e OpenCV. Pesquise sobre essas bibliotecas e verifique os recursos disponíveis para a
manipulação de imagens.
CONTEUDISTA
Frederico Tosta de Oliveira
 CURRÍCULO LATTES
javascript:void(0);
/
DESCRIÇÃO
Desenvolvimento de aplicações para armazenamento e recuperação de informação em banco
de dados utilizando a linguagem de programação Python.
PROPÓSITO
Compreender os passos e ações necessárias para realizar a manipulação de registro em
banco de dados, de forma a garantir o correto funcionamento de programas que tenham essas
características.
PREPARAÇÃO
Antes de iniciar o conteúdo, sugerimos que você tenha o software Python 3.7, ou posterior,
instalado em seu computador. Ele será utilizado nos módulos deste tema.
/
Você pode pesquisar e baixar o Python 3.7 no site oficial do Python.
Para programar os exemplos apresentados neste módulo, utilizamos a IDE PyCharm
Community. Você pode baixar essa IDE gratuitamente no site oficial da JetBrains.
Para visualizar os dados e tabelas, vamos utilizar o DB Browser for SQLite, também disponível
gratuitamente.
Para que você possa acompanhar melhor os exemplos apresentados clique aqui para realizar
o download do arquivo “Banco de dados.zip” que contém os scripts utilizados neste conteúdo.
OBJETIVOS
MÓDULO 1
Reconhecer as funcionalidades de frameworks e bibliotecas para gerenciamento de banco de
dados
MÓDULO 2
Empregar as funcionalidades para conexão, acesso e criação de bancos de dados e tabelas
MÓDULO 3
Aplicar as funcionalidades para inserção, remoção e atualização de registros em tabelas
MÓDULO 4
Empregar as funcionalidades para recuperação de registros em tabelas
http://estacio.webaula.com.br/cursos/temas/python_com_banco_de_dados/docs/codigos-fontes.zip
/
INTRODUÇÃO
Neste tema, aprenderemos a utilizar o Python para criar aplicações que utilizam banco de
dados.
Atualmente, muitas aplicações, como gerenciadores de conteúdo, jogos e sistemas de controle
de vendas utilizam banco de dados. É muito importante que o desenvolvedor saiba manipular
as informações de um banco de dados.
Nos próximos módulos, mostraremos como criar novos bancos de dados, tabelas e
relacionamentos, inserir e remover registros, além de recuperar as informações presentes no
banco por meio de consultas.
Para demonstrar a utilização desses comandos, usaremos o banco de dados SQLite, que é um
banco de dados leve, baseado em arquivo, que não necessita de um servidor para ser
utilizado.
O SQLite está disponível em diversas plataformas, inclusive em celulares com sistema
operacional Android.
O SQLite também é muito utilizado durante o desenvolvimento das aplicações, para então ser
substituído por um banco de dados mais robusto, como PostgreSQL ou MySQL, quando em
produção.
MÓDULO 1
 Reconhecer as funcionalidades de frameworks e bibliotecas para gerenciamento de banco
de dados
CONCEITOS
CONECTORES PARA BANCO DE DADOS
/
Quando estamos trabalhando com banco de dados, precisamos pesquisar por bibliotecas que
possibilitem a conexão da aplicação com o banco de dados que iremos utilizar.
Na área de banco de dados, essas bibliotecas se chamam conectores ou adaptadores.
 Figura: 1.
Como estamos trabalhando com Python, devemos procurar por conectores que atendam a
PEP 249 (Python Database API Specification v2.0 - DB-API 2.0) .
Essa PEP (Python Enhancement Proposal) especifica um conjunto de padrões que os
conectores devem seguir, a fim de garantir um melhor entendimento dos módulos e maior
portabilidade entre bancos de dados.
Como exemplo de padrões definidos pela DB-API 2.0, podemos citar:
Nomes de métodos:
close, commit e cursor
Nomes de Classes:
Connection e Cursor
Tipos de exceção:
IntegrityError e InternalError
Como exemplo de conectores que implementam a DB-API 2.0, temos:
psycopg2: Conector mais utilizado para o banco de dados PostgreSQL.
mysqlclient, PyMySQL e mysql-connector-python: Conectores para o banco de dados
MySQL.
/
sqlite3: Adaptador padrão do Python para o banco de dados SQLite.
 COMENTÁRIO
Apenas o conector para SQLite está disponível nativamente no Python 3.7. Todos os demais
precisam ser instalados.
Como dito na introdução, neste tema, utilizaremos o banco de dados SQLite para demonstrar o
desenvolvimento de aplicações Python para bancode dados.
Apesar do nome Lite (leve) , o SQLite é um banco de dados completo, que permite a criação
de tabelas, relacionamentos, índices, gatilhos (trigger) e visões (views) .
O SQLite também tem suporte a subconsultas, transações, junções, pesquisa em texto (full text
search), restrições de chave estrangeira, entre outras funcionalidades.
Porém, por não ter um servidor para seu gerenciamento, o SQLite não provê um acesso direto
pela rede. As soluções existentes para acesso remoto são “caras” e ineficientes.
Além disso, o SQLite não tem suporte à autenticação, com usuários e permissões definidas.
Estamos falando aqui sobre usuários do banco de dados, que têm permissão para criar tabela,
inserir registros etc.
Observe que, apesar do SQLite não ter suporte à autenticação, podemos e devemos
implementar nosso próprio controle de acesso para nossa aplicação.
PRINCIPAIS MÉTODOS DOS CONECTORES
EM PYTHON
Antes de começarmos a trabalhar diretamente com banco de dados, precisamos conhecer
algumas classes e métodos disponibilizados pelos conetores e previstos na PEP 249.
Esses métodos são a base para qualquer aplicação que necessite de acesso a banco de dados
e estão descritos a seguir:
CONNECT
/
Função global do conector para criar uma conexão com o banco de dados.
Retorna um objeto do tipo Connection.
CONNECTION
Classe utilizada para gerenciar todas as operações no banco de dados.
Principais métodos:
commit: Confirma todas as operações pendentes;
rollback: Desfaz todas as operações pendentes;
cursor: Retorna um objeto do tipo Cursor; e
close: Encerra a conexão com o banco de dados.
CURSOR
Classe utilizada para enviar os comandos ao banco de dados.
Principais métodos:
execute: Prepara e executa a operação passada como parâmetro;
fetchone: Retorna a próxima linha encontrada por uma consulta; e
fetchall: Retorna todas as linhas encontradas por uma consulta.
A utilização desses métodos segue basicamente o mesmo fluxo de trabalho para todas as
aplicações que utilizam banco de dados. A seguir, vamos descrever esse fluxo:
Criar uma conexão com o banco de dados utilizando a função connect.
Utilizar a conexão para criar um cursor, que será utilizado para enviar comandos ao banco de
dados.
Utilizar o cursor para enviar comandos ao banco de dados, por exemplo:
/
Criar tabelas.
Inserir linhas.
Selecionar linhas.
Efetivar as mudanças no banco de dados utilizando o método commit da conexão.
Fechar o cursor e a conexão
Observe os scripts a seguir na Figura 2, na qual temos esse fluxo de trabalho descrito na forma
de código Python.
 
Fonte: O Autor
 Figura: 2
Neste momento, vamos focar apenas no script1, mais à esquerda da figura.
Na primeira linha, importamos o módulo sqlite3, conector para o banco de dados SQLite
disponível nativamente no Python 3.7. Atribuímos um alias (apelido) a esse import chamado
conector. Veremos ao final por que criamos esse alias.
Na linha 4, abrimos uma conexão com o banco de dados utilizando uma URL. O retorno dessa
conexão é um objeto da classe Connection, que foi atribuído à variável conexao.
Na linha 7, utilizamos o método cursor da classe Connection para criar um objeto do tipo
Cursor, que foi atribuído à variável cursor.
Na linha 10, utilizamos o método execute, da classe Cursor. Este método permite enviar
comandos SQL para o banco de dados. Entre os comandos, podemos citar: SELECT, INSERT
e CREATE.
Na linha 11, usamos o método fetchall, da classe Cursor, que retorna os resultados de uma
consulta.
/
Na linha 14, utilizamos o método commit, da classe Connection, para efetivar todos os
comandos enviados anteriormente. Se desejássemos desfazer os comandos, poderíamos
utilizar o método rollback.
Nas linhas 17 e 18, fechamos o cursor e a conexão, respectivamente.
A estrutura apresentada irá se repetir ao longo deste tema, onde, basicamente, preencheremos
o parâmetro do método execute com o comando SQL pertinente.
 ATENÇÃO
Agora observe os scripts 2 e 3 da Figura 2. e veja que ambas as bibliotecasmysql.connector e
psycopg2 contêm os mesmos métodos e funções da biblioteca sqlite3.
Como estamos utilizando o alias conector no import, para trocar de banco de dados,
bastaria apenas alterar o import da primeira linha. Isso se deve ao fato de que todas elas
seguem a especificação DB-API 2.0.
Cada biblioteca tem suas particularidades, que podem adereçar alguma funcionalidade
específica do banco de dados referenciado, mas todas elas implementam, da mesma
maneira, o básico para se trabalhar com banco de dados.
Isso é de grande utilidade, pois podemos alterar o banco de dados a qualquer momento,
sem a necessidade de realizar muitas alterações no código-fonte.
Mais adiante, mostraremos algumas situações onde as implementações podem diferir
entre os conectores.
PRINCIPAIS EXCEÇÕES DOS
CONECTORES EM PYTHON
Além dos métodos, a DB-API 2.0 prevê algumas exceções que podem ser lançadas pelos
conectores.
Vamos listar e explicar algumas dessas exceções:
Error IntegrityError OperationalError
javascript:void(0)
javascript:void(0)
javascript:void(0)
/
DatabaseError ProgrammingError NotSupportedError
 Atenção! Para visualizaçãocompleta da tabela utilize a rolagem horizontal
ERROR
Classe base para as exceções. É a mais abrangente.
DATABASEERROR
Exceção para tratar erros relacionados ao banco de dados. Também é uma exceção
abrangente. É uma subclasse de Error.
INTEGRITYERROR
Exceção para tratar erros relacionados à integridade do banco de dados, como
falha na checagem de chave estrangeira e falha na checagem de valores únicos. É
uma subclasse de DatabaseError.
PROGRAMMINGERROR
javascript:void(0)
javascript:void(0)
javascript:void(0)
/
Exceção para tratar erros relacionados à programação, como sintaxe incorreta do
comando SQL, tabela não encontrada etc. É uma subclasse de DatabaseError.
OPERATIONALERROR
Exceção para tratar erros relacionados a operações no banco de dados, mas que
não estão sob controle do programador, como desconexão inesperada. É uma
subclasse de DatabaseError.
NOTSUPPORTEDERROR
Exceção para tratar erros relacionados a operações não suportadas pelo banco de
dados, como chamar o método rollback em um banco de dados que não suporta
transações. É uma subclasse de DatabaseError.
TIPOS DE DADOS
Cada dado armazenado em um banco de dados contém um tipo, como inteiro, texto,
ponto flutuante, entre outros.
Os tipos suportados pelos bancos de dados não são padronizados e, por isso, é
necessário verificar na sua documentação quais tipos são disponibilizados.
O SQLite trata os dados armazenados de um modo um pouco diferente de outros
bancos, nos quais temos um número limitado de tipos.
No SQLite, cada valor armazenado no banco é de uma das classes a seguir:
/
NULL Para valores nulos.
INTEGER Para valores que são números inteiros, com sinal.
REAL Para valores que são números de ponto flutuante.
TEXT Para valores que são texto (string).
BLOB
Para armazenar valores exatamente como foram inseridos, ex.
bytes.
 Atenção! Para visualização completa da tabela utilize a rolagem horizontal
Apesar de parecer um número limitado de classes, quando comparado com outros
bancos de dados, o SQLite suporta o conceito de afinidades de tipo para as colunas.
AFINIDADES DE TIPO
Afinidade é a classe preferida para se armazenar um dado em uma determinada
coluna.
No SQLite, quando definimos uma coluna durante a criação de uma tabela, ao invés de
especificar um tipo estático, dizemos qual a afinidade dela. Isso nos permite armazenar
diferentes tipos de dados em uma mesma coluna. Observe as afinidades disponíveis a
seguir:
TEXT Coluna para armazenar dados das classes NULL, TEXT e BLOB.
javascript:void(0)
/
NUMERIC Coluna para armazenar dados de qualquer uma das cinco classes.
INTEGER
Similar ao NUMERIC, diferenciando apenas no processo de
conversão de valores.
REAL
Similar ao NUMERIC, porém os valores inteiros são forçados a
serem representados como ponto flutuante.
NONE
Coluna sempreferência de armazenamento, não é realizada
nenhuma conversão de valores.
 Atenção! Para visualização completa da tabela utilize a rolagem horizontal
A afinidade também permite ao motor do SQLite fazer um mapeamento entre tipos não
suportados e tipos suportados. Por exemplo, o tipo VARCHAR(n), disponível no MySQL
e PostgreSQL, é convertido para TEXT no SQLite.
Esse mapeamento nos permite definir atributos no CREATE TABLE com outros tipos,
não suportados pelo SQLite. Esses tipos são convertidos para tipos conhecidos
utilizando afinidade.
A tabela de afinidades do SQLite está descrita a seguir:
Tipo no CREATE TABLE Afinidade
INT 
INTEGER 
TINYINT 
SMALLINT 
MEDIUMINT 
BIGINT 
UNSIGNED BIG INT 
INTEGER
/
INT2 
INT8
CHARACTER(20) 
VARCHAR(255) 
VARYING CHARACTER(255) 
NCHAR(55) 
NATIVE CHARACTER(70) 
NVARCHAR(100) 
TEXT 
CLOB
TEXT
BLOB BLOB
REAL 
DOUBLE 
DOUBLE PRECISION 
FLOAT
REAL
NUMERIC 
DECIMAL(10,5) 
BOOLEAN
DATE 
DATETIME
NUMERIC
 Atenção! Para visualizaçãocompleta da tabela utilize a rolagem horizontal
A partir desta tabela, mesmo utilizando o SQLite para desenvolvimento, podemos definir
os atributos de nossas tabelas com os tipos que utilizaremos em ambiente de produção.
/
VERIFICANDO O APRENDIZADO
1. NESTE MÓDULO, APRENDEMOS SOBRE AS BIBLIOTECAS PARA
ACESSO A BANCO DE DADOS EM PYTHON. VIMOS QUE AS PRINCIPAIS
BIBLIOTECAS IMPLEMENTAM A PEP 249, QUE PROPÕE PADRÕES QUE
DEVEM SER SEGUIDOS POR ESSAS BIBLIOTECAS. 
CONSIDERANDO AS CLASSES E MÉTODOS PROPOSTOS NA PEP 249,
MARQUE A ALTERNATIVA CORRETA QUE COMPLETA A SEGUINTE
AFIRMAÇÃO: 
A FUNÇÃO GLOBAL ______________ DEVE SER UTILIZADA PARA CRIAR
/
UMA CONEXÃO COM O BANCO DE DADOS. ESSA FUNÇÃO RETORNA
UM OBJETO DO TIPO ______________, QUE É UTILIZADO PARA CRIAR
UM OBJETO DO TIPO ______________ UTILIZANDO O MÉTODO
________________.
A) connect – Connection – Cursor – cursor
B) execute – Connection – cursor – Cursor
C) Connection – connection – cursor – Cursor
D) connect – Execute – Cursor – cursor
2. SOBRE O BANCO DE DADOS SQLITE E SEU CONECTOR SQLITE3
PARA PYTHON, ASSINALE A ALTERNATIVA CORRETA:
A) Mesmo não tendo um servidor para seu gerenciamento, o SQLite provê acesso direto
e otimizado pela rede.
B) O sqlite3 não permite criar colunas com tipos diferentes de TEXT, NUMERIC, INTEGER
e REAL.
C) No SQLite, os dados de uma mesma coluna podem ser de tipos diferentes.
D) O sqlite3 não implementa a DB API 2.0.
GABARITO
1. Neste módulo, aprendemos sobre as bibliotecas para acesso a banco de dados em
Python. Vimos que as principais bibliotecas implementam a PEP 249, que propõe
padrões que devem ser seguidos por essas bibliotecas. 
Considerando as classes e métodos propostos na PEP 249, marque a alternativa correta
que completa a seguinte afirmação: 
A função global ______________ deve ser utilizada para criar uma conexão com o banco
de dados. Essa função retorna um objeto do tipo ______________, que é utilizado para
criar um objeto do tipo ______________ utilizando o método ________________.
A alternativa "A " está correta.
 
/
Os programas que precisam se conectar a um banco de dados que utiliza bibliotecas
que seguem a PEP, normalmente seguem o mesmo fluxo de desenvolvimento. A função
global connect da biblioteca deve ser utilizada para criar um objeto do tipo Connect. O
método cursor da classe Connect retorna um objeto do tipo Cursor, que é utilizado para
enviar comandos ao banco de dados.
2. Sobre o banco de dados SQLite e seu conector sqlite3 para Python, assinale a
alternativa correta:
A alternativa "C " está correta.
 
A afinidade definida no SQLite indica a classe preferida para o armazenamento dos
dados de uma determinada coluna, porém, diferente de outros bancos de dados,
podemos ter dados de classes diversas em uma mesma coluna.
MÓDULO 2
 Empregar as funcionalidades para conexão, acesso e criação de bancos de dados e
tabelas
CONCEITOS
CONECTANDO A UM BANCO DE DADOS
Neste módulo, vamos aprender a criar e a conectar-se a um banco de dados, criar e
editar tabelas e seus relacionamentos.
/
 
Fonte: Shutterstock
Como o SQLite trabalha com arquivo e não tem suporte à autenticação, para se conectar
a um banco de dados SQLite, basta chamar a função connect do módulo sqlite3,
passando como argumento o caminho para o arquivo que contém o banco de dados.
Veja a sintaxe a seguir:
>>> import sqlite3 
>>> conexao = sqlite3.connect('meu_banco.db') 
Pronto! Isso é o suficiente para termos uma conexão com o banco de dados
meu_banco.db e iniciar o envio de comandos SQL para criar tabelas e inserir registros.
Caso o arquivo não exista, ele será criado automaticamente! O arquivo criado pode ser
copiado e compartilhado.
Se quisermos criar um banco de dados em memória, que será criado para toda execução
do programa, basta utilizar o comando conexao = sqlite3.connect(':memory:').
CRIANDO TABELAS
Agora que já sabemos como criar e se conectar a um banco de dados SQLite, vamos
começar a criar nossas tabelas.
/
Antes de colocarmos a mão na massa, vamos verificar o nosso modelo entidade
relacionamento (ER) que utilizaremos para criar nossas tabelas neste primeiro momento.
Veja o modelo na Figura 3.
 
Fonte: O Autor
 Figura: 3.
Nosso modelo é composto por três entidades: Pessoa, Veiculo e Marca.
Nossa primeira entidade se chama Pessoa e contém os atributos: 
- cpf, como chave primária; 
- nome; 
- nascimento, para armazenar a data de nascimento da pessoa; e 
- oculos, que indica se a pessoa precisa usar óculos.
A segunda entidade se chama Marca, que contém os atributos: 
- id, como chave primária, 
- nome; e 
- sigla.
Nossa terceira e última entidade se chama Veiculo, que contém os atributos: 
- placa, como chave primária; 
- cor; 
- proprietario, que é uma referência à pessoa dona do veículo; e 
- marca, referência à marca do veículo.
Para os relacionamentos do nosso modelo, uma pessoa pode ter zero, um ou mais
veículos e um veículo só pode ter um proprietário. Uma marca pode estar em zero, um
ou mais veículos e um veículo só pode ter uma marca.
Agora que já temos nosso modelo ER, precisamos definir os tipos de cada atributo das
nossas entidades. Como estamos trabalhando com SQLite, precisamos ter em mente a
tabela de afinidades disponibilizada no módulo anterior.
/
Vamos definir a nossa entidade Pessoa, de forma que os atributos tenham os seguintes
tipos e restrições:
CPF INTEGER (chave primária, não nulo)
NOME TEXT (não nulo)
NASCIMENTO DATE (não nulo)
OCULOS BOOLEAN (não nulo)
 Atenção! Para visualização completa da tabela utilize a rolagem horizontal
Para criar uma tabela que represente essa entidade, vamos utilizar o comando SQL:
CREATE TABLE Pessoa ( 
cpf INTEGER NOT NULL, 
nome TEXT NOT NULL, 
nascimento DATE NOT NULL, 
oculos BOOLEAN NOT NULL, 
PRIMARY KEY (cpf) 
); 
Observe pela nossa tabela de afinidades, que os tipos DATE e BOOLEAN serão
convertidos por afinidade para NUMERIC. Na prática, os valores do tipo DATE serão da
classe TEXT e os do tipo BOOLEAN da classe INTEGER, pois armazenaremos os valores
True como 1 e False como 0.
Definido o comando SQL, vamos ver como criar essa tabela em Python no exemplo da
Figura 4 a seguir.
/
 
Fonte: O Autor
 Figura: 4.
Na linha 1, importamos o módulo sqlite3 e atribuímos o alias conector.
Observe que envolvemos todo o nosso código com a cláusula try/catch, capturando as
exceções do tipo DatabaseError.
Na linha 5, criamos uma conexão com o banco de dados meu_banco.db. Caso esse
arquivo não exista, será criado um arquivo no mesmo diretório do script sendo
executado.
Na linha 6, criamos um cursor para executar as operações no nosso banco.
Nas linhas 9 a 15, definimos a variável comando, que é uma string contendo o comando
SQL para criação da nossa tabela Pessoa.
Na linha 17, utilizamos o método execute do cursor para executar o comando SQL
passado como argumento.
Na linha 19, efetivamos a transação pendente utilizando o métodocommit da variável
conexão. Nesse caso, a transação pendente é a criação da tabela.
Nas linhas 22 e 23, capturamos e tratamos a exceção DatabaseError.
Nas linhas 28 e 29 fechamos o cursor e a conexão na cláusula finally, para garantir que
nenhuma conexão fique aberta em caso de erro.
/
Observe como ficou a árvore de diretórios à esquerda da figura após a execução do
programa. Veja que agora temos o arquivo meu_banco.db.
 ATENÇÃO
Nos exemplos ao longo deste tema, vamos utilizar a mesma estrutura de código do
script anterior, porém, vamos omitir as cláusulas try/catch para fins de brevidade.
Agora vamos tratar de nossa próxima entidade, Marca. Vamos defini-la de forma que os
atributos tenham os seguintes tipos e restrições:
id INTEGER (chave primária, não nulo)
nome TEXT (não nulo)
sigla CHARACTER (não nulo, tamanho 2)
 Atenção! Para visualização completa da tabela utilize a rolagem horizontal
A codificação latin-1, muito utilizada no Brasil, utiliza um byte por caractere. Como a
sigla da marca será composta por 2 caracteres, nosso atributo sigla terá tamanho 2
(CHAR(2) ou CHARACTER(2)).
Para criar uma tabela que represente essa entidade, vamos utilizar o comando SQL:
CREATE TABLE Marca ( 
id INTEGER NOT NULL, 
nome TEXT NOT NULL, 
sigla CHARACTER(2) NOT NULL, 
PRIMARY KEY (id) 
); 
Pela tabela de afinidades, o tipo CHARACTER(2) será convertido para TEXT.
Confira a imagem a seguir, Figura 5, para verificar como ficou o script de criação dessa
tabela.
/
 
Fonte: O Autor
 Figura: 5.
Após a criação da conexão e do cursor, linhas 4 e 5, definimos uma string com o
comando SQL para criação da tabela Marca, linhas 8 a 13.
O comando foi executado na linha 15 e efetivado na linha 18.
Nas linhas 21 e 22, fechamos o cursor e a conexão.
A próxima entidade a ser criada será a entidade Veiculo. Os seus atributos terão os
seguintes tipos e restrições.
PLACA CHARACTER (chave primária, não nulo, tamanho 7)
ANO INTEGER (não nulo)
COR TEXT (não nulo)
PROPRIETÁRIO INTEGER (chave estrangeira, não nulo)
/
MARCA INTEGER (chave estrangeira, não nulo)
 Atenção! Para visualização completa da tabela utilize a rolagem horizontal
Como nossas placas são compostas por 7 caracteres, nosso atributo placa terá tamanho
7 (CHAR(7) ou CHARACTER(7)). Por afinidade, ele será convertido para TEXT.
O atributo proprietario será utilizado para indicar um relacionamento da entidade Veiculo
com a entidade Pessoa. O atributo da tabela Pessoa utilizado no relacionamento será o
CPF. Como o CPF é um INTEGER, o atributo relacionado proprietario também precisa ser
INTEGER.
Analogamente, o atributo marca será utilizado para indicar um relacionamento da
entidade Veiculo com a entidade Marca, por meio do atributo id da tabela Marca, que
também é um INTEGER.
Veja o comando SQL a seguir para criar a tabela Veiculo e o relacionamento com as
tabelas Pessoa e Marca.
CREATE TABLE Veiculo ( 
placa CHARACTER(7) NOT NULL, 
ano INTEGER NOT NULL, 
cor TEXT NOT NULL, 
proprietario INTEGER NOT NULL, 
marca INTEGER NOT NULL, 
PRIMARY KEY (placa), 
FOREIGN KEY(proprietario) REFERENCES Pessoa(cpf), 
FOREIGN KEY(marca) REFERENCES Marca(id) 
);
Definido o comando SQL, vamos ver como criar essa tabela em Python no exemplo da
Figura 6 a seguir.
/
 
Fonte: O Autor
 Figura: 6.
Este script também segue os mesmos passos do script anterior até a linha 8, onde
definimos a string com o comando SQL para criação da tabela Veiculo.
Esse comando foi executado na linha 19 e efetivado na linha 22.
 DICA
Caso a referência da chave estrangeira seja feita a um atributo inexistente, será lançado
um erro de programação: ProgrammingError.
Para visualizar como ficaram nossas tabelas, vamos utilizar o programa DB Browser for
SQLite.
Após abrir o programa DB Browser for SQLite, basta clicar em Abrir banco de dados e
selecionar o arquivo meu_banco.db. Observe a Figura 7 a seguir.
/
 
Fonte: O Autor
 Figura: 7.
Observe que está tudo conforme o previsto, inclusive a ordem dos atributos obedece a
sequência na qual foram criados.
ALTERAÇÃO E REMOÇÃO DE TABELA
Neste momento, temos o nosso banco com as três tabelas exibidas no modelo ER da
Figura 3.
Durante o desenvolvimento, pode ser necessário realizar alterações no nosso modelo e,
consequentemente, nas nossas tabelas. Nesta parte do módulo, vamos ver como
podemos fazer para adicionar um novo atributo e como fazemos para remover uma
tabela.
Para alterar uma tabela e adicionar um novo atributo, precisamos utilizar o comando
ALTER TABLE do SQL.
Para ilustrar, vamos adicionar mais um atributo à entidade Veiculo.
O atributo se chama motor e corresponde à motorização do carro: 1.0, 1.4, 2.0 etc. Esse
atributo deverá conter pontos flutuantes e, por isso, vamos defini-lo como do tipo REAL.
Para alterar a tabela Veículo e adicionar a coluna motor, utilizamos o seguinte comando
SQL.
/
ALTER TABLE Veiculo 
ADD motor REAL; 
Confira o script da Figura 8, onde realizamos a alteração da tabela Veiculo.
 
Fonte: O Autor
 Figura: 8.
Após se conectar ao banco e obter um cursor, linhas 4 e 5, construímos uma string com
o comando ALTER TABLE nas linhas 8 e 9.
Na linha 11, executamos o comando e na linha 14 efetivamos a modificação.
Nas linhas 17 e 18, fechamos o cursor e a conexão.
Observe como ficou nossa tabela após a criação da nova coluna.
/
 
Fonte: O Autor
 Figura: 9.
Veja, pela Figura 9, que o atributo motor foi adicionado ao final da entidade, obedecendo
a ordem de criação.
 EXEMPLO
Em algumas situações, pode ser necessário que as colunas sigam uma ordem
predeterminada. Um exemplo é quando precisamos carregar os dados de uma planilha
diretamente para um banco de dados, para realizarmos o chamado bulk insert (inserção
em massa). Nesses casos, as colunas da planilha precisam estar na mesma sequência
das colunas do banco.
Como nem todos os bancos de dados, incluindo o SQLite, dão suporte à criação de
colunas em posição determinada, vamos precisar remover nossa tabela para recriá-la
com os atributos na posição desejada.
Para o nosso exemplo, desejamos a seguinte sequência: placa, ano, cor, motor,
proprietario e marca.
No exemplo da Figura 10, vamos remover a tabela Veiculo, utilizando o comando DROP
TABLE do SQL e, posteriormente, vamos criá-la novamente com a sequência desejada.
Para remover a tabela Veiculo, utilizamos o seguinte comando SQL.
DROP TABLE Veiculo; 
/
Para recriar a tabela, utilizamos o seguinte comando SQL:
CREATE TABLE Veiculo ( 
placa CHARACTER(7) NOT NULL, 
ano INTEGER NOT NULL, 
cor TEXT NOT NULL, 
motor REAL NOT NULL, 
proprietario INTEGER NOT NULL, 
marca INTEGER NOT NULL, 
PRIMARY KEY (placa), 
FOREIGN KEY(proprietario) REFERENCES Pessoa(cpf), 
FOREIGN KEY(marca) REFERENCES Marca(id) 
); 
Confira como ficou nosso script na Figura 10 a seguir:
 
Fonte: O Autor
 Figura: 10.
Após se conectar ao banco e obter o cursor, criamos a string comando1 com o comando
para remover a tabela Veiculo, na linha 8. Na linha 10, executamos esse comando.
Nas linhas 12 a 22, criamos o comando para criar novamente a tabela Veiculo com os
atributos na ordem mostrada anteriormente e, na linha 24, executamos esse comando.
/
Na linha 27, efetivamos todas as modificações pendentes, tanto a remoção da tabela,
quanto a criação. Observe que não é preciso efetuar um commit para cada comando!
Nas linhas 30 e 31, liberamos o cursor e fechamos a conexão.
Chegamos ao final do módulo 2 e agora nosso modelo ER está conforme a Figura 11 a
seguir:
 
Fonte: O Autor
 Figura: 11.
 SAIBA MAIS
Algumas bibliotecas de acesso a banco de dados oferecem uma funcionalidade
chamada mapeamento objeto-relacional, do inglês object-relational mapping (ORM).
ORM
ORM (Object Relational Mapper) é uma mapeamento objeto-relacional, isto é uma
técnica de mapeamento objeto relacional que permite fazer uma relação dos
objetos com os dados que os mesmos representam.
Esse mapeamento permite associar classesdefinidas em Python com tabelas em banco
de dados, onde cada objeto dessas classes corresponde a um registro da tabela.
Os comandos SQL de inserções e consultas são todos realizados por meio de métodos,
não sendo necessário escrever o comando SQL em si. Os ORM nos permitem trabalhar
com um nível mais alto de abstração.
Como exemplo dessas bibliotecas, podemos citar SQLAlchemy e Peewee.
javascript:void(0)
/
Visite as páginas dessas bibliotecas e veja como elas facilitam a manipulação de
registros em banco de dados.
No próximo módulo, vamos mostrar como inserir e atualizar os dados em uma tabela.
VERIFICANDO O APRENDIZADO
1. CONSIDERE QUE PRECISAMOS ESCREVER UM PROGRAMA PARA SE
CONECTAR A UM BANCO DE DADOS RELACIONAL E CRIAR A
ENTIDADE CIDADE, COM OS ATRIBUTOS A SEGUIR:
/
ID: INTEIRO, NÃO NULO
NOME: TEXTO
ESTADO: TEXTO
DADO QUE UTILIZAMOS O CONECTOR SQLITE3, SELECIONE O SCRIPT
QUE EXECUTA TODAS AS OPERAÇÕES NECESSÁRIAS
CORRETAMENTE: 
 
FONTE: O AUTOR
A) script atividade2-a.py
B) script atividade2-b.py
C) script atividade2-c.py
D) script atividade2-d.py
2. CONSIDERE O SCRIPT A SEGUIR, ONDE CRIAMOS AS TABELAS
PRODUTO E ARREMATE E O RELACIONAMENTO ENTRE ELAS. 
/
 
FONTE: O AUTOR
MARQUE A ALTERNATIVA QUE CORRESPONDE ÀS TABELAS CRIADAS
PELO SCRIPT.
A) 
Fonte: O autor
B) 
Fonte: O autor
/
C) 
Fonte: O autor
D) 
Fonte: O autor
GABARITO
1. Considere que precisamos escrever um programa para se conectar a um banco de
dados relacional e criar a entidade Cidade, com os atributos a seguir:
id: inteiro, não nulo
nome: texto
estado: texto
Dado que utilizamos o conector sqlite3, selecione o script que executa todas as
operações necessárias corretamente: 
/
 
Fonte: O Autor
A alternativa "C " está correta.
 
No script (c) temos todos os passos necessários para criar uma tabela. Primeiro, é
necessário criar uma conexão (linha 3) e, em seguida, um cursor (linha 4). Na sequência,
precisamos definir o comando SQL de criar tabela (linhas 6 a 10) e utilizar o cursor para
executar esse comando (linha 12). Após a execução do comando, precisamos efetivar a
transação utilizando o método commit da conexão (linha 13). Posteriormente, fechamos
o cursor e então fechamos a conexão.
2. Considere o script a seguir, onde criamos as tabelas Produto e Arremate e o
relacionamento entre elas. 
/
 
Fonte: O Autor
Marque a alternativa que corresponde às tabelas criadas pelo script.
A alternativa "B " está correta.
 
O script cria, inicialmente, a tabela Produto, com os atributos: codigo e nome (linhas 5 a
8). Posteriormente, alteramos a tabela para criar mais dois atributos: descricao,
preco_inicial (linhas 18 e 19). A tabela Arremate foi criada inicialmente com os atributos
id, data e cod_prod (linhas 11 a 15) e posteriormente foi adicionado o atributo
lance_vencedor (linha 20). Lembre-se de que o SQLite obedece à ordem de criação dos
atributos. A única opção que contém todos os atributos ordenados é a opção b.
MÓDULO 3
 Aplicar as funcionalidades para inserção, remoção e atualização de registros em
tabelas
CONCEITOS
/
INSERÇÃO DE DADOS EM TABELA
Neste módulo, vamos aprender a inserir, alterar e remover registros de tabelas. Para
inserir registros em uma tabela, utilizamos o comando INSERT INTO, do SQL.
Para ilustrar a utilização desse comando, vamos inserir o seguinte registro na tabela
Pessoa.
CPF: 12345678900
Nome: João
Data de Nascimento: 31/01/2000
Usa óculos: Sim (True)
O Comando SQL para inserção desses dados é o seguinte:
INSERT INTO Pessoa (cpf, nome, nascimento, oculos) 
VALUES (12345678900, 'João', '2000-01-31', 1); 
Observe que alteramos a formatação da data para se adequar ao padrão de alguns
bancos de dados, como MySQL e PostgreSQL. Para o SQLite será indiferente, pois o tipo
DATE será convertido por afinidade para NUMERIC, que pode ser de qualquer classe. Na
prática, será convertido para classe TEXT.
Além disso, utilizamos o valor “1” para representar o booleano True. Assim como o
DATE, o BOOLEAN será convertido para NUMERIC, porém, na prática, será convertido
para classe INTEGER.
Confira como ficou o script para inserção dos dados, Figura 12.
/
 
Fonte: O Autor
 Figura: 12.
Após se conectar ao banco e obter o cursor, criamos a string com o comando para
inserir um registro na tabela Pessoa nas linhas 8 e 9.
Na linha 11, executamos esse comando com a execução do commit na linha 14.
Ao final do script, fechamos o cursor e a conexão.
Observe na figura 13 como ficou nossa tabela pelo DB Browser for SQLite.
 
Fonte: O Autor
 Figura: 13.
/
INSERÇÃO DE DADOS EM TABELA COM
QUERIES DINÂMICAS
É muito comum reutilizarmos uma mesma string para inserir diversos registros em uma
tabela, alterando apenas os dados a serem inseridos.
Para realizar esse tipo de operação, o método execute, da classe Cursor, prevê a
utilização de parâmetros de consulta, que é uma forma de criar comandos SQL
dinamicamente.
 COMENTÁRIO
De uma forma geral, as APIs sqlite3, psycopg2 e PyMySQL fazem a concatenação da
string e dos parâmetros antes de enviar ao banco de dados.
Essa concatenação é realizada de forma correta, evitando brechas de segurança, como
SQL Injection, e convertendo os dados para os tipos e formatos esperados pelo banco
de dados.
Como resultado final, temos um comando pronto para ser enviado ao banco de dados.
Para indicar que a string de um comando contém parâmetros que precisam ser
substituídos antes da sua execução, utilizamos delimitadores. Esses delimitadores
também estão previstos na PEP 249 e podem ser: “?”, “%s”, entre outros.
Na biblioteca do SQLite, utilizamos o delimitador “?”.
Para ilustrar a utilização do delimitador “?” em SQLite, considere o comando a seguir:
>>> comando = “INSERT INTO tabela1 (atributo1, atributo2) VALUES (?, ?);” 
Esse comando indica que, ao ser chamado pelo método execute, devemos passar dois
parâmetros, um para cada interrogação. Esses parâmetros precisam estar em um
iterável, como em uma tupla ou lista.
Veja a seguir como poderia ficar a chamada do método execute para esse comando:
>>> cursor.execute(comando, (“Teste”, 123)) 
A partir da string e da tupla, é montado o comando final, que é traduzido para:
/
“INSERT INTO tabela1 (atributo1, atributo2) VALUES (‘Teste’, 123);” 
A concatenação é feita da forma correta para o banco de dados em questão, aspas
simples para textos e números sem aspas.
No exemplo a seguir, vamos detalhar a utilização de parâmetros dinâmicos, porém,
antes, vamos definir uma classe chamada Pessoa, com os mesmos atributos da nossa
entidade Pessoa.
 
autor
A definição dessa classe pode ser vista no script modelo.py. Foi retirado a referência
para a figura.
 
autor
Observe que temos os mesmos atributos que a entidade equivalente, mas com nomes
diferentes. Fizemos isso para facilitar o entendimento dos exemplos deste módulo.
Confira agora o script10.
javascript:void(0)
javascript:void(0)
/
Primeiro, importamos o conector na linha 1 e, na linha 2, importamos a classe Pessoa.
Ela será utilizada para criar um objeto do tipo Pessoa.
Nas linhas 5 e 6, conectamos ao banco de dados e criamos um cursor.
Na linha 9, utilizamos o construtor da classe Pessoa para criar um objeto com os
seguintes atributos: CPF: 10000000099, Nome: Maria, Data de Nascimento: 31/01/1990 e
Usa óculos: Não (False). O valor False será convertido para 0 durante a execução do
método execute.
Na linha 12, definimos a string que conterá o comando para inserir um registro na tabela
Pessoa. Observe como estão representados os valores dos atributos! Estão todos com o
delimitador representado pelo caractere interrogação (?)!
Como dito anteriormente, isso serve para indicar ao método execute que alguns
parâmetros serão fornecidos, a fim de substituir essas interrogações por valores.
Na linha 13, chamamos o método execute utilizando, como segundo argumento, uma
tupla com os atributos do objeto pessoa. Cada elemento dessa tupla irá ocupar o lugarde uma interrogação, respeitando a ordem com que aparecem na tupla.
O comando final enviado ao banco de dados pelo comando execute foi:
INSERT INTO Pessoa (cpf, nome, nascimento, oculos) 
VALUES (10000000099, 'Maria', '1990-01-31', 0); 
Na linha 16, efetivamos o comando utilizando o método commit.
Nas linhas 18 e 19, fechamos o cursor e a conexão.
 DICA
Nem todos os conectores utilizam o mesmo caractere como delimitador. Os conectores
psycopg2, do PostgreSQL, e PyMySQL, do MySQL, utilizam o “%s”. É necessário ver a
documentação de cada conector para verificar o delimitador correto!
INSERÇÃO DE DADOS EM TABELA COM
QUERIES DINÂMICAS E NOMES
/
Além da utilização do caractere “?” como delimitador de parâmetros, o sqlite3 também
possibilita a utilização de argumentos nomeados.
A utilização de argumentos nomeados funciona de forma similar à chamada de funções
utilizando os nomes dos parâmetros.
Nessa forma de construção de queries dinâmicas, ao invés de passar uma tupla,
devemos passar um dicionário para o método execute. Ele será utilizado para preencher
corretamente os valores dos atributos.
A utilização de argumentos nomeados nos permite utilizar argumentos sem a
necessidade de manter a ordem.
Para ilustrar a utilização dos argumentos nomeados em SQLite, considere o comando a
seguir:
>>> comando = INSERT INTO tabela1 (atributo1, atributo2) VALUES (:atrib1, :atrib2); 
Esse comando indica que ao ser chamado pelo método execute, devemos passar um
dicionário com duas chaves, sendo uma “atrib1” e outra “atrib2”. Observe que há dois
pontos (“:”) antes do argumento nomeado!
Veja a seguir como poderia ficar a chamada do método execute para esse comando:
>>> cursor.execute(comando, {“atrib1”:“Teste”, “atrib2”: 123}) 
A partir da string e do dicionário é montado o comando final, que é traduzido para:
INSERT INTO tabela1 (atributo1, atributo2) VALUES (‘Teste’, 123); 
Observe o exemplo da Figura 14, onde vamos criar um script similar ao anterior, no qual
vamos utilizar novamente a classe Pessoa, porém o comando para inserir um registro no
banco de dados utiliza os argumentos nomeados.
/
 
Fonte: O Autor
 Figura: 14.
Nas linhas 5 e 6, conectamos ao banco de dados e criamos um cursor.
Na linha 9, utilizamos o construtor da classe Pessoa para criar um objeto com os
seguintes atributos: CPF: 20000000099, Nome: José, Data de Nascimento: 28/02/1990 e
Usa óculos: Não (False).
Nas linhas 12 e 13, definimos a string que conterá o comando para inserir um registro na
tabela Pessoa. Observe os nomes dos argumentos nomeados: cpf, nome,
data_nascimento e usa_oculos. Cada um desses nomes deve estar presente no
dicionário passado para o método execute!
Na linha 14, chamamos o método execute utilizando, como segundo argumento, um
dicionário com os atributos do objeto pessoa, definido na linha 10. Cada argumento
nomeado do comando será substituído pelo valor da chave correspondente do
dicionário.
O comando final enviado ao banco de dados pelo comando execute foi:
INSERT INTO Pessoa (cpf, nome, nascimento, oculos) 
VALUES (20000000099,'José','1990-02-28',0); 
Na linha 20, efetivamos o comando utilizando o método commit.
Observe que nosso código está crescendo. Imagine se tivéssemos uma entidade com
dezenas de atributos? A chamada do método execute da linha 14 cresceria
/
proporcionalmente, comprometendo muito a leitura do nosso código.
A seguir, vamos simplificar nosso código, de forma que ele permaneça legível,
independentemente do número de atributos de uma entidade.
 DICA
Quando utilizamos o comando INSERT INTO do SQL para inserir um registro onde todos
os atributos estão preenchidos, podemos suprimir o nome das colunas no comando.
Como vamos inserir uma pessoa com todos os atributos, vamos manter apenas os
argumentos nomeados no comando SQL.
No próximo exemplo, vamos simplificar mais um pouco nosso código, removendo o
nome das colunas no comando SQL e utilizando a função interna vars do Python que
converte objetos em dicionários. Observe a Figura 15 a seguir.
 
Fonte: O Autor
 Figura: 15.
Após a criação da conexão e do cursor, criamos um objeto do tipo Pessoa com todos os
atributos preenchidos na linha 9. Observe que o valor True do atributo usa_oculos será
convertido para 1 durante a execução do método execute.
/
Na linha 12, criamos o comando SQL “INSERT INTO”, onde suprimimos o nome das
colunas após o nome da tabela Pessoa.
Na linha 13, utilizamos o método execute passando como segundo argumento
vars(pessoa).
A função interna vars retorna todos os atributos de um objeto na forma de dicionário, no
qual cada chave é o nome de um atributo.
Observe na saída do console onde imprimimos o resultado de vars(pessoa), linha 14, e
destacado a seguir:
{'cpf': 30000000099, 'nome': 'Silva', 'data_nascimento': '1990-03-30', 'usa_oculos': True} 
O comando final enviado ao banco de dados pelo comando execute foi:
INSERT INTO Pessoa VALUES (30000000099,'Silva','1990-03-30',1); 
Na linha 17, efetivamos a transação e ao final do script fechamos o cursor e a conexão.
No exemplo a seguir, vamos inserir alguns registros nas outras tabelas, de forma a
povoar nosso banco de dados. Vamos utilizar a mesma lógica do exemplo anterior, no
qual utilizamos a função vars() e argumentos nomeados.
Primeiro, vamos criar mais duas classes no nosso módulo modelo.py para representar
as entidades Marca e Veiculo. Confira essas classes no script da Figura 16.
 
Fonte: O Autor
 Figura: 16.
/
Para inserir os registros, vamos criar o script definido na Figura 17 a seguir.
 
Fonte: O Autor
 Figura: 17.
No script13, após abrir conexão, vamos utilizar um comando especial do SQLite na linha
4. O comando PRAGMA.
 ATENÇÃO
O comando PRAGMA é uma extensão do SQL específica para o SQLite. Ela é utilizada
para modificar alguns comportamentos internos do banco de dados.
O SQLite, por padrão, não força a checagem das restrições de chave estrangeira. Isso
ocorre por motivos históricos, visto que versões mais antigas do SQLite não tinham
suporte à chave estrangeira.
No comando da linha 4, habilitamos a flag foreign_keys, de forma a garantir que as
restrições de chave estrangeiras sejam checadas antes de cada operação.
Após a utilização do comando PRAGMA e da criação de um cursor, vamos inserir
registros relacionados à entidade Marca e Veiculo no banco.
Vamos começar pela entidade Marca, pois ela é um requisito para criação de registros na
tabela Veiculo, visto que a tabela Veiculo contém uma chave estrangeira para a tabela
/
Marca, por meio do atributo Veiculo.marca, que referencia Marca.id.
Na linha 8, escrevemos o comando de inserção de registro na tabela Marca utilizando
argumentos nomeados.
Como não iremos passar um valor para o id da marca, que é autoincrementado, foi
necessário explicitar o nome das colunas no comando INSERT INTO. Caso omitíssemos
o nome das colunas, seria gerada uma exceção do tipo OperationalError, com a
descrição indicando que a tabela tem 3 colunas, mas apenas dois valores foram
fornecidos.
Na linha 10, criamos um objeto do tipo Marca, que foi inserido no banco pelo comando
execute da linha 11.
Para criar uma referência da marca que acabamos de inserir em um veículo, precisamos
do id autoincrementado gerado pelo banco no momento da inserção.
Para isso, vamos utilizar o atributo lastrowid do Cursor. Esse atributo armazena o id da
linha do último registro inserido no banco e está disponível assim que chamamos o
método execute do cursor. O id da linha é o mesmo utilizado para o campo
autoincrementado.
Na linha 12, atribuímos o valor do lastrowid ao atributo id do objeto marca1, recém-
criado.
Nas linhas 14 a 16, criamos mais um objeto do tipo Marca, inserimos no banco de dados
e recuperamos seu novo id.
Nas linhas 19 e 20, temos o comando para inserir registros na tabela Veiculo, também
utilizando argumentos nomeados. Como vamos inserir um veículo com todos os
atributos, omitimos os nomes das colunas.Nas linhas 21 a 24, criamos quatro objetos do tipo Veiculo. Observe que utilizamos o
atributo id dos objetos marca1 e marca2 para fazer referência à marca do veículo. Os
CPF dos proprietários foram escolhidos aleatoriamente, baseando-se nos cadastros
anteriores.
Lembre-se de que como os atributos proprietario e marca são referências a chaves de
outras tabelas, eles precisam existir no banco! Caso contrário, será lançada uma
exceção de erro de integridade (IntegrityError) com a mensagem Falha na Restrição de
Chave Estrangeira (FOREIGN KEY constraint failed).
/
Na sequência, os veículos foram inseridos no banco pelos comandos execute das linhas
25 a 28.
Os comandos SQL gerados por esse script foram os seguintes:
INSERT INTO Marca (nome, sigla) VALUES ('Marca A', 'MA') 
INSERT INTO Marca (nome, sigla) VALUES ('Marca B', 'MB') 
INSERT INTO Veiculo VALUES ('AAA0001', 2001, 'Prata', 1.0, 10000000099, 1) 
INSERT INTO Veiculo VALUES ('BAA0002', 2002, 'Preto', 1.4, 10000000099, 1) 
INSERT INTO Veiculo VALUES ('CAA0003', 2003, 'Branco', 2.0, 20000000099, 2) 
INSERT INTO Veiculo VALUES ('DAA0004', 2004, 'Azul', 2.2, 30000000099, 2) 
Ao final do script, efetivamos as transações, fechamos a conexão e o cursor.
Neste momento, temos os seguintes dados nas nossas tabelas:
 
Fonte: O Autor
ATUALIZAÇÃO DE DADOS EM UMA
TABELA
Agora que já sabemos como inserir um registro em uma tabela, vamos aprender a
atualizar os dados de um registro.
Para atualizar um registro, utilizamos o comando SQL UPDATE. Sua sintaxe é a
seguinte:
UPDATE tabela1 
SET coluna1 = valor1, coluna2 = valor2... 
WHERE [condição]; 
Assim como no comando INSERT, podemos montar o comando UPDATE de três formas.
Uma string sem delimitadores, uma string com o delimitador “?” ou uma string com
/
argumentos nomeados.
Também podemos utilizar os delimitadores na condição da cláusula WHERE.
No exemplo a seguir, Figura 18, vamos mostrar como atualizar registros de uma tabela
utilizando os três métodos.
 
Fonte: O Autor
 Figura: 18.
Após a abertura da conexão, habilitamos novamente a checagem de chave estrangeira,
por meio da flag foreign_keys, ativada pelo comando PRAGMA.
Na sequência, criamos o cursor e definimos a string do nosso primeiro comando de
atualização, onde passamos os valores de forma explícita, sem utilização de
delimitadores. O string foi atribuído à variável comando1, linha 9.
No comando1, estamos atualizando o valor do atributo oculos para 1 (verdadeiro) para
TODOS os registros da tabela. Isso ocorreu, pois a cláusula WHERE foi omitida.
Na linha 10, executamos o comando1.
Na linha 12, criamos um comando de UPDATE utilizando o delimitador “?” para o valor
do atributo oculos e explicitamos o valor do cpf na cláusula WHERE. O comando
executado pela linha 13 é:
UPDATE Pessoa SET oculos= 0 WHERE cpf=30000000099; 
/
Ou seja, vamos alterar o valor do atributo oculos para zero (falso) apenas para quem tem
cpf igual a 30000000099.
Na linha 15, criamos mais um comando de UPDATE, desta vez utilizando o argumento
nomeado tanto para o atributo oculos quanto para o cpf da clausula WHERE.
O comando final enviado pela linha 16 ao banco de dados é:
UPDATE Pessoa SET oculos= 0 WHERE cpf= 20000000099; 
Onde vamos alterar o valor do atributo oculos para zero (falso) para quem tem cpf igual
a 20000000099.
Na linha 19, efetivamos as transações e posteriormente fechamos o cursor e a conexão.
Se tentássemos alterar o CPF de uma pessoa referenciada pela tabela Veiculo, seria
lançada uma exceção do tipo IntegrityError, devido à restrição da chave estrangeira.
 DICA
Cuidado ao executar um comando UPDATE sem a cláusula WHERE, pois, dependendo
do tamanho do banco de dados, essa operação pode ser muito custosa.
REMOÇÃO DE DADOS DE UMA TABELA
Nesta parte deste módulo, iremos aprender a remover registros de uma tabela.
Para remover um registro, utilizamos o comando SQL DELETE. Sua sintaxe é a seguinte:
DELETE FROM tabela1 
WHERE [condição]; 
Assim como nos outros comandos, podemos montar o comando DELETE de três
formas. Uma string sem delimitadores, uma string com o delimitador “?” ou uma string
com argumentos nomeados. Todos para a condição da cláusula WHERE.
Veja o exemplo da utilização do comando DELETE a seguir, na Figura 19.
/
 
Fonte: O Autor
 Figura: 19.
Após a criação da conexão, habilitação da checagem de chave estrangeira e aquisição
do cursor, criamos o comando SQL “DELETE” na linha 9, onde explicitamos o CPF da
pessoa que desejamos remover do banco.
Na linha 10, utilizamos o método execute com o comando criado anteriormente.
O comando final enviado ao banco de dados pelo comando execute foi:
DELETE FROM Pessoa WHERE cpf=12345678900; 
Na linha 13, efetivamos a transação e ao final do script fechamos o cursor e a conexão.
Observe que, como as outras pessoas cadastradas são referenciadas pela tabela Veiculo
por meio de seu CPF, seria gerada uma exceção do tipo IntegrityError caso tentássemos
removê-las.
/
VERIFICANDO O APRENDIZADO
1. CONSIDERE QUE TEMOS AS TABELAS ARREMATE E PRODUTO,
DEFINIDAS COM OS COMANDOS SQL A SEGUIR:
CREATE TABLE PRODUTO ( 
CODIGO INTEGER NOT NULL, 
NOME TEXT NOT NULL, 
DESCRICAO TEXT, 
/
PRECO_INICIAL REAL, 
PRIMARY KEY (CODIGO)) 
CREATE TABLE ARREMATE ( 
ID INTEGER NOT NULL, 
DATA DATE NOT NULL, 
COD_PROD INTEGER NOT NULL, 
LANCE_VENCEDOR REAL, 
FOREIGN KEY(COD_PROD) REFERENCES PRODUTO(CODIGO)) 
QUAL SERÁ O CONTEÚDO DA TABELA ARREMATE APÓS A EXECUÇÃO
DO SCRIPT A SEGUIR?
 
FONTE: O AUTOR
A)
A) id A) Data A) cod_prod A) lance_vencedor
A) 1 A) 01-10-2020 A) 10 A) 3000.0
/
A) 2 A) 01-10-2020 A) 20 A) 39.0
A) 3 A) 01-10-2020 A) 30 A) 110.0
 Atenção! Para visualizaçãocompleta da tabela utilize a rolagem horizontal
A)
B)
B) id B) Data B) cod_prod B) lance_vencedor
B) 1 B) 01-10-2020 B) 10 B) 55.0
B) 2 B) 02-10-2020 B) 20 B) 3000.0
B) 3 B) 01-10-2020 B) 30 B) 110.0
 Atenção! Para visualizaçãocompleta da tabela utilize a rolagem horizontal
B)
C)
C) id C) Data C) cod_prod C) lance_vencedor
C) 1 C) 01-10-2020 C) 20 C) 55.0
C) 2 C) 02-10-2020 C) 20 C) 3000.0
/
C) 3 C) 01-10-2020 C) 30 C) 110.0
 Atenção! Para visualizaçãocompleta da tabela utilize a rolagem horizontal
C)
D)
D) id D) Data D) cod_prod D) lance_vencedor
D) 1 D) 01-10-2020 D) 10 D) 55.0
D) 2 D) 01-10-2020 D) 20 D) 39.0
D) 3 D) 01-10-2020 D) 30 D) 110.0
 Atenção! Para visualizaçãocompleta da tabela utilize a rolagem horizontal
D)
2. CONSIDERE NOVAMENTE AS TABELAS DO EXEMPLO ANTERIOR,
PORÉM SEM REGISTROS CADASTRADOS. OBSERVE O SCRIPT A
SEGUIR E RESPONDA: 
/
 
FONTE: O AUTOR
 
QUAL STRING DEVE SER INCLUÍDA NA LINHA 12, SUBSTITUINDO A
INTERROGAÇÃO, PARA QUE O PROGRAMA INSIRA CORRETAMENTE OS
ELEMENTOS DA LISTA PRODUTOS NA TABELA PRODUTO?
A) '''INSERT INTO Produto VALUES (?, ?, ?, ?);'''
B) '''INSERT INTO Produto VALUES (:codigo, :nome, :descricao, :preco_inicial);'''
C) '''INSERT INTO Produto VALUES (:cod, :nome, :desc, :preco);'''
D) '''INSERT INTO Produto VALUES ([cod, nome, desc, preco]);'''
GABARITO
1. Considere que temos as tabelas Arremate e Produto, definidas com os comandos SQL
a seguir:
CREATE TABLE Produto ( 
codigo INTEGER NOT NULL, 
nome TEXT NOT NULL, 
descricao TEXT, 
preco_inicial REAL, 
PRIMARY KEY (codigo)) 
CREATE TABLE Arremate ( 
id INTEGER NOT NULL, 
data DATE NOT NULL, 
/
cod_prod INTEGER NOT NULL, 
lance_vencedor REAL, 
FOREIGN KEY(cod_prod) REFERENCES Produto(codigo)) 
Qual será o conteúdo da tabela Arremate após a execução do script a seguir?
 
Fonte: O Autor
A alternativa "B " está correta.
 
O script insere os dados iniciais na tabela Arremate nas linhas 11 a 14, deixando a tabela
Arremate com os registros:
 
id data cod_prod lance_vencedor
1 01-10-2020 10 55.0
2 01-10-2020 20 39.0
/
3 01-10-2020 30 110.0
Na linha 19, atualizamos a data e lance_vencedor do registro cujo cod_prod é 20. Com
isso, obtivemos o resultado exibido na letra b.
2. Considere novamente as tabelasdo exemplo anterior, porém sem registros
cadastrados. Observe o script a seguir e responda: 
 
Fonte: O Autor
 
Qual string deve ser incluída na linha 12, substituindo a interrogação, para que o
programa insira corretamente os elementos da lista produtos na tabela Produto?
A alternativa "C " está correta.
 
Para inserir dados de um dicionário utilizando queries dinâmicas, precisamos definir
uma string que utilize parâmetros nomeados. Os nomes dos parâmetros precisam ser os
nomes das chaves do dicionário, não o nome dos atributos. Lembrando que os nomes
das chaves precisam ser precedidos por dois pontos (:).
MÓDULO 4
 Empregar as funcionalidades para recuperação de registros em tabelas
/
SELEÇÃO DE REGISTROS DE UMA TABELA
Neste módulo, aprenderemos a recuperar os registros presentes no banco de dados.
Partiremos de consultas mais simples, utilizando apenas uma tabela, até consultas mais
sofisticadas, envolvendo os relacionamentos entre tabelas.
Para selecionar e recuperar registros de um banco de dados, utilizamos o comando SQL
SELECT. Sua sintaxe é a seguinte:
SELECT coluna1, coluna2, ... FROM tabela1 
WHERE [condição]; 
Assim como nos outros comandos, podemos utilizar uma string sem delimitadores, uma
string com o delimitador “?” ou uma string com argumentos nomeados para a condição
da cláusula WHERE.
No exemplo a seguir, Figura 20, vamos mostrar como recuperar todos os registros da
tabela Pessoa.
/
 
Fonte: O Autor
 Figura: 20.
Após criar uma conexão e obter um cursor, criamos o comando SQL “SELECT” na linha
8 e destacado a seguir:
SELECT nome, oculos FROM Pessoa; 
Observe que estamos selecionando todas as pessoas da tabela, visto que não há
clausulas WHERE. Porém, estamos recuperando apenas os dados das colunas nome e
oculos.
Executamos o comando na linha 9 e utilizamos o método fetchall do cursor para
recuperar os registros selecionados.
Atribuímos o retorno do método à variável registros.
O objeto retornado pelo método fetchall é do tipo lista, impresso pela linha 13 e que
pode ser observado pelo console.
Na linha 15, iteramos sobre os elementos retornados e, na linha 16, imprimimos o tipo e
o conteúdo dos registros.
Observe que cada registro é uma tupla, composta pelos atributos nome e oculos da
entidade Pessoa.
Os registros são sempre retornados em forma de tupla, mesmo que contenham apenas
um atributo!
/
Ao final, fechamos o cursor e a conexão.
 ATENÇÃO
Como o SQLite não cria uma transação para o comando SELECT, não é necessário
executar o commit.
No exemplo a seguir, Figura 21, vamos criar uma consulta para retornar as pessoas que
usam óculos. Observe como ficou o exemplo.
 
Fonte: O Autor
 Figura: 21.
Após abrir a conexão e criar um cursor, definimos o comando para selecionar apenas as
pessoas que usam óculos.
Para isso, definimos o comando SQL da linha 8, que, após executado, fica da seguinte
forma:
SELECT * FROM Pessoa WHERE oculos=1; 
Observe que utilizamos o asterisco (*) para representar quais dados desejamos receber.
No SQL, o asterisco representa todas as colunas.
/
Na linha 12, recuperamos todos os dados selecionados utilizando o fetchall, que foram
iterados na linha 13.
Para cada registro retornado, que é uma tupla com os atributos cpf, nome, nascimento e
oculos, nessa ordem, criamos um objeto do tipo Pessoa, na linha 14.
Observe que utilizamos o operador * do Python. Esse operador “desempacota” um
iterável, passando cada elemento como um argumento para uma função ou construtor.
Como sabemos que a ordem das colunas é a mesma ordem dos parâmetros do
construtor da classe Pessoa, garantimos que vai funcionar corretamente.
Das linhas 15 a 18, imprimimos cada atributo do registro e seu respectivo tipo.
Ao final do script fechamos a conexão e o cursor.
Verifique que os dados dos atributos nascimento e oculos estão exatamente como no
banco de dados, o nascimento é uma string e o oculos é do tipo inteiro.
 COMENTÁRIO
Se estivéssemos utilizando o banco de dados PostgreSQL com o conector psycopg2,
como os tipos DATE e BOOLEAN são suportados, esses valores seriam convertidos
para o tipo correto.
O conector sqlite3 também nos permite fazer essa conversão automaticamente, mas
precisamos fazer algumas configurações a mais.
No exemplo a seguir, Figura 22, vamos mostrar como fazer a conversão de datas e
booleanos.
/
 
Fonte: O Autor
 Figura: 22.
A primeira modificação ocorre nos parâmetros da criação da conexão. Precisamos
passar o argumento PARSE_DECLTYPES para o parâmetro detect_types da função
connect. Observe como ficou a linha 4.
Isso indica que o conector deve tentar fazer uma conversão dos dados, tomando como
base o tipo da coluna declarada no CREATE TABLE.
 COMENTÁRIO
Os tipos DATE e TIMESTAMP já possuem conversores embutidos no sqlite3, porém, o
tipo BOOLEAN não.
Para informar ao conector como fazer a conversão do tipo BOOLEAN, precisamos definir
e registrar a função conversora utilizando a função interna register_converter do sqlite3.
A função register_converter espera, como primeiro parâmetro, uma string com o tipo da
coluna a ser convertido e, como segundo parâmetro, uma função que recebe o dado e
retorna esse dado convertido.
Na linha 12, chamamos a função register_converter, passando a string “BOOLEAN” e a
função conv_bool (converter booleano) como argumentos.
/
A função conv_bool, definida na linha 9, retorna True para o caso do dado ser 1, ou
False, caso contrário. Com isso, convertemos os inteiros 0 e 1 para os booleanos True e
False.
O restante do script é igual ao anterior, porém, os dados estão convertidos para o tipo
correto.
Verifique a saída do console e observe os tipos dos atributos nascimento e oculos.
Agora são das classes date e bool!
SELEÇÃO DE REGISTROS UTILIZANDO
JUNÇÃO
Na seção anterior, aprendemos a selecionar registros de apenas uma tabela, mas como
podemos buscar registros de tabelas relacionadas?
No exemplo a seguir, Figura 23, vamos buscar os veículos e suas respectivas marcas.
Vamos fazer isso por meio da junção de tabelas.
 
Fonte: O Autor
 Figura: 23.
/
Após abrir a conexão e obter um cursor, selecionamos todos os registros da tabela
Veiculo, utilizando o comando da linha 9, executado na linha 10.
Na linha 13, recuperamos todos os registros de veículos utilizando o método fetchall,
que foram iterados na linha 14.
Na linha 15, criamos um objeto do tipo Veiculo utilizando o operador * e imprimimos os
atributos placa e marca na linha 16.
Verifique no console que os valores do atributo marca são seus respectivos ids, 1 e 2.
Isso ocorre, pois no banco de dados, armazenamos apenas uma referência à chave
primária da entidade Marca.
E se quisermos substituir o id das marcas pelos seus respectivos nomes?
Para isso, precisamos realizar uma junção das tabelas Veiculo e Marca no comando
SELECT.
O comando SELECT para junção de duas tabelas tem a seguinte sintaxe:
SELECT tab1.col1, tab1.col2, tab2.col1… FROM tab1 JOIN tab2 ON tab1.colN =
tab2.colM; 
Primeiro, definimos quais colunas serão retornadas utilizando a sintaxe
nome_tabela.nome_coluna, depois indicamos as tabelas que desejamos juntar e, por
último, indicamos como alinhar os registros de cada tabela, ou seja, quais são os
atributos que devem ser iguais (colN e colM).
No exemplo a seguir, Figura 24, vamos criar um script de forma que o Veiculo tenha
acesso ao nome da Marca, não ao id.
/
 
Fonte: O Autor
 Figura: 24.
Após criar uma conexão e obter um cursor, definimos o comando SQL para recuperar os
dados das tabelas Veiculo e Marca de forma conjunta.
Observe o comando SQL nas linhas 9 a 12 e destacado a seguir:
SELECT Veiculo.placa, Veiculo.ano, Veiculo.cor, Veiculo.motor, Veiculo.proprietario,
Marca.nome FROM Veiculo JOIN Marca ON Marca.id = Veiculo.marca; 
Vamos selecionar os atributos placa, ano, cor, motor e proprietário do Veiculo e juntar
com o atributo nome da tabela Marca. Observe que não vamos utilizar o atributo id da
Marca.As tuplas retornadas serão similares à seguinte:
('AAA0001', 2001, 'Prata', 1.0, 10000000099, 'Marca A')
Na linha 16, recuperamos todos os registros de veículos, que foram iterados na linha 17.
Na linha 18, criamos um objeto do tipo Veiculo utilizando o operador * e imprimimos os
atributos placa e marca na linha 19.
Observe pelo console, que agora o atributo marca do nosso objeto do tipo Veiculo
contém o nome da Marca.
No próximo exemplo, vamos dar um passo além. Vamos atribuir ao atributo marca, do
Veiculo, um objeto do tipo Marca. Desta forma, vamos ter acesso a todos os atributos da
/
marca de um veículo.
Para isso, vamos fazer alguns ajustes no nosso modelo. Observe a Figura 25 a seguir.
 
Fonte: O Autor
 Figura: 25.
Vamos começar pelo nosso modelo. Adicionamos o id ao construtor da classe Marca.
Essa alteração foi feita para facilitar a criação do objeto do tipo Marca a partir da
consulta no banco. Veremos o motivo mais à frente.
No script principal à esquerda da Figura 27, iniciamos o script com a abertura da
conexão e criação do cursor.
Na sequência, na linha 9, criamos o comando SQL SELECT para retornar todas as
colunas da tabela Veiculo e Marca, utilizando junção.
Na linha 11, executamos esse comando e os resultados da consulta foram recuperados
na linha 14.
Na linha 15, iteramos sobre os registros recuperados.
Na linha 16, imprimimos cada tupla do registro da forma como foram retornados pelo
conector. Vamos destacar um exemplo a seguir, que também pode ser observado no
console.
('AAA0001', 2001, 'Prata', 1.0, 10000000099, 1, 1, 'Marca A', 'MA')
Destacado em vermelho, temos os atributos relacionados à entidade Veiculo e, em azul,
temos os atributos relacionados à entidade Marca.
/
Na linha 17, utilizamos array slice para selecionar apenas os atributos da Marca. O
resultado do slice para o exemplo anterior é a tupla (1, 'Marca A', 'MA'), onde temos os
atributos id, nome e sigla. Essa tupla é utilizada em conjunto com o operador * para
criarmos um objeto do tipo Marca. Como agora temos acesso ao id da Marca, foi
necessário adicionar o id ao construtor da classe Marca.
Para ilustrar, após o slice e desempacotamento, a linha 17 pode ser traduzida para o
seguinte código:
marca = Marca(1, 'Marca A', 'MA')
Na linha 18, utilizamos array slice para selecionar apenas os atributos do Veiculo, que
retornou a tupla ('AAA0001', 2001, 'Prata', 1.0, 10000000099), onde temos os atributos
placa, ano, cor, motor e proprietário. Observe que removemos o id da Marca no slice.
Fizemos isso, pois ele será substituído pelo objeto marca criado na linha 17.
Após o slice e desempacotamento, a linha 18 pode ser traduzida para o seguinte código:
veiculo = Veiculo('AAA0001', 2001, 'Prata', 1.0, 10000000099, marca) 
Na linha 19, imprimimos a placa do veículo e o nome da marca. Observe que o atributo
marca, do Veiculo, faz uma referência ao objeto marca, por isso fomos capazes de
acessar veiculo.marca.nome.
No final do script, fechamos a conexão e o cursor.
SELEÇÃO DE REGISTROS RELACIONADOS
Para finalizar, vamos recuperar todas as pessoas, com seus respectivos veículos e
marcas.
Para isso, vamos transformar o script anterior em uma função, de forma que possamos
utilizá-la no nosso script final. Observe a Figura 26 a seguir.
/
 
Fonte: O Autor
 Figura: 26.
À direita da imagem, temos o script 19_4. Utilizamos como base o script do exemplo
anterior, script19_3, para criar uma função que retorne uma lista dos veículos de uma
determinada pessoa.
Essa função tem como parâmetros uma conexão e o cpf de uma pessoa. Esse cpf será
utilizado para filtrar os veículos que ela possui. Para isso, utilizamos o delimitador “?”
na linha 11 e passamos o cpf da pessoa como argumento para o comando execute da
linha 14.
Na linha 15, criamos uma lista vazia, chamada veiculos. Essa lista será povoada com os
veículos recuperados pela consulta ao longo do laço for das linhas 17 a 20.
Ao final, fechamos o cursor e retornamos a lista veiculos.
À esquerda da figura, temos nosso script final, script20, cujo objetivo é ter uma lista com
as pessoas cadastradas no banco de dados, incluindo seus veículos e marcas.
Após criar a conexão e o cursor, criamos o comando SQL para recuperar as pessoas na
linha 10, que foi executado na linha 11.
Na linha 14, criamos a variável do tipo lista pessoas e, na linha 15, recuperamos todos
os registros das pessoas utilizando a função fetchall do cursor.
Na linha 16, iteramos pelas pessoas recuperadas e para cada uma, criamos um objeto do
tipo Pessoa (linha 17) e recuperamos seus veículos (linha 18).
/
Para recuperar os veículos, utilizamos a função recuperar_veiculos do script 19_4,
passando como argumento a conexão criada na linha 6 e o cpf da pessoa.
Na linha 19, adicionamos cada pessoa à lista pessoas criada anteriormente.
Na linha 21, iteramos sobre a lista pessoas e imprimimos seu nome e a lista de veículos
que possui.
Ao final, fechamos a conexão e o cursor.
Verifique a saída do console abaixo da figura.
VERIFICANDO O APRENDIZADO
/
1. PARA CONECTORES QUE IMPLEMENTEM A DB API 2.0, QUAL A
CLASSE RETORNADA PELO MÉTODO FETCHALL DO TIPO CURSOR
APÓS EXECUTAR UM COMANDO SQL SELECT QUE NÃO RETORNOU
REGISTROS?
A) list
B) tuple
C) dict
D) None
2. CONSIDERE QUE TEMOS AS SEGUINTES TABELAS E REGISTROS NO
NOSSO BANCO DE DADOS: 
ARREMATE
ID DATA COD_PROD LANCE_VENCEDOR
1 01-10-2020 10 55.0
2 01-10-2020 20 39.0
3 01-10-2020 30 110.0
 ATENÇÃO! PARA VISUALIZAÇÃOCOMPLETA DA TABELA UTILIZE A
ROLAGEM HORIZONTAL
 
PRODUTO
/
CODIGO NOME DESCRIÇÃO PRECO_INICIAL
10 FACA FACA DE PORCELANA 50.0
20 GARFO GARFO DE AÇO INOX 30.0
30 PRATO
PRATO DE
PORCELANA
100.0
 ATENÇÃO! PARA VISUALIZAÇÃOCOMPLETA DA TABELA UTILIZE A
ROLAGEM HORIZONTAL
 
QUAIS OS VALORES DE X, Y, Z E W DO SCRIPT A SEGUIR PARA QUE A
LINHA 12 PROGRAMA IMPRIMA OS VALORES: 
[('FACA', 55.0), ('GARFO', 39.0), ('PRATO', 110.0)] 
 
FONTE: O AUTOR
A) Produto.codigo; Arremate.lance_vencedor; Produto.nome; e Arremate.cod_prod
B) Arremate.cod_vencedor; Produto.codigo; Produto.nome; e Arremate.lance_vencedor
/
C) Produto.nome; Arremate.preco_inicial; Arremate.cod_prod e Produto.codigo;
D) Produto.nome; Arremate.lance_vencedor; Produto.codigo; e Arremate.cod_prod
GABARITO
1. Para conectores que implementem a DB API 2.0, qual a classe retornada pelo método
fetchall do tipo Cursor após executar um comando SQL SELECT que não retornou
registros?
A alternativa "A " está correta.
 
O método fetchall sempre retorna uma lista, mesmo que seja vazia!
2. Considere que temos as seguintes tabelas e registros no nosso banco de dados: 
Arremate
ID Data cod_prod lance_vencedor
1 01-10-2020 10 55.0
2 01-10-2020 20 39.0
3 01-10-2020 30 110.0
 Atenção! Para visualizaçãocompleta da tabela utilize a rolagem horizontal
 
Produto
Codigo Nome descrição preco_inicial
/
10 Faca Faca de porcelana 50.0
20 Garfo Garfo de aço inox 30.0
30 Prato Prato de porcelana 100.0
 Atenção! Para visualizaçãocompleta da tabela utilize a rolagem horizontal
 
Quais os valores de X, Y, Z e W do script a seguir para que a linha 12 programa imprima
os valores: 
[('Faca', 55.0), ('Garfo', 39.0), ('Prato', 110.0)] 
 
Fonte: O Autor
A alternativa "D " está correta.
 
Pela saída impressa pela linha 12, os dados dos registros retornados são Produto.nome
e Arremate.lance_vencedor, que serão o X e Y, respectivamente. A junção precisa ser
feita por colunas que possam ser “alinhadas”, ou seja, que possuam o mesmo tipo e
valores em comum. Essas colunas são Produto.codigo; e Arremate.cod_prod, Z e W,
respectivamente.
/
CONCLUSÃO
CONSIDERAÇÕES FINAIS
Neste tema, visitamos as principais ações que podemos realizar na manipulação de
registros em banco de dados.
Conhecemos as principais funcionalidades disponibilizadas pelas bibliotecas de
gerenciamento de banco de dados que implementam a DB API 2.0, introduzida pela PEP
249.
Vimos como criar um banco de dados e iniciar uma conexão.Além disso, aprendemos a aplicar as funcionalidades de inserção, remoção e
atualização de registros.
Finalmente, empregamos as funcionalidades de recuperação de registros para
selecionar e visualizar o conteúdo do banco de dados.
REFERÊNCIAS
HIPP, R. D. SQLite. In: SQLite. Consultado em meio eletrônico em: 08 out. 2020.
MYSQL. MySQL Connector. In: MySQL. Consultado em meio eletrônico em: 08 out. 2020.
PSYCOPG. Psycopg2. In: Psycopg. Consultado em meio eletrônico em: 08 out. 2020.
https://www.sqlite.org/index.html
/
PYTHON. Python Software Foundation. In: Python. Consultado em meio eletrônico em:
08 out. 2020.
SQLITEBROWSER. DB Browser for SQLite. In: SQLitebrowser. Consultado em meio
eletrônico em: 08 out. 2020.
EXPLORE+
Para saber mais sobre os assuntos tratados neste tema, pesquise na internet:
As páginas das bibliotecas SQLAlchemy e Peewee.
CONTEUDISTA
Frederico Tosta de Oliveira
 CURRÍCULO LATTES
javascript:void(0);
/
DESCRIÇÃO
Apresentação dos principais frameworks e bibliotecas necessárias para o desenvolvimento de aplicações
de interface gráfica (GUI) no Python, Como adicionar widgets para montar a interface gráfica, Como
implementar uma interface para incluir dados em tabela e localizar, alterar e excluir dados em tabela.
PROPÓSITO
Compreender como criar uma aplicação GUI em Python que interaja com um banco de dados, de modo a
realizar as operações de inserção, consulta, alteração e exclusão de dados em uma tabela.
PREPARAÇÃO
Antes de iniciar o conteúdo deste tema, o aluno precisa ter instalado o Python versão 3, a IDE Spyder e o
PostgreSQL.
OBJETIVOS
/
MÓDULO 1
Identificar alguns dos principais frameworks e bibliotecas necessárias para a GUI
MÓDULO 2
Descrever a adição de widgets e montagem da interface gráfica
MÓDULO 3
Definir a interface para inclusão de dados em uma tabela no banco de dados
MÓDULO 4
Identificar a interface para localização, alteração e exclusão de dados em tabela
INTRODUÇÃO
Cada vez mais, nós geramos e consumimos dados para poder realizar atividades que vão desde a abertura
de uma conta bancária, até as informações que disponibilizamos nas redes sociais.
Portanto, é necessário entender como esses dados são gerenciados, pois são importantes para identificar
pessoas, preferências, produtos, transações financeiras, entre tantas outras aplicações.
Para fazer esse gerenciamento, as aplicações fazem uso de sistemas gerenciadores de banco de dados, de
modo a tornar possível a realização de operações de inserção, consulta, alteração e exclusão de dados.
Além disso, para que o usuário possa interagir de modo eficiente com o sistema, é importante que ele tenha
à disposição uma interface gráfica que facilite o seu acesso às funcionalidades implementadas.
Nesse sentido, a linguagem Python aparece como uma opção muito eficaz para atingir esses objetivos, uma
vez que oferece recursos para desenvolver aplicações que integrem interface gráfica com operações no
banco de dados.
Ao longo deste trabalho, apresentaremos alguns dos principais frameworks e bibliotecas para desenvolver
aplicações de interface gráfica, além de explorarmos como realizar aplicações no banco de dados.
/
MÓDULO 1
 Identificar alguns dos principais frameworks e bibliotecas necessárias para a GUI
 
Fonte: Trismegist san/Shutterstock
CONCEITOS
A linguagem Python possui muitos frameworks para desenvolvimento de aplicações de interface gráfica
para interação com o usuário, chamadas, comumente, de GUI (Graphical User Interface).
O framework mais comum é o Tkinter (Python interface to Tcl/Tk (2020)) que já faz parte da instalação
Python, mas existem outros frameworks que têm características específicas que podem torná-los a escolha
adequada para um projeto.
Entre os frameworks para aplicações GUI mais comuns estão:
TKINTER
É o framework GUI padrão do Python. Sua sintaxe é simples, possui muitos componentes para interação
com o usuário. Além disso, seu código é aberto e é disponível sob a licença Python. Caso ela não esteja
instalada na sua versão do Python, basta digitar o comando:
pip install tkinter 
Para quem usa a IDE Spyder, ver Spyder (2020), é necessário colocar uma exclamação antes do comando
“pip”, ou seja, o comando, nesse caso, ficaria:
!pip install tkinter 
/
Para testar a instalação, basta escrever na linha de comando o código abaixo:
import tkinter 
tkinter._test() 
Se a instalação ocorreu normalmente, vai aparecer uma tela com alguns componentes para que você possa
interagir e ter uma impressão inicial do potencial desse framework, conforme a Figura 1.
 
Fonte: O Autor
 Figura 1: Exemplo de aplicação do Tkinter.
Devido à importância do Tkinter, vamos explorá-lo com bastantes detalhes mais à frente.
FLEXX
É um kit de ferramentas para o desenvolvimento de interfaces gráficas com o usuário implementado em
Python, que faz uso de tecnologia web para sua renderização. O Flexx pode ser usado para criar tanto
aplicações de desktop, como para web e, até mesmo, exportar uma aplicação para um documento HTML
independente. Para instalar o Flexx, basta digitar o comando:
pip install flexx 
Para quem usa a IDE Spyder, é necessário colocar uma exclamação antes do comando “pip”, isso vale para
qualquer instalação de biblioteca/framework/pacote.
 COMENTÁRIO
Para evitar repetições sobre isso, apresentaremos aqui como instalar o pacote Flexx na IDE Spyder, mas,
para os próximos casos, mostraremos apenas a instalação tradicional, ou seja, sem o símbolo de
“exclamação”.
No caso do Spyder, o comando deve ser:
!pip install flexx 
/
Uma forma prática de testar a instalação e aprender um pouco mais sobre esse framework, é escrever o
código abaixo na linha de comando, ou em um arquivo e executar:
from flexx import flx 
class Exemplo(flx.Widget): 
 
def init(self): 
flx.Button(text='Olá') 
flx.Button(text='Mundo') 
 
if __name__ == '__main__': 
a = flx.App(Exemplo, title='Flexx demonstração') 
m = a.launch() 
flx.run() 
Se a instalação estiver correta, vai abrir uma janela, conforme a Figura 2.
 
Fonte: O Autor
 Figura 2: Exemplo de aplicação com Flexx.
CEF PYTHON
É um projeto de código aberto voltado para o desenvolvimento de aplicações com integração ao Google
Chrome. Existem muitos casos de uso para CEF. Por exemplo, ele pode ser usado para criar uma GUI
baseada em HTML 5, pode usá-lo para testes automatizados, como também pode ser usado para web
scraping, entre outras aplicações.
Para instalá-lo, basta digitar na linha de comando:
pip install cefpython3 
Para testar a instalação do CEF Python, basta escrever o código abaixo na linha de comando, ou em um
arquivo e executar:
/
from cefpython3 import cefpython as cef 
import platform 
import sys 
def main(): 
check_versions() 
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error 
cef.Initialize() 
cef.CreateBrowserSync(url="https://www.google.com/", 
window_title="Olá, mundo! Este é o primeiro exemplo do CEF Python") 
cef.MessageLoop() 
cef.Shutdown() 
 
def check_versions(): 
ver = cef.GetVersion() 
print("[hello_world.py] CEF Python {ver}".format(ver=ver["version"])) 
print("[hello_world.py] Chromium {ver}".format(ver=ver["chrome_version"])) 
print("[hello_world.py] CEF {ver}".format(ver=ver["cef_version"])) 
print("[hello_world.py] Python {ver} {arch}".format( 
ver=platform.python_version(), 
arch=platform.architecture()[0])) 
assert cef.__version__ >= "57.0", "CEF Python v57.0+ required to run this" 
 
 
if __name__ == '__main__': 
main() 
 ATENÇÃO
Como esse exemplo, apesar de simples, é um pouco maior, cabe lembrar que a indentação faz parte da
sintaxe do Python (Python 3.8.5 documentation, 2020), por isso, é necessário ter bastante cuidado, caso
contrário o programa vai apresentar erros.
Bem, se tudo funcionou corretamente, quando o programa executar, vai abrir uma janela conforme a Figura
3:
/
 
Fonte: O Autor
 Figura 3: Exemplo de aplicação com CEF Python.
Observe o títuloda janela: “Olá, mundo! Este é o primeiro exemplo do CEF Python”.
KIVY
É um framework Python de código aberto para o desenvolvimento de aplicações com interfaces de usuário
e multitoque. Ele é escrito em Python e Cython, baseado em OpenGL ES 2, suporta vários dispositivos de
entrada e possui uma extensa biblioteca de componentes (widgets).
Com o mesmo código, a aplicação funciona para Windows, macOS, Linux, Android e iOS. Todos os widgets
Kivy são construídos com suporte multitoque.
Para instalá-lo, é necessário escrever na linha de comando:
pip install Kivy 
Uma forma de testar a instalação é escrever e executar o programa:
from kivy.app import App 
from kivy.uix.button import Button 
 
class ExemploApp(App): 
def build(self): 
return Button(text='Olá, Mundo!') 
 
ExemploApp().run() 
/
Se tudo funcionar corretamente, vai aparecer a aplicação, conforme a Figura 4:
 
Fonte: O Autor
 Figura 4: Exemplo de aplicação Kivy.
Na figura 4, é possível identificar o título da janela “Exemplo” e um componente botão no centro da tela com
a mensagem “Olá, Mundo!”. Um ponto interessante pode ser observado no código, que é a utilização da
programação orientada a objetos.
É um framework utilizado para o desenvolvimento de jogos. A instalação desse framework pode ser um
pouco mais complicada do que os anteriores, em especial, por causa das dependências.
Muitos desses problemas são bem documentados e de fácil acesso na web.
PYFORMS
É um framework Python 3 para desenvolver aplicações que podem operar nos ambientes Desktop GUI,
Terminal e Web. A biblioteca é composta por três sub-bibliotecas, cada uma implementando a camada
responsável por interpretar a aplicação Pyforms em cada ambiente diferente, que são:
Pyforms-gui.
Pyforms-web.
Pyforms-terminal.
Essas camadas podem ser usadas individualmente, ou em conjunto, dependendo da instalação do Pyforms.
Para fazer a instalação básica, é necessário escrever na linha de comando:
pip install pyforms 
Uma forma de testar a instalação é escrever e executar o programa:
/
import pyforms 
from pyforms.basewidget import BaseWidget 
from pyforms.controls import ControlText 
from pyforms.controls import ControlButton 
 
class ExemploSimples(BaseWidget): 
 
def __init__(self): 
super(ExemploSimples,self).__init__('ExemploSimples') 
#Definition of the forms fields
self._nome = ControlText('Nome', 'Default value') 
self._sobrename = ControlText('Sobrenome') 
self._nomeCompleto = ControlText('Nome completo') 
self._button = ControlButton('Pressione o Botão')
 
 
#Execute the application 
if __name__ == "__main__": 
from pyforms import start_app 
start_app(ExemploSimples) 
Se tudo funcionar corretamente, vai aparecer a aplicação, conforme a Figura 5:
 
Fonte: O Autor
 Figura 5: Exemplo de aplicação Pyform.
 COMENTÁRIO
No exemplo da Figura 5, é possível ver três caixas de texto, chamadas de “controle de texto” e um
componente botão, chamado de “controle de botão” pelo Pyforms. Ele foi projetado para desenvolver
/
aplicações para executar no modo Windows GUI.
PYQT
Uma aplicação desenvolvida no framework PyQt executa nas plataformas Windows, macOS, Linux, iOS e
Android.
Trata-se de um framework que aborda, além de desenvolvimento GUI, de abstrações de sockets de rede,
threads, Unicode, expressões regulares, bancos de dados SQL, OpenGL, XML, entre outras aplicações.
Suas classes empregam um mecanismo de comunicação segura entre objetos que é fracamente acoplada,
tornando mais fácil criar componentes de software reutilizáveis.
Para fazer a instalação básica, é necessário escrever na linha de comando:
pip install PyQt5 
Uma forma de testar a instalação é escrever e executar o programa:
import sys 
from PyQt5 import QtCore, QtWidgets 
from PyQt5.QtWidgets import QMainWindow, QLabel, QGridLayout, QWidget 
from PyQt5.QtCore import QSize 
 
class HelloWindow(QMainWindow): 
def __init__(self): 
QMainWindow.__init__(self) 
 
self.setMinimumSize(QSize(280, 120)) 
self.setWindowTitle("Olá, Mundo! Exemplo PyQT5") 
 
centralWidget = QWidget(self) 
self.setCentralWidget(centralWidget) 
 
gridLayout = QGridLayout(self) 
centralWidget.setLayout(gridLayout) 
 
title = QLabel("Olá Mundo para PyQt", self) 
title.setAlignment(QtCore.Qt.AlignCenter) 
gridLayout.addWidget(title, 0, 0) 
/
 
if __name__ == "__main__": 
app = QtWidgets.QApplication(sys.argv) 
mainWin = HelloWindow() 
mainWin.show() 
sys.exit( app.exec_() ) 
Se tudo funcionar corretamente, vai aparecer a aplicação, conforme a Figura 6:
 
Fonte: O Autor
 Figura 6: Exemplo de aplicação PyQt.
No exemplo da Figura 6, é possível identificar uma janela, o título da janela e uma mensagem no centro.
WXPYTHON
É um kit de ferramentas GUI baseadas em uma biblioteca C++ chamada wxWidgets, que foi lançada em
1998. O wxPython usa os componentes (widgets) reais na plataforma nativa sempre que possível.
Essa, inclusive, é a principal diferença entre o wxPython e outros kits de ferramentas, como PyQt ou Tkinter.
 ATENÇÃO
Desse modo, as aplicações desenvolvidas em wxPython se assemelham a aplicações nativas do sistema
operacional em que estão sendo executados.
As bibliotecas PyQt e Tkinter têm componentes personalizados, é por isso que é bastante comum que as
aplicações fiquem com um aspecto diferente das aplicações nativas do sistema operacional. Apesar disso,
o wxPython também oferece suporte a componentes personalizados.
Para fazer a instalação básica, é necessário escrever na linha de comando:
pip install wxPython 
/
Uma forma de testar a instalação é escrever e executar o programa:
import wx 
class Janela(wx.Frame): 
def __init__(self, parent, title): 
super(Janela, self).__init__(parent, title=title, size = (400,300)) 
self.panel = ExemploPainel(self) 
self.text_ctrl = wx.TextCtrl(self.panel, pos=(5, 5)) 
self.btn_test = wx.Button(self.panel, label='Pressione esse componente!', pos=(5, 55)) 
 
 
class ExemploPainel(wx.Panel): 
def __init__(self, parent): 
super(ExemploPainel, self).__init__(parent) 
 
class ExemploApp(wx.App): 
def OnInit(self): 
self.frame = Janela(parent=None, title="Janela wxPython") 
self.frame.Show() 
return True 
 
app = ExemploApp() 
app.MainLoop() 
Se tudo funcionar corretamente, vai aparecer a aplicação, conforme a Figura 7:
 
Fonte: O Autor
 Figura 7: Exemplo de aplicação wxPython.
/
No exemplo da Figura 7, é possível identificar uma janela, o seu respectivo título, uma caixa de texto e um
botão com a mensagem “Pressione esse componente!”.
PYAUTOGUI
Permite desenvolver aplicações Python que controlem o mouse e o teclado para automatizar as interações
com outros aplicativos.
 COMENTÁRIO
Uma das situações em que essa característica pode ser muito interessante é na implementação de testes
que simulem a interação do usuário com o sistema.
O PyAutoGUI funciona no Windows, macOS e Linux e é executado no Python 2 e 3.
Para fazer a instalação básica, é necessário escrever na linha de comando:
!pip install PyAutoGUI 
Uma forma de testar a instalação é escrever e executar o programa:
import pyautogui 
screenWidth, screenHeight = pyautogui.size() 
currentMouseX, currentMouseY = pyautogui.position() 
pyautogui.moveTo(100, 150) 
pyautogui.click() 
pyautogui.click(100, 200) 
pyautogui.move(0, 10) 
pyautogui.doubleClick() 
pyautogui.moveTo(500, 500, duration=2, tween=pyautogui.easeInOutQuad) 
pyautogui.write('Olá, Mundo!', interval=0.25) 
pyautogui.press('esc') 
pyautogui.keyDown('shift') 
pyautogui.press(['left', 'left', 'left', 'left']) 
pyautogui.keyUp('shift') 
pyautogui.hotkey('ctrl', 'c') 
pyautogui.alert('Esta é a mensagem para Tela.') 
Nesse código, basicamente, tem-se a seguinte sequência de instruções:
/
Obter o tamanho do monitor principal.
 
Obter a posição XY do mouse.
 
Mover o mouse para as coordenadas XY.
 
Clicar com o mouse.
 
Mover o mouse para as coordenadas XY e clicar nelas.
 
Mover o mouse 10pixels para baixo de sua posição atual.
 
Clicar duas vezes com o mouse.
 
Usar a função de interpolação/atenuação para mover o mouse por 2 segundos com pausa de um quarto de
segundo entre cada tecla.
 
Pressionar a tecla Esc.
 
Pressionar a tecla Shift e segurá-la.
 
Pressionar a tecla de seta para a esquerda 4 vezes.
 
Soltar a tecla Shift.
/
 
Pressionar a combinação de teclas de atalho Ctrl-C.
 
Mostrar uma caixa de alerta aparecer na tela e pausar o programa até clicar em OK.
Antes de executar o código, cabe um alerta: Essa aplicação, apesar de ser muito simples, vai interagir com
o seu sistema.
Se tudo funcionar corretamente, vai aparecer a aplicação, conforme a Figura 8:
 
Fonte: O Autor
 Figura 8: Exemplo de aplicação PyAutoGUI.
A figura 8 vai aparecer depois do “cursor do mouse” se movimentar na tela e o “teclado” escrever a
mensagem “Esta é a mensagem para tela”.
As possibilidades de aplicações são muitas para o PyAutoGUI.
PYSIMPLEGUI
Esse pacote foi lançado em 2018 e possui portabilidade com os pacotes: Tkinter, PyQt, wxPython e Remi,
portanto aumenta as possibilidades de uso de componentes na programação.
Para fazer a instalação básica, é necessário escrever na linha de comando:
pip install pysimplegui 
Uma forma de testar a instalação é escrever e executar o programa:
import PySimpleGUI as sg 
 
sg.theme('DarkAmber') 
 
layout = [ [sg.Text('Texto na linha 1')], 
[sg.Text('Entre com um texto na linha 2'), sg.InputText()], 
/
[sg.Button('Ok'), sg.Button('Cancel')] ] 
window = sg.Window('Bem-Vindo ao PySimpleGUI', layout) 
 
while True: 
event, values = window.read() 
if event == sg.WIN_CLOSED or event == 'Cancel': 
break 
print('Você entrou com: ', values[0]) 
 
window.close() 
Se tudo funcionar corretamente, vai aparecer a aplicação, conforme a Figura 9:
 
Fonte: O Autor
 Figura 9: Exemplo PySimpleGUI.
No exemplo da Figura 9, é possível identificar uma janela, o seu respectivo título, dois componentes “label”,
uma caixa de texto e dois botões.
 ATENÇÃO
A lista de frameworks e bibliotecas disponíveis para Python ainda tem muitos outros exemplos, como o
PySide e o PyObject. A escolha deve levar em consideração a maturidade da biblioteca/framework e da
necessidade de o projeto incorporar ou não aspectos mais elaborados de uma GUI.
VANTAGENS E DESVANTAGENS DE UMA
INTERFACE GUI
Agora, discutiremos sobre alguns dos aspectos do desenvolvimento de um projeto de interface gráfica.
VANTAGENS
/
Entre as principais vantagens relacionadas às escolhas por uma determinada biblioteca/framework para um
projeto da interface GUI, estão:
Facilitar a interação do usuário com o sistema através da utilização de componentes intuitivos.
Simplicidade de utilizar os componentes em um programa.
Compatibilidade do componente com múltiplas plataformas.
Criar uma camada de abstração para o programador sobre detalhes da programação dos
componentes.
Incorporação de aspectos que facilitem a experiência do usuário com o sistema.
Facilitar que o usuário possa alternar rapidamente entre as funcionalidades do sistema.
Ser bem documentada e com uma comunidade engajada, o que ajuda a perceber novas aplicações e
evoluções dos componentes que vão melhorar a aplicação dos componentes GUI no sistema.
DESVANTAGENS
Também devem ser levadas em consideração as desvantagens relacionadas às escolhas de
bibliotecas/frameworks da interface GUI. Entre essas desvantagens, estão:
Alguns componentes de interface gráfica usam muitos recursos computacionais, pois têm como
objetivo ser amigáveis para o usuário, e não necessariamente fazer uso otimizado dos recursos.
Como consequência, podem tornar as aplicações muitos lentas para plataformas de versões mais
antigas.
O uso dos componentes na programação pode ser excessivamente complexo, fazendo com que o
desenvolvedor tenha que desviar esforço do objetivo principal para se preocupar com detalhes dos
componentes GUI.
As bibliotecas disponibilizam componentes, mas a aplicação deles no sistema é responsabilidade do
desenvolvedor. Além de se preocupar com aspectos de programação, é necessário se preocupar
como esses componentes vão ser disponibilizados no sistema, pois, caso contrário, algumas tarefas
podem ser mais demoradas devido a muitos níveis de interação para selecionar a escolha desejada,
como, por exemplo, o uso excessivo de menus e submenus.
Os componentes precisam ter comportamentos previsíveis. Comportamentos inesperados são
potencialmente perigosos, pois podem dar acesso não autorizado a partes do sistema, revelando,
assim, vulnerabilidades de segurança.
/
Sistemas baseados em componentes GUI requerem mais memória RAM para serem executados.
Ainda sobre uso de recursos computacionais, sistemas baseados em componentes GUI demandam
por processamento.
Podem ter um comportamento distinto, quando operam em diferentes plataformas, tanto na parte
visual, como pela demanda de recursos computacionais.
O tempo necessário para utilizar os componentes GUI no sistema pode ser longo, em especial,
quando há necessidade de atender a muitos requisitos de infraestrutura.
A Curva de Aprendizado para profissionais não experientes pode ser proibitiva para o
desenvolvimento de projetos de curto de prazo.
Assista ao vídeo a seguir e aprenda a criar uma aplicação com interface gráfica. Neste vídeo, você verá a
apresentação do protótipo de sistema que será desenvolvido, os frameworks a serem utilizados e a
preparação do ambiente para utilização.
VERIFICANDO O APRENDIZADO
1. A LINGUAGEM PYTHON É MUITO USADA EM DIVERSAS APLICAÇÕES DEVIDO À
SIMPLICIDADE DA SINTAXE E POR POSSUIR MUITOS PACOTES DISPONÍVEIS QUE
PODEM SER INSTALADOS ATRAVÉS DO COMANDO “PIP INSTALL ”. SOBRE O
COMANDO “PIP”, SELECIONE A OPÇÃO CORRETA:
A) Funciona como um gerenciador de dependências.
B) Independentemente do ambiente de desenvolvimento, o comando “pip” deve ser usado da mesma
forma.
/
C) O comando “pip” é o único meio de fazer a instalação de pacotes no Python.
D) Por se tratar de um comando nativo do Python, não é necessário se preocupar com a versão do “pip”.
E) O “pip” é o interpretador utilizado pelo Python para gerar o executável.
2. A BIBLIOTECA TKINTER É CONSIDERADA A BIBLIOTECA PADRÃO DO PYTHON
PARA O DESENVOLVIMENTO DE INTERFACE GRÁFICA. EM RELAÇÃO À
BIBLIOTECA TKINTER, SELECIONE A OPÇÃO CORRETA:
A) A biblioteca Tkinter sempre será a melhor escolha para um projeto de interface gráfica, pois é compatível
com múltiplas plataformas.
B) Seus componentes não se integram diretamente na linguagem Python, sendo necessário usar outros
programas para ter acesso aos seus recursos.
C) Seus componentes GUIs são considerados avançados e, portanto, apropriados para aplicações de
jogos, por exemplo.
D) A biblioteca Tkinter é a base para que todos os outros frameworks GUI possam ser utilizados.
E) Para testar se ela está instalada corretamente, pode-se escrever duas linhas de código que são import
tkinter e tkinter._test().
GABARITO
1. A linguagem Python é muito usada em diversas aplicações devido à simplicidade da sintaxe e por
possuir muitos pacotes disponíveis que podem ser instalados através do comando “pip install ”.
Sobre o comando “pip”, selecione a opção correta:
A alternativa "A " está correta.
 
O comando “pip” é um dos gerenciadores de dependências do Python. Ele facilita a instalação de pacotes,
mas possui algumas pequenas variações de acordo com o ambiente de desenvolvimento. Por exemplo, no
Spyder, o comando “pip” deve ser precedido do símbolo de exclamação “!”.
2. A biblioteca Tkinter é considerada a biblioteca padrão do Python para o desenvolvimento de
interface gráfica. Em relação à biblioteca Tkinter, selecione a opção correta:
A alternativa "E " está correta.
 
De fato, a biblioteca Tkinter é a mais importante do Python por estar disponível na instalação padrão do
Python, no entanto, apesar da facilidade de aplicação, ela não é adequada para aplicações específicas,/
como jogos.
MÓDULO 2
 Descrever a adição de widgets e montagem da interface gráfica
CONCEITOS
Neste módulo, o nosso foco será na criação de uma aplicação GUI. Para isso, a biblioteca que vamos usar
como referência é a Tkinter.
 COMENTÁRIO
Essa biblioteca GUI é considerada a padrão para desenvolvimento de interface gráfica no Python. Ela
fornece uma interface orientada a objetos que facilita a implementação de programas interativos.
Para usar o Tkinter – supondo que você já instalou o Pyhton e o pacote Tkinter ‒ é necessário executar as
seguintes etapas:
Importar a biblioteca Tkinter.
 
Criar a janela principal do programa GUI.
 
Adicionar um ou mais dos widgets (componentes).
 
Entrar no loop de evento principal para tratar os eventos disparados pelo usuário.
O código fica conforme abaixo:
import tkinter 
janela = tkinter.Tk() 
janela.mainloop() 
/
Esse programa produz a seguinte saída, conforme a Figura 10.
 
Fonte: O Autor
 Figura 10: Exemplo de aplicação Tkinter.
WIDGETS TKINTER
O Tkinter possui diversos componentes (widgets), tais como botões, rótulos e caixas de texto usados para
criar aplicações interativas com o usuário.
Os principais widgets do Tkinter, de acordo com Meier (2015), são:
Botão (Button)
É usado para exibir os botões na aplicação. São usados, por exemplo, para
confirmar uma ação de salvar os dados.
Telas (Canvas) É usado para desenhar formas, como linhas, ovais, polígonos e retângulos.
Botão de
verificação
(Checkbutton)
É usado para exibir várias opções como caixas de seleção. O usuário pode
selecionar várias opções ao mesmo tempo.
Entrada de texto
(Entry)
É usado para exibir uma caixa de texto de linha única para que o usuário
digite valores de entrada.
Quadros (Frame)
É usado como um widget de contêiner, isso significa que outros componentes
são adicionados a ele com o objetivo de organizar outros widgets.
Rótulo (Label)
É usado para fornecer uma legenda de linha única para outros widgets.
Também pode conter imagens.
/
Caixa de
listagem
(Listbox)
É usado para fornecer uma lista de opções para um usuário.
Menubutton É usado para exibir opções no menu.
Menu
É usado para fornecer várias possibilidades de comandos a um usuário.
Esses comandos estão contidos no Menubutton.
Mensagem
(Message)
É usado para exibir uma mensagem de texto e um botão para o usuário
confirmar uma ação.
Botão de rádio
(Radiobutton)
É usado para exibir várias opções, como botões de rádio. O usuário pode
selecionar apenas uma opção por vez.
Escala (Scale) É usado para fornecer um widget de controle deslizante.
Barra de
rolagem
(Scrollbar)
É usado para adicionar capacidade de rolagem a vários widgets.
Texto (Text) É usado para exibir texto em várias linhas.
Toplevel É usado para fornecer um contêiner de janela separado.
Spinbox
É uma variante do widget Entry padrão. Ele é usado para selecionar um
número fixo de valores.
PanedWindow
É um widget de contêiner que pode conter qualquer número de painéis,
organizados horizontalmente ou verticalmente.
LabelFrame
É um widget de contêiner simples. Seu objetivo principal é atuar como um
espaçador, ou contêiner para layouts de janela.
tkMessageBox Este módulo é usado para exibir caixas de mensagens.
/
Cada um desses widgets possuem propriedades que permitem personalizar tamanhos, cores e fontes que
serão exibidos para o usuário.
Na próxima seção, apresentaremos alguns exemplos que vão ajudar a entender como desenvolver uma
aplicação GUI.
DESENVOLVENDO EXEMPLOS DE APLICAÇÕES
GUI
 DICA
Antes de iniciar esta seção, é fortemente recomendado que você tenha feito a instalação da versão mais
atual do Python e tente executar os exemplos.
Vamos apresentar exemplos dos componentes:
Window
Label
Button
Entry
Radiobutton
Checkbox
Text
Message
Sliders
Dialog
/
Combobox
WIDGET WINDOW (TK.TK())
Para iniciar, a primeira aplicação vai exibir uma janela redimensionável, conforme a Figura 11.
 
Fonte: O Autor
 Figura 11: Exemplo de uma janela redimensionável.
O código dessa aplicação é:
import tkinter as tk 
janela = tk.Tk() 
janela.title("Aplicação GUI") 
janela.mainloop()] 
Agora, cada uma das linhas será analisada.
LINHA 1
É feita a importação da biblioteca Tkinter.
LINHA 2
É criada uma instância da classe Tk no objeto “janela”.
LINHA 3
O método “title” é usado para definir um título que aparece no topo da janela, no caso, “Aplicação GUI”.
LINHA 4
A aplicação inicia o loop de evento principal da janela.
Bem, a janela da aplicação anterior é redimensionável, ou seja, o usuário pode alterar as dimensões da
janela, se ele clicar com o cursor do mouse na janela e arrastá-la.
Para fixar o tamanho da janela, é necessário determinar essa propriedade conforme o código abaixo:
import tkinter as tk 
janela = tk.Tk() 
/
janela.title("Aplicação GUI NÃO Dimensionável") 
janela.resizable(False, False) 
janela.mainloop() 
 ATENÇÃO
A principal diferença desse exemplo em relação ao anterior está na linha 4, onde a propriedade de
redimensionar a janela é colocada como “Falso”.
WIDGET LABEL
O próximo exemplo apresenta como usar o widget “Label”. O código para gerar uma aplicação com o
“Label” é dado por:
import tkinter as tk 
from tkinter import ttk 
janela = tk.Tk() 
janela.title("Aplicação GUI com o Widget Label") 
ttk.Label(janela, text="Componente Label").grid(column=0, row=0) 
janela.mainloop() 
Na Figura 12, é exibido o resultado da execução:
 
Fonte: O Autor
 Figura 12: Exemplo do componente Label.
Na linha 5, é feito o posicionamento do componente “label” na “janela” com o gerenciador de layout “grid”.
WIDGET BUTTON
O próximo exemplo apresenta como usar o widget “Button”.
O código para gerar uma aplicação com o componente “Button” é dado por:
/
import tkinter as tk 
contador = 0 
def contador_label(lblRotulo): 
def funcao_contar(): 
global contador 
contador = contador + 1 
lblRotulo.config(text=str(contador)) 
lblRotulo.after(1000, funcao_contar) 
funcao_contar() 
janela = tk.Tk() 
janela.title("Contagem dos Segundos") 
lblRotulo = tk.Label(janela, fg="green") 
lblRotulo.pack() 
contador_label(lblRotulo) 
btnAcao = tk.Button(janela, text='Clique aqui para Interromper a contagem', width=50,
command=janela.destroy) 
btnAcao.pack() 
janela.mainloop() 
Este programa vai gerar uma janela com um contador de segundos – que utiliza um componente “label” – e
um componente botão com a mensagem “Clique aqui para interromper a contagem”.
Na Figura 13, é exibido o resultado da execução do programa.
 
Fonte: O Autor
 Figura 13: Exemplo do componente botão.
As linhas mais importantes deste código são:
LINHA 14
Chamada para a função “contador_label”, que é a função que faz a contagem dos segundos e a atualização
dos dados do componente “label”.
LINHA 15
Criação de uma instância do componente “botão” com uma mensagem, largura do componente e o
estabelecimento de um comportamento, no caso, fechar a janela, quando o usuário pressionar o botão.
/
WIDGET ENTRY
Agora, vamos analisar o componente “entry”. Este componente é uma das principais formas do usuário
entrar com dados no sistema.
A seguir, é apresentado um exemplo de como usar este componente:
import tkinter as tk 
def mostrar_nomes(): 
print("Nome: %s\nSobrenome: %s" % (e1.get(), e2.get())) 
janela = tk.Tk() 
janela.title("Aplicação GUI com o Widget Entry") 
tk.Label(janela,
text="Nome").grid(row=0)
tk.Label(janela,text="Sobrenome").grid(row=1) 
e1 = tk.Entry(janela) 
e2 = tk.Entry(janela) 
e1.grid(row=0, column=1)
e2.grid(row=1, column=1)
tk.Button(janela, text='Sair',
command=janela.quit).grid(row=3,
column=0,
sticky=tk.W,
pady=4)
tk.Button(janela, text='Exibir Dados', command=mostrar_nomes).grid(row=3,
column=1,
sticky=tk.W,
pady=4)
tk.mainloop() 
O código vai produzir uma janela com duas entradas de dados (widgets entry), dois botões e dois
componentes rótulos, conforme podemos ver na Figura 14.
/
 
Fonte: O Autor
Figura 14: Exemplo do componente entry.
Os códigos que estamos apresentando estão evoluindo em termos de aplicações práticas.
No caso do exemplo da Figura 14, com poucas modificações, pode ser aplicado para muitas situações
reais.
Agora, analisaremos os principais aspectos do código.
LINHA 2
É implementada a função “mostrar_nomes”, que vai exibir na linha de comando os nomes que estão
escritos nas instâncias “e1” e “e2” do componente “entry”.
LINHAS 8 E 9
São feitas as instâncias “e1” e “e2” do componente entry.
LINHAS 10 E 11
“e1” e “e2” são posicionados na janela.
LINHAS 12 E 13
São instanciados objetos do componente “botão”. Em especial, na linha 13, a função “mostrar_nomes” é
associada ao comportamento do botão.
WIDGET RADIOBUTTON
O próximo exemplo apresenta como usar o widget “Radiobutton”. O código para gerar uma aplicação com
esse componente é dado por:
import tkinter as tk 
janela = tk.Tk() 
v = tk.IntVar() 
tk.Label(janela, 
text="""Escolha uma linguagem de programação:""",
justify = tk.LEFT, padx = 20).pack()
tk.Radiobutton(janela, 
/
text="Python",
padx = 25,
variable=v,
value=1).pack(anchor=tk.W)
tk.Radiobutton(janela, 
text="C++",
padx = 25,
variable=v,
value=2).pack(anchor=tk.W)
janela.mainloop() 
O código vai produzir uma janela com dois “botões de rádio” (widgets radiobutton), conforme a Figura 15.
 
Fonte: O Autor
 Figura 15: Exemplo do componente radiobutton.
LINHA 4
É instanciado um componente “label” com a parametrização das propriedades “text”, “justify” e “padx” que
correspondem, respectivamente, ao texto, como vai ser justificado e qual a largura em pixels do
componente.
LINHAS 5 E 6
São instanciados os componentes “radiobuttons”. Cabe destacar a propriedade “variable”, que recebe o
valor “v”, que indica que o componente será colocado na vertical.
WIDGET CHECKBOX
O próximo exemplo apresenta como usar o widget “checkbox”. O código para gerar uma aplicação com
esse componente é dado por:
import tkinter as tk 
from tkinter import ttk 
janela = tk.Tk() 
/
def escolha_carreira(): 
print("Gerencial: %d,\nTécnica : %d" % (var1.get(), var2.get())) 
ttk.Label(janela, text="Escolha sua vocação:").grid(row=0, sticky=tk.W) 
var1 = tk.IntVar() 
ttk.Checkbutton(janela, text="Gerencial", variable=var1).grid(row=1, sticky=tk.W) 
var2 = tk.IntVar() 
ttk.Checkbutton(janela, text="Técnica", variable=var2).grid(row=2, sticky=tk.W) 
ttk.Button(janela, text='Sair', command=janela.quit).grid(row=3, sticky=tk.W, pady=4) 
ttk.Button(janela, text='Mostrar', command=escolha_carreira).grid(row=4, sticky=tk.W, pady=4) 
janela.mainloop() 
O código vai produzir uma janela com um “label”, dois “checkboxes” e dois botões, conforme a Figura 16.
 
Fonte: O Autor
 Figura 16: Exemplo do componente checkbox.
Agora, vamos analisar os principais aspectos do código.
LINHA 4
É implementada a função “escolha_carreira”, que vai exibir os valores dos objetos “var1” e “var2” que estão
relacionadas aos “checkboxes”.
LINHAS 7 E 9
São instanciados os objetos “var1” e “var2”, que serão associados aos “checkboxes”. Quando um
“checkbox” for selecionado, o seu respectivo objetivo vai retornar valor 1, caso o componente não seja
selecionado, o valor do objeto será 0.
LINHAS 8 E 10
São instanciados objetos dos componentes “checkboxes”, que são associados, respectivamente, às opções
Gerencial e Técnica.
WIDGET TEXT
/
O próximo exemplo apresenta como usar o widget “Text”. O código para gerar uma aplicação com o
componente “Text” é dado por:
import tkinter as tk 
janela = tk.Tk() 
T = tk.Text(janela, height=2, width=30) 
T.pack() 
T.insert(tk.END, "Este é um texto\ncom duas linhas\n") 
tk.mainloop() 
O código vai produzir uma janela com um texto, conforme a Figura 17.
 
Fonte: O Autor
 Figura 17: Exemplo do componente Text.
Agora, vamos analisar os principais aspectos do código.
LINHA 3
É feita uma instância do componente “Text”.
LINHAS 5
É inserido um texto na instância do componente “text”, que vai ser exibido na tela. Observe que o texto é
separado em duas linhas com o uso do “\n”.
WIDGET MESSAGE
O próximo exemplo apresenta como usar o widget “Message”. O código para gerar uma aplicação com o
componente “Message” é dado por:
import tkinter as tk 
janela = tk.Tk() 
mensagem_para_usuario = "Esta é uma mensagem.\n(Pode ser bastante útil para o usuário)" 
msg = tk.Message(janela, text = mensagem_para_usuario) 
msg.config(bg='lightgreen', font=('times', 24, 'italic')) 
msg.pack() 
janela.mainloop() 
O código vai produzir uma janela com uma mensagem, conforme pode ser visto na Figura 18.
/
 
Fonte: O Autor
 Figura 18: Exemplo do componente Message.
Agora, vamos analisar os principais aspectos do código.
LINHA 4
É instanciado um componente “Message” com uma mensagem para o usuário.
LINHAS 5
O componente é configurado, determinando a cor do “background” e detalhes sobre a fonte da mensagem.
WIDGET SLIDER
O próximo exemplo apresenta como usar o widget “Slider”. O código para gerar uma aplicação com esse
componente é dado por:
import tkinter as tk 
from tkinter import ttk 
def mostrar_valores(): 
print (w1.get(), w2.get()) 
janela = tk.Tk() 
w1 = ttk.Scale(janela, from_=0, to=50) 
w1.pack() 
w2 = ttk.Scale(janela, from_=0, to=100, orient=tk.HORIZONTAL) 
w2.pack() 
ttk.Button(janela, text='Mostrar a Escala', command=mostrar_valores).pack() 
janela.mainloop() 
O código vai produzir uma janela com duas linhas deslizantes, conforme a Figura 19.
/
 
Fonte: O Autor
 Figura 19: Exemplo do componente Slider.
Agora, vamos analisar os principais aspectos do código.
Nas linhas 6 e 8, são instanciados componentes “sliders”.
Além disso, são determinadas as propriedades “from”, “to” e “orient”, que são responsáveis,
respectivamente, pelo espectro de escala componente e a orientação do componente na tela.
WIDGET DIALOG
O próximo exemplo apresenta como usar o widget “Dialog”. O código para gerar uma aplicação com o
componente “Dialog” é dado por:
import tkinter as tk 
from tkinter import messagebox as mb 
def resposta(): 
mb.showerror("Resposta", "Desculpe, nenhuma resposta disponível!") 
def verificacao(): 
if mb.askyesno('Verificar', 'Realmente quer sair?'): 
mb.showwarning('Yes', 'Ainda não foi implementado') 
else: 
mb.showinfo('No', 'A opção de Sair foi cancelada') 
tk.Button(text='Sair', command=verificacao).pack(fill=tk.X) 
tk.Button(text='Resposta', command=resposta).pack(fill=tk.X) 
tk.mainloop() 
O código vai produzir uma janela com dois botões, conforme a Figura 20.
 
Fonte: O Autor
 Figura 20: Exemplo com dois componentes botões.
/
RESPOSTA
Caso o usuário pressione o botão “Resposta”, vai aparecer uma janela com a mensagem “Desculpe,
nenhuma resposta disponível!”, conforme a Figura 21.
 
Fonte: O Autor
 Figura 21: Exemplo do componente MessageDialog.

SAIR
Caso o usuário tenha pressionado o botão “Sair”, vai aparecer uma janela com a mensagem “Realmente
quer sair?”, conforme a Figura 22.
 
Fonte: O Autor
 Figura 22: Segundo exemplo do componente MessageDialog.
YES
/
Caso o usuário pressione o botão “Yes”, vai aparecer uma janela com a mensagem “Ainda não foi
implementado”, conforme a Figura 23.
 
Fonte: O Autor
 Figura 23: Terceiro exemplo do componente MessageDialog.

NO
Por outro lado, se o usuário pressionar o botão “No” da janela da Figura 22, vai ser exibida uma janela com
a mensagem “A opção de Sair foi cancelada”, conforme a Figura 24.
 
Fonte: O Autor
 Figura 24: Quarto exemplo do componente MessageDialog.
Agora, vamos analisar os principais aspectos do código.
Nas linhas 4, 6, 7 e 9, são instanciados componentes “messageDialog”.
/
Esse exemplo é bastante interessante, pois, apesar de pouca implementação, é possível que o usuário
tenha bastante interação com o sistema.
WIDGET COMBOBOX
O próximo exemplo apresenta como usar o widget “Combobox”. O código para gerar uma aplicação com
esse componente é dado por:
import tkinteras tk 
from tkinter import ttk 
# Criação de uma janela tkinter 
janela = tk.Tk() 
janela.title('Combobox') 
janela.geometry('500x250') 
# Componente Label 
ttk.Label(janela, text = "Combobox Widget", 
background = 'green', foreground ="white", 
font = ("Times New Roman", 15)).grid(row = 0, column = 1) 
# Componente Label 
ttk.Label(janela, text = "Selecione um mês :", 
font = ("Times New Roman", 10)).grid(column = 0, 
row = 5, padx = 10, pady = 25) 
# Componente Combobox 
n = tk.StringVar() 
escolha = ttk.Combobox(janela, width = 27, textvariable = n) 
# Adição de itens no Combobox 
escolha['values'] = (' Janeiro', 
' Fevereiro', 
' Março', 
' Abril', 
' Maio', 
' Junho', 
' Julho', 
' Agosto', 
' Setembro', 
' Outubro', 
' Novembro', 
' Dezembro') 
escolha.grid(column = 1, row = 5) 
/
escolha.current() 
janela.mainloop() 
O código vai produzir uma janela com um “combobox”, conforme a Figura 25.
 
Fonte: O Autor
 Figura 25: Exemplo do componente combobox.
Agora, vamos analisar os principais aspectos do código.
LINHA 17
É instanciado um componente “combobox”.
LINHAS 19 A 30
Os meses do ano são atribuídos ao componente.
Agora, o vídeo a seguir dá continuidade e projeta a interface gráfica. No vídeo, serão carregados os widgets
necessários para o funcionamento do protótipo.
VERIFICANDO O APRENDIZADO
/
1. CONSIDERE O FRAGMENTO DE CÓDIGO PYTHON ABAIXO.
1 IMPORT TKINTER 
2 LACUNA_I = LACUNA_II.TK() 
3 LACUNA_III.MAINLOOP()
PARA QUE O CÓDIGO SEJA COMPILADO E EXECUTADO CORRETAMENTE, AS
PALAVRAS LACUNA_I, LACUNA_II E LACUNA_III DEVEM SER SUBSTITUÍDAS,
RESPECTIVAMENTE, POR:
A) tk, janela, tkinter
B) raiz, tkinter, janela
C) tkinter, raiz, janela
D) raiz, tkinter e raiz
E) tkinter, janela e raiz
2. O TKINTER POSSUI DIVERSOS COMPONENTES (WIDGETS) QUE SÃO ÚTEIS
PARA CRIAR APLICAÇÕES QUE VÃO FACILITAR A INTERAÇÃO DO USUÁRIO COM
O SISTEMA. NESSE SENTIDO, SELECIONE A OPÇÃO QUE RELACIONA
CORRETAMENTE OS COMPONENTES E SUAS RESPECTIVAS FUNCIONALIDADES.
A) Button: Fornece para o usuário a possibilidade de selecionar várias opções ao mesmo tempo.
B) Checkbutton: São usados para a confirmação de uma ação.
C) Entry: Exibem uma mensagem de texto para o usuário.
D) Label: É usado para fornecer uma legenda para outros componentes do projeto.
E) Dialog: Vai produzir uma janela com um “combobox”.
GABARITO
1. Considere o fragmento de código Python abaixo.
1 import tkinter 
2 lacuna_I = lacuna_II.Tk() 
3 lacuna_III.mainloop() 
Para que o código seja compilado e executado corretamente, as palavras lacuna_I, lacuna_II e
lacuna_III devem ser substituídas, respectivamente, por:
A alternativa "D " está correta.
/
 
A Tkinter é considerada a biblioteca padrão de interface gráfica do Python. Para que um programa que faz
uso de seus componentes possa rodar, é necessário importar a biblioteca, instanciar um componente
“window” que é a “raiz” da interface gráfica onde os demais componentes serão adicionados e, por fim,
fazer a chamada (invocação) do método “mainloop”.
2. O Tkinter possui diversos componentes (widgets) que são úteis para criar aplicações que vão
facilitar a interação do usuário com o sistema. Nesse sentido, selecione a opção que relaciona
corretamente os componentes e suas respectivas funcionalidades.
A alternativa "D " está correta.
 
O componente “label” é muito útil para fornecer uma explicação a respeito de uma funcionalidade do
sistema, por exemplo, ele pode acompanhar uma caixa de texto (widget entry) com a legenda “nome”, que
dá a entender para o usuário que ele precisa preencher seu próprio nome.
MÓDULO 3
 Definir a interface para inclusão de dados em uma tabela no banco de dados
CONCEITOS
O Python possui muitas bibliotecas para interagir com diversos bancos de dados. Aqui, o foco vai ser dado
na integração com o PostgreSQL. Isso porque pode ser usado gratuitamente, possui bastante
documentação disponível online e pode ser aplicado para resolver problemas reais.
Para explicar como o Python interage com o PostgreSQL, trabalharemos na seguinte aplicação:
/
 
Fonte: O Autor
“Desenvolver um programa em que seja possível realizar as operações CRUD para gerenciar uma agenda
telefônica que vai tratar de nomes e números de telefones”.
CRUD
Acrônimo da expressão do idioma Inglês, Create (Criação), Read (Consulta), Update (Atualização) e
Delete (Destruição).
A ideia é desenvolvermos uma aplicação CRUD, para que os usuários possam interagir com o sistema para
inserir, modificar, consultar e excluir dados de uma agenda telefônica e que essas operações fiquem sob a
responsabilidade do sistema gerenciador de banco de dados.
 DICA
Inicialmente, é necessário ter o PostgreSQL instalado. Os exemplos apresentados aqui foram implementados
na versão 4.24 do PostgreSQL.
O script para criação da tabela é dado por:
CREATE TABLE public."AGENDA" 
( 
id integer NOT NULL, 
nome text COLLATE pg_catalog."default" NOT NULL, 
javascript:void(0)
/
telefone char(12) COLLATE pg_catalog."default" NOT NULL 
) 
TABLESPACE pg_default; 
ALTER TABLE public."AGENDA" 
OWNER to postgres; 
Para testar se a criação da tabela está correta, pode-se inserir um registro da seguinte maneira:
INSERT INTO public."AGENDA"( id, nome, telefone) 
VALUES (1, 'teste 1', '02199999999');
Em seguida, fazemos uma consulta na tabela, conforme abaixo:
SELECT * FROM public."AGENDA"; 
Se tudo funcionar corretamente, vai aparecer a seguinte saída:
 
Fonte: O Autor
Bem, agora, vamos estudar o pacote que será utilizado para que o Python possa interagir com o
PostgreSQL: psycopg2.
 ATENÇÃO
O PostgreSQL pode ser integrado ao Python usando o módulo psycopg2. Trata-se de um adaptador de
banco de dados PostgreSQL. O pacote psycopg2 é simples, rápido e estável.
Para instalá-lo, basta digitar na linha de comando do Python:
pip install psycopg2 
Para poder interagir com o banco de dados PostgreSQL com o uso da biblioteca psycopg2, primeiro é
necessário criar um objeto Connection que representa o banco de dados e, em seguida, pode-se criar um
objeto cursor que será bastante útil para executar todas as instruções SQL. Isso será detalhado um pouco
mais à frente.
Antes disso, porém, vamos apresentar as principais APIs (rotinas de interface de programação) da
psycopg2:
/
PSYCOPG2.CONNECT (DATABASE =
"NOMEDOBANCODEDADOS", USER = "LOGINDOUSUÁRIO",
SENHA = "SENHADOBANCODEDADOS", HOST =
"ENDEREÇODAAPLICAÇÃO", PORTA = "NÚMERODAPORTA")
A conexão com o banco de dados PostgreSQL é feita com essa API. O banco de dados retorna um objeto
de conexão, se o banco de dados for aberto com sucesso. Para aplicações que vão rodar localmente,
utiliza-se o endereço de localhost dado por 127.0.0.1". A porta de comunicação padrão do PostgreSQL é a
"5432", mas esse valor pode ser mudado.
CONNECTION.CURSOR ()
Esta API cria um cursor que será usado ao longo da programação para interagir com o banco de dados com
Python.
CURSOR.EXECUTE (SQL [, PARÂMETROS OPCIONAIS])
Esta rotina é aplicada para executar uma instrução SQL. A instrução SQL pode ser parametrizada. Por
exemplo, seja o trecho de código abaixo:
nomeDaTabela = 'tabelaExemplo' 
cursor.execute( 
"insert into %s values (%%s, %%s)" % nomeDaTabela, 
[10, 20]) 
O comando vai executar a instrução “insert” para inserir os valores 10 e 20 na tabela ‘tabelaExemplo’.
CURSOR.EXECUTEMANY (SQL,
SEQUÊNCIA_DE_PARÂMETROS)
Esta rotina executa um comando SQL em todas as sequências de parâmetros. Por exemplo, seja o trecho
de código:
carros = ( 
(1, 'Celta', 35000), 
(2, 'Fusca', 30000), 
/
(3, 'Fiat Uno', 32000) 
) 
 
con = psycopg2.connect(database='BancoExemplo', user='postgres', 
password='postgres') 
 
cursor = con.cursor() 
 
query = "INSERT INTO cars (id, nome, preco) VALUES (%s, %s, %s)" 
cursor.executemany(query, carros) 
O trecho de código começa com uma lista de três carros, na qual cada carro possui um código de
identificação, nome e um preço.
Em seguida,é feita uma conexão com o banco de dados “BancoExemplo”.
Logo depois, é criado o cursor que vai ser usado para realizar as operações sobre o banco de dados.
Por fim, é executada a rotina “executemany”, sendo que ela recebe uma query e uma lista de carros que
serão inseridos no banco de dados.
CURSOR.CALLPROC
('NOMEDAFUNÇÃO_OU_NOMEDOPROCEDIMENTOARMAZENADO',
[PARÂMETROS IN E OUT,])
Esta rotina faz chamada para uma função, ou procedimento armazenado do banco de dados. Os
parâmetros IN e OUT correspondem, respectivamente, aos parâmetros de entrada e saída da função, ou
procedimento armazenado e devem ser separados por vírgulas.
CURSOR.ROWCOUNT
Este atributo retorna o número total de linhas do banco de dados que foram modificadas, inseridas ou
excluídas pela última instrução de “execute“.
CONNECTION.COMMIT()
/
Este método confirma a transação atual. É necessário que ele seja chamado ao final de uma sequência de
operações sql, pois, caso contrário, tudo o que foi feito desde a última chamada até o “commit” não será
visível em outras conexões de banco de dados.
CONNECTION.ROLLBACK()
Este método reverte quaisquer mudanças no banco de dados desde a última chamada até o “commit”.
CONNECTION.CLOSE()
Este método fecha a conexão com o banco de dados. Ele não chama o “commit” automaticamente. Se a
conexão com o banco de dados for fechada sem chamar o “commit” primeiro, as alterações serão perdidas.
CURSOR.FETCHONE()
Este método busca a próxima linha de um conjunto de resultados de consulta, retornando uma única
sequência, ou nenhuma, quando não há mais dados disponíveis.
CURSOR.FETCHMANY([SIZE = CURSOR.ARRAYSIZE])
Esta rotina busca o próximo conjunto de linhas de um resultado de consulta, retornando uma lista. Uma lista
vazia é retornada quando não há mais linhas disponíveis. O método tenta buscar quantas linhas forem
indicadas pelo parâmetro “size”.
CURSOR.FETCHALL()
Esta rotina busca todas as linhas (restantes) de um resultado de consulta, retornando uma lista. Uma lista
vazia é retornada quando nenhuma linha está disponível.
UM EXEMPLO COMPLETO
/
Agora, apresentaremos um exemplo completo de como usar o psycopg2. O exemplo vai abordar:
Criação de uma tabela
Inserção de dados
Seleção de dados
Atualização de dados
Exclusão de dados
Agora, vamos aos exemplos que implementam as operações CRUD.
CRIAÇÃO DE TABELA
Este primeiro código mostra como criar uma tabela a partir do Python. É uma alternativa em relação a criar
a tabela usando o PostgreSQL.
import psycopg2 
conn = psycopg2.connect(database = "postgres", user = "postgres", password = "senha123", host =
"127.0.0.1", port = "5432") 
print("Conexão com o Banco de Dados aberta com sucesso!") 
cur = conn.cursor() 
cur.execute('''CREATE TABLE Agenda 
(ID INT PRIMARY KEY NOT NULL, 
Nome TEXT NOT NULL, 
Telefone CHAR(12));''') 
print("Tabela criada com sucesso!") 
conn.commit() 
conn.close() 
Depois de colocar o programa para executar, se tudo funcionar corretamente, aparecerão as mensagens na
tela:
Conexão com o Banco de Dados feita com Sucesso!
Tabela criada com sucesso!
Agora, vamos analisar o código.
LINHAS 1
É feita a importação da biblioteca psycopg2.
LINHA 2
/
É feita a conexão com o banco de dados. Observe os parâmetros da função “connect”, pois é necessário
que você crie um banco no PostgreSQL com usuário e senha, conforme escrito na função.
LINHA 3
É exibida uma mensagem de sucesso para o usuário.
LINHA 4
É criado o cursor que vai permitir realizar operações no banco de dados.
LINHA 5
Executa o comando SQL para criar a tabela “Agenda” com os campos “ID”, “Nome” e “Telefone”.
LINHA 9
É exibida uma mensagem de criação da tabela com sucesso.
LINHA 10
É executada a função “commit” para confirmar a execução das operações SQL.
LINHAS 11
Por fim, é fechada a conexão com o banco de dados.
INSERÇÃO DE DADOS NA TABELA
O exemplo desse código mostra como inserir um registro em uma tabela a partir do Python usando a
biblioteca psycopg2.
import psycopg2 
conn = psycopg2.connect(database = "postgres", user = "postgres", password = " senha123", host =
"127.0.0.1", port = "5432") 
print ("Conexão com o Banco de Dados aberta com sucesso!") 
cur = conn.cursor() 
cur.execute("""INSERT INTO public."AGENDA" ("id", "nome", "telefone") VALUES (1, 'Pessoa 1',
'02199999999')""") 
conn.commit() 
print("Inserção realizada com sucesso!"); 
conn.close() 
As mensagens que vão aparecer depois da execução do programa são:
Conexão com o Banco de Dados feita com Sucesso!
Inserção realizada com sucesso!
/
Vamos analisar o código.
LINHAS 1 A 4
São realizadas as mesmas operações do exemplo anterior: Importação da biblioteca “psycopg2”, abrir a
conexão com o banco de dados “postgres” e impressão da mensagem “Conexão aberta com sucesso!”.
LINHA 5
É executado o comando SQL para inserir dados na tabela AGENDA.
No caso, o registro é formado pelos seguintes dados: O campo “id” recebe o valor 1, o campo “nome”
recebe o valor ‘Pessoa 1’ e, por fim, o campo “telefone” recebe o valor ‘02199999999’.
Essa linha tem mais algumas questões que merecem destaque: O uso de aspas simples e duplas.
No caso do banco de dados PostgreSQL, o nome da tabela e dos campos deve estar entre aspas duplas,
por causa disso é que o comando insert possui três aspas duplas logo no início e no final. Sendo assim,
muita atenção com isso, pois existem algumas variações conforme o sistema gerenciador de banco
de dados escolhido.
LINHAS 6 A 8
Do mesmo modo como foi realizado no exemplo de criação da tabela “Agenda”, são realizadas as seguintes
operações: “commit” das operações do banco de dados, fechamento da conexão com o banco de dados,
impressão na linha de comando da mensagem “Inserção realizada com sucesso!”.
SELEÇÃO DE DADOS NA TABELA
Antes de descrever o exemplo de seleção de dados, já podemos perceber algo em comum em todas as
operações dos códigos para trabalhar com banco de dados no início do código:
Importação da biblioteca “psycopg2”.

Abertura da conexão com o banco de dados “postgres”.
POSTGRES
Perceba que esse nome não é do sistema gerenciador de banco de dados, e sim um nome que
escolhemos. Poderia ser, por exemplo, “banco_dados_teste”.
javascript:void(0)
/
E no final do código:
“Commit” das operações realizadas no banco de dados para confirmar a execução delas. Esse comando é
obrigatório.

Fechamento da conexão com o banco de dados.
Agora, vamos analisar o código que mostra como selecionar um registro em uma tabela a partir da
biblioteca psycopg2 do Python.
import psycopg2 
conn = psycopg2.connect(database = "postgres", user = "postgres", password = " senha123", host =
"127.0.0.1", port = "5432") 
print ("Conexão com o Banco de Dados aberta com sucesso!") 
cur = conn.cursor() 
cur.execute("""select * from public."AGENDA" where "id" = 1""") 
registro = cur.fetchone() 
print(registro) 
conn.commit() 
print("Seleção realizada com sucesso!"); 
conn.close() 
Depois de colocar o programa para executar, se tudo funcionar corretamente, aparecerão as mensagens na
tela:
Conexão com o Banco de Dados feita com Sucesso!
(1, 'Pessoa 1', '02199999999 ')
Tabela criada com sucesso!
Vamos analisar os trechos mais importantes do código.
LINHA 5
É feita a consulta na tabela “Agenda” pelo registro com “id” igual a 1, através do comando Select do SQL.
LINHA 6
É executado o método “fetchone” que recupera exatamente um registro do “cursor” e atribui para a variável
“registro”.
LINHA 7
É impresso na linha de comando o resultado da consulta armazenado na variável “registro”.
/
ATUALIZAÇÃO DE DADOS NA TABELA
Este exemplo mostra como atualizar os registros de uma tabela a partir do Python.
import psycopg2 
conn = psycopg2.connect(database = "postgres", user = "postgres", password = "senha123", host =
"127.0.0.1", port = "5432") 
print ("Conexão com o Banco de Dados aberta com sucesso!") 
cur = conn.cursor() 
print("Consulta antes da atualização") 
cur.execute("""select * from public."AGENDA"where "id" = 1""") 
registro = cur.fetchone() 
print(registro) 
#Atualização de um único registro 
cur.execute("""Update public."AGENDA" set "telefone" = '02188888888' where "id" = 1""") 
conn.commit() 
print("Registro Atualizado com sucesso! ") 
cur = conn.cursor() 
print("Consulta depois da atualização") 
cur.execute("""select * from public."AGENDA" where "id" = 1""") 
registro = cur.fetchone() 
print(registro) 
conn.commit() 
print("Seleção realizada com sucesso!"); 
conn.close() 
Este código possui três partes distintas, que são:
ETAPA 01
Uma consulta antes da atualização: Que mostra os dados do registro antes de serem modificados.
ETAPA 02
A atualização do registro que vai modificar os dados.
ETAPA 03
Uma consulta depois da atualização do registro: Que mostra como ficaram os dados do registro depois de
serem atualizados.
 ATENÇÃO
javascript:void(0)
javascript:void(0)
javascript:void(0)
/
A linha 10 é a mais importante deste código. É nela que é executado o comando “update” do sql, que vai
atualizar o dado do campo “telefone” do registro, cujo campo “id” contenha o valor “1”.
Perceba, ainda, que é associado o comando “commit” para o comando “update” do sql na linha 11.
EXCLUSÃO DE DADOS NA TABELA
Por fim, vamos ver o exemplo para excluir um registro de uma tabela.
import psycopg2 
conn = psycopg2.connect(database = "postgres", user = "postgres", password = "senha123", host =
"127.0.0.1", port = "5432") 
print ("Conexão com o Banco de Dados aberta com sucesso!") 
cur = conn.cursor() 
cur.execute("""Delete from public."AGENDA" where "id" = 1""") 
conn.commit() 
cont = cur.rowcount 
print(cont, "Registro excluído com sucesso! ") 
print("Exclusão realizada com sucesso!"); 
conn.close() 
Depois de colocar o programa para executar, se tudo funcionar corretamente, aparecerão as mensagens na
tela:
Conexão com o Banco de Dados aberta com Sucesso!
1 Registro excluído com sucesso!
Exclusão realizada com sucesso!
Vamos analisar as partes mais importantes do código.
LINHA 5
É executado o comando “delete” do sql que vai excluir o registro cujo campo “id” seja igual a “1”.
LINHA 7
A propriedade “rowcount” do “cursor” retorna a quantidade de registros que foram excluídos da tabela
“Agenda”.
LINHA 8
É impresso na linha de comando o total de registros que foram excluídos.
/
 VOCÊ SABIA
Outras bibliotecas para interface com banco de dados.
Além da biblioteca psycopg2, existem outras bibliotecas para trabalhar com vários sistemas gerenciadores de
banco de dados. Por exemplo:
pyMySQL: Biblioteca que faz interface com o mysql.
cx_Oracle: Biblioteca que faz interface com o oracle.
PySqlite: Biblioteca que faz interface com o sqlite.
PyMongo: Biblioteca que faz interface com o mongodb, que é um banco de dados NoSQL.
O vídeo a seguir dá continuidade ao desenvolvimento do protótipo do sistema, apresentando a modelagem
do banco de dados a ser utilizado, criando o banco e fazendo as inserções/atualizações/remoções
necessárias.
VERIFICANDO O APRENDIZADO
1. CONSIDERE O FRAGMENTO DE CÓDIGO PYTHON ABAIXO QUE UTILIZA A
BIBLIOTECA “PSYCOPG2” PARA FAZER OPERAÇÕES NO SISTEMA
GERENCIADOR DE BANCO DE DADOS POSTGRE:
1 IMPORT PSYCOPG2 
2 CONN = PSYCOPG2.CONNECT(DATABASE = "POSTGRES", USER =
"POSTGRES", PASSWORD = " SENHA123", HOST = "127.0.0.1", PORT = "5432") 
/
3 CURSOR = CONN.CURSOR() 
4 CURSOR.EXECUTE("""LACUNA_I INTO PUBLIC."AGENDA" ("ID", "NOME",
"TELEFONE") VALUES (1, 'PESSOA 1', '02199999999')""") 
5 CONN. LACUNA_II() 
6 PRINT("INSERÇÃO REALIZADA COM SUCESSO!"); 
7 CONN.LACUNA_III() 
PARA QUE O CÓDIGO SEJA COMPILADO E EXECUTADO CORRETAMENTE, AS
PALAVRAS LACUNA_I, LACUNA_II E LACUNA_III DEVEM SER SUBSTITUÍDAS,
RESPECTIVAMENTE, POR:
A) UPDATE, connect, close
B) INSERT, fetchone, finally
C) INSERT, commit, close
D) INSERT, cursor e close
E) UPDATE, commit, close
2. EXISTEM MUITAS BIBLIOTECAS DISPONÍVEIS PARA PYTHON PARA FAZER
INTERFACE COM SISTEMAS GERENCIADORES DE BANCOS DE DADOS. ENTRE
ELAS, ESTÁ A “PSYCOPG2”. ESTA BIBLIOTECA FAZ INTERFACE COM O
POSTGRESQL, QUE É UM SISTEMA IMPORTANTE PARA DESENVOLVER
APLICAÇÕES REAIS. NESSE SENTIDO, SELECIONE A OPÇÃO QUE RELACIONA B
AS APIS DO PSYCOPG2 E SUAS FUNCIONALIDADES.
A) cursor.rowcount: Indica se o comando sql – inserção, ou exclusão - foi executado com sucesso.
B) connection.commit(): Abre a conexão com o banco de dados.
C) cursor.execute: É aplicada para executar uma instrução SQL.
D) connection.close(): Limpa as variáveis que estão associadas a operações com o banco de dados.
E) cursor.execute: Fecha a conexão com o banco de dados.
GABARITO
1. Considere o fragmento de código Python abaixo que utiliza a biblioteca “psycopg2” para fazer
operações no sistema gerenciador de banco de dados Postgre:
1 import psycopg2 
2 conn = psycopg2.connect(database = "postgres", user = "postgres", password = " senha123", host
/
= "127.0.0.1", port = "5432") 
3 cursor = conn.cursor() 
4 cursor.execute("""lacuna_I INTO public."AGENDA" ("id", "nome", "telefone") VALUES (1, 'Pessoa
1', '02199999999')""") 
5 conn. lacuna_II() 
6 print("Inserção realizada com sucesso!"); 
7 conn.lacuna_III() 
Para que o código seja compilado e executado corretamente, as palavras lacuna_I, lacuna_II e
lacuna_III devem ser substituídas, respectivamente, por:
A alternativa "C " está correta.
 
A palavra-chave “INTO” está relacionada ao comando “INSERT” do sql. Após a execução de um comando
sql, é necessário confirmá-lo através do comando “commit”. No final da execução de um programa, deve-se
fechar a conexão com o banco de dados com o comando “close”.
2. Existem muitas bibliotecas disponíveis para Python para fazer interface com sistemas
gerenciadores de bancos de dados. Entre elas, está a “psycopg2”. Esta biblioteca faz interface com
o PostgreSQL, que é um sistema importante para desenvolver aplicações reais. Nesse sentido,
selecione a opção que relaciona B as APIs do psycopg2 e suas funcionalidades.
A alternativa "C " está correta.
 
O comando “execute” é fundamental para executar as instruções do sql para fazer inserção, consulta,
atualização e exclusão de registros no banco de dados.
MÓDULO 4
 Identificar a interface para localização, alteração e exclusão de dados em tabela
CONCEITOS
Até o dado momento, vimos como criar uma aplicação com componentes de interface gráfica e como
interagir com um banco de dados.
Neste módulo, criaremos uma aplicação que integra tanto elementos de interface gráfica quanto operações
com banco de dados.
/
A nossa aplicação implementa as operações CRUD, que são: Inserção, seleção, atualização e exclusão de
dados.
O usuário vai fazer a entrada de dados através de componentes de caixas de texto (widget entry) e
confirmar a ação que deseja, quando pressionar o botão correspondente.
Além disso, os dados que estão armazenados no banco são exibidos em um componente do tipo grade
(widget treeview). O usuário tem a possibilidade de selecionar um registro na grade e ele será exibido nas
caixas de texto, onde poderão ser modificados ou excluídos.
Na Figura 26, está a interface gráfica da nossa aplicação.
 
Fonte: O Autor
 Figura 26: Interface da aplicação com Tkinter.
 ATENÇÃO
Perceba que alguns dados já estão armazenados no banco e são exibidos na grade. Outra coisa, veja que o
usuário selecionou o “produto_7” na grade e seus dados estão exibidos nas caixas de texto.
CRIAÇÃO DA TABELA NO POSTGRESQL
A primeira ação a ser feita é a criação da tabela.
/
 COMENTÁRIO
No caso do nosso sistema, vamos criar a tabela Produto, que tem três campos, que são “CODIGO”, “NOME”
e “PRECO”.
Estamos usando o PostgreSQL para gerenciar os nossos dados. O PostgreSQL é um sistema gerenciador
de banco de dados de licença gratuita e é considerado bastante robusto para aplicações de um modo geral.
Através da ferramenta pgAdmin, o desenvolvedor pode criar a tabela produto.
Na Figura 27, vemos como criar uma tabela no pgAdmin.
 
Fonte: O Autor
 Figura 27: Criação detabela no pgAdmin.
O campo “owner” é o usuário proprietário do banco de dados que terá acesso à tabela “PRODUTO”. No
caso, usamos o usuário padrão do PostgreSQL.
Em seguida, precisamos criar os campos tabelas. Para isso, selecionamos a opção “Columns” da Figura 27.
Agora, vai ser exibida a tela da Figura 28, na qual podemos adicionar as colunas através da opção “+” no
canto superior direito da tela.
/
 
Fonte: O Autor
 Figura 28: Criação dos campos da tabela no pgAdmin.
Perceba que o campo “CODIGO” é a chave primária da tabela e, além disso, todos os campos não podem
ser vazios.
Agora, salvamos a tabela e, finalmente, ela é criada no banco de dados. Na Figura 29, podemos ver a
tabela no pgAdmin.
 
Fonte: O Autor
 Figura 29: Visualização da tabela no pgAdmin.
O pgAdmin é bastante útil para fazermos operações sobre as tabelas. Na Figura 30, mostramos como
inserir dados na tabela “PRODUTO”.
/
 
Fonte: O Autor
 Figura 30: Inserção de dados no pgAdmin.
Para executar o comando de inserção, basta pressionar a seta no canto direito superior da tela.
Outra forma de criar uma tabela é através do próprio Python, com o uso da biblioteca “psycopg2”.
Na Figura 31, mostramos o código para criação da tabela “PRODUTO”. O código para criação da tabela
pode ser baixado clicando aqui.
 
Fonte: O Autor
 Figura 31: Criação de tabela no Python.
Agora, cada uma das linhas será analisada.
LINHA 8
Importamos a biblioteca psycopg2.
LINHA 9
Fazemos a conexão ao banco de dados “postgres” com o usuário “postgres”, senha “senha123”, host local
(127.0.0.1) e porta “5432”.
LINHA 13
Abrimos o cursor. Lembre-se de que é com o cursor que fazemos as operações no banco de dados.
LINHAS 14 A 16
/
Executamos o comando sql “Create Table” para criar a tabela “PRODUTO” com os campos “CODIGO”,
“NOME” e “PRECO”.
LINHA 18
Executamos o comando “commit” para confirmar o comando sql.
LINHA 19
Fechamos a conexão com o banco de dados.
GERAÇÃO DE DADOS ALEATÓRIOS
Uma boa forma de iniciar o projeto é inserindo dados aleatórios na tabela. Para isso, vamos usar o pacote
“faker”, que é bastante útil para gerar dados aleatórios.
Na Figura 32, mostramos o código para gerar os dados aleatórios.
 
Fonte: O Autor
 Figura 32: Geração de dados aleatórios.
LINHA 15
Importamos a biblioteca “faker”.
LINHA 22
Instanciamos um objeto para gerar dados aleatórios no “português do Brasil”.
LINHAS 25 A 31
Geramos os dados aleatórios que serão inseridos na tabela.
LINHAS 34 E 35
/
Montamos o comando sql. Mas nesse momento, trata-se apenas de um texto (string) que deve seguir uma
sintaxe cuidadosa: Três aspas duplas no início e no final do texto. Além disso, perceba os “%s” no trecho do
“VALUES” que serão usados para entrar com os dados das variáveis.
LINHA 36
Criamos um registro com as variáveis que serão armazenadas na tabela.
LINHA 37
Aplicamos o comando “execute”, que executa o comando sql com a entrada de dados que definimos na
variável registro.
 COMENTÁRIO
Esse exemplo é simples, mas ilustra testes que podem ser feitos logo no começo do projeto que são úteis
para validar a entrada de dados, além de ser útil para os desenvolvedores aprenderem mais sobre o próprio
sistema.
INTERAÇÃO COM O BANCO DE DADOS
Nesta seção, apresentaremos a parte do sistema responsável pelas operações CRUD.
O sistema foi desenvolvido usando programação orientada a objetos. O arquivo do programa foi salvo com
o nome “crud.py”. (./docs/crud.zip)
A classe com os métodos para realizar as operações para interagir com o banco de dados é a “AppBD”,
conforme podemos ver na Figura 33.
 
Fonte: O Autor
javascript:void(0);
/
 Figura 33: Classe para operações CRUD.
Antes de continuar, lembre-se de que a indentação (espaçamento) faz parte da sintaxe do Python.
LINHA 12
Declaramos a classe “AppBD”.
LINHA 13
Implementamos o construtor da classe, que é o método que é chamado logo que um objeto da classe
AppBD for instanciado.
LINHAS 16 A 25
Implementamos o método para abrir a conexão. Perceba as cláusulas “try” e “except”. Isso é fundamental
para criar um programa confiável, ou seja, com tolerância a falhas, pois o programa tenta seguir o fluxo
normal de execução, ou seja, abrir a conexão com o banco de dados.
 COMENTÁRIO
Caso ocorra algum problema, ao invés de o programa interromper a execução e exibir uma mensagem de
erro, que pode revelar vulnerabilidades do sistema, que podem ser exploradas por um atacante, vai exibir
uma mensagem amigável para o usuário, no caso, será “Falha ao se conectar ao Banco de Dados”.
O próximo método é o que faz consulta no banco de dados, conforme podemos ver na Figura 34.
 
Fonte: O Autor
 Figura 34: Seleção de dados.
Vamos destacar os principais pontos do método “selecionarDados”.
/
LINHA 35
Montamos a instrução de consulta do sql.
LINHA 38
Executamos a instrução sql.
LINHA 39
Recuperamos as linhas que retornaram da consulta sql.
LINHA 52
Retornamos os registros para quem faz a chamada para o método “selecionarDados”.
Agora, vamos explicar o método para fazer a inserção de dados. O código do método está na Figura 35.
 
Fonte: O Autor
 Figura 35: Inserção de dados.
LINHA 56
Implementamos a função “inserirDados” e passamos como parâmetros os “codigo”, “nome” e “preco” que
serão inseridos na tabela. Além disso, passamos o parâmetro “self”, que é usado para fazer referência aos
atributos e métodos da própria classe.
LINHAS 60 E 61
Montamos a instrução sql para fazer a inserção dos dados.
LINHA 62
Montamos o registro que será inserido na tabela.
LINHA 63
Executamos a instrução sql para fazer a inserção do registro da variável “record_to_insert”.
/
Agora, vamos analisar o método responsável pela atualização de dados. O código é apresentado na Figura
36.
 
Fonte: O Autor
 Figura 36: Atualização dos dados.
LINHA 80
Implementamos a função “atualizarDados” e passamos como parâmetros os “codigo”, “nome” e “preco” que
serão modificados na tabela.
LINHAS 92 E 93
Montamos a instrução sql para fazer a modificação dos dados da tabela.
LINHA 94
Executamos a instrução sql para fazer a modificação do registro de acordo com a tupla “(nome, preco,
codigo)”.
Agora, vamos analisar o método que trata da exclusão de dados. O código é apresentado na Figura 37.
/
 
Fonte: O Autor
 Figura 37: Exclusão de dados.
LINHA 116
Implementamos a função “excluirDados” e passamos o “codigo” do produto, que será excluído da tabela.
LINHAS 121 E 122
Montamos a instrução sql para fazer a exclusão dos dados da tabela.
LINHA 123
Executamos a instrução sql para fazer a exclusão do registro de acordo com o parâmetro “codigo” passado
para o método.
INTERFACE GRÁFICA
Nesta seção, vamos apresentar a parte do sistema responsável pela interação com o usuário através de
uma interface gráfica.
Do mesmo modo que a classe “AppBD”, esse programa também foi desenvolvido em programação
orientada a objetos.
O arquivo do programa foi salvo com o nome “aplicacaoCRUD.py”. A classe com os atributos e métodos
para trabalhar com a interface gráfica e interagir com a classe responsável pelas operações com o banco
de dados é a “PrincipalBD”, conforme podemos ver na Figura 38. (./docs/aplicacaoCRUD.zip)
javascript:void(0);
/
 
Fonte: O Autor
 Figura 38: Classe principal.
LINHA 9
Importamos a biblioteca Tkinter para interagir com os componentes gráficos.
LINHAS 10
Importamos o módulo ttk para podermos trabalhar com o componente “TreeView”, que foi usado como uma
grade para exibir os dados armazenados na tabela “PRODUTO”.
LINHAS 14
Implementamos o construtor ( __init__ ) da classe PrincipalBD, que será chamado logo que um objeto do
tipo PrincipalBD for instanciado.
LINHAS 17 A 23
Instanciamos os componentes rótulos (“label”) e caixas de texto (“entry”).
LINHAS 24 A 27
Instanciamos os componentes botões (“button”), que vão acionar as operações CRUD.
 ATENÇÃO
Observe que os métodos “fCadastrarProduto”, “fAtualizarProduto”, “fExcluirProduto” e “fLimparProduto” estão
vinculadosaos botões, ou seja, quando o usuário pressionar um botão, o respectivo método será chamado.
O construtor ainda possui mais duas partes. Uma delas é responsável por instanciar e configurar o
componente “TreeView”, conforme podemos ver na Figura 39.
/
 
Fonte: O Autor
 Figura 39: Configuração do componente Treeview.
Observe nas linhas 52 e 53 que o método “apresentarRegistrosSelecionados” é vinculado à instância do
componente “TreeView”. Esse método será explicado mais à frente.
E a outra posiciona os componentes na tela, conforme podemos ver na Figura 40.
 
Fonte: O Autor
 Figura 40: Configuração de componentes.
Observe que, na linha 73, fazemos chamada para o método “carregarDadosIniciais”. Mais à frente, vamos
explicá-lo com mais detalhes.
Agora, vamos analisar o método “apresentarRegistrosSelecionados”, conforme podemos ver na Figura 41.
 
Fonte: O Autor
/
 Figura 41: Exibir dados selecionados no Treeview.
Este método exibe os dados selecionados na grade (componente “TreeView”) nas caixas de texto, de modo
que o usuário possa fazer alterações, ou exclusões sobre eles.
LINHA 76
Fazemos a chamada para a função “fLimparTela”, que limpa o conteúdo das caixas de texto.
LINHA 77
Obtemos os registros que foram selecionados na grade de registros.
LINHA 79
Os dados do item selecionados são, agora, associados às variáveis “codigo”, “nome” e “preco”.
LINHAS 80 A 82
Os valores das variáveis são associados às caixas de texto.
Agora, vamos analisar o método “carregarDadosIniciais”, que é apresentado na Figura 42.
 
Fonte: O Autor
 Figura 42: Carregar dados da tabela no Treeview.
Este método carrega os dados que já estão armazenados na tabela para serem exibidos na grade de dados
(componente “TreeView”).
LINHAS 86 E 87
Os atributos “id” e “iid” são iniciados com valor 0. Eles são necessários para gerenciar o componente
“TreeView”.
LINHA 88
É feita a chamada para o método “selecionarDados” que está na classe “AppBD”. Ele recupera todos os
registros armazenados na tabela.
/
LINHAS 91 A 93
Obtemos os valores dos registros e associamos às respectivas variáveis.
LINHAS 98 A 102
Os dados são adicionados ao componente “TreeView”.
Agora, vamos apresentar o método “fLerCampos”, conforme podemos ver na Figura 43.
 
Fonte: O Autor
 Figura 43: Entrada de dados.
Este método lê os dados que estão nas caixas de texto e os retorna para quem faz a chamada.
Por exemplo, na linha 114, a variável “codigo” recebe o valor da caixa de texto “txtCodigo” depois que ele é
convertido para um valor do tipo “inteiro”.
Na linha 123, as variáveis “codigo”, “nome” e “preco” retornam para quem faz a chamada do método.
Agora, vamos apresentar o método “fCadastrarProduto”, conforme podemos ver na Figura 44.
 
Fonte: O Autor
 Figura 44: Inserção de dados no banco.
Este método tem como objetivo fazer a inserção dos dados na tabela “PRODUTOS”.
LINHA 130
Os dados digitados nas caixas de texto são recuperados nas variáveis “codigo”, “nome” e “preco”.
LINHA 131
/
Fazemos a chamada ao método “inserirDados”, que fará a inserção dos dados na tabela “PRODUTO”.
LINHAS 132 A 136
Os dados são inseridos no componente grade (“TreeView”).
Agora, vamos analisar o método “fAtualizarProduto”, conforme podemos ver na Figura 45.
 
Fonte: O Autor
 Figura 45: Atualização de dados no banco.
O objetivo deste método é atualizar os dados que o usuário selecionou na grade de dados (o componente
“TreeView”).
LINHA 149
Os dados selecionados da grade de dados são recuperados nas variáveis “codigo”, “nome” e “preco”.
LINHA 150
Chamamos a função “atualizarDados”, que fará as modificações dos dados na tabela “PRODUTO”.
LINHA 152
Os dados selecionados são removidos da grade de dados.
LINHA 153
Fazemos a chamada ao método “carregarDadosIniciais” para recarregar a grade de dados com os dados da
tabela.
Agora, vamos analisar o método “fExcluirProduto”, conforme podemos ver na Figura 46.
 
Fonte: O Autor
 Figura 46: Exclusão de dados no banco.
/
O objetivo deste método é excluir os dados que o usuário selecionou na grade de dados (o componente
“TreeView”).
LINHA 164
Os dados selecionados da grade de dados são recuperados nas variáveis “codigo”, “nome” e “preco”.
LINHA 165
Chamamos a função “excluirDados”, que vai excluir os dados da tabela “PRODUTO”.
LINHA 167
Os dados selecionados são removidos da grade de dados.
LINHA 169
Fazemos a chamada ao método “carregarDadosIniciais” para recarregar a grade de dados com os dados da
tabela.
Agora, vamos analisar o método “fLimparTela”, conforme podemos ver na Figura 47.
 
Fonte: O Autor
 Figura 47: Limpar os componentes da tela.
Este método limpa o conteúdo das caixas de texto, conforme podemos ver nas linhas 179 a 181.
Por fim, apresentamos o programa principal que vai iniciar a execução do sistema, conforme podemos ver
na Figura 49.
 
Fonte: O Autor
 Figura 49: Programa principal.
LINHA 188
Instanciamos o objeto raiz da aplicação gráfica que chamamos de “janela”.
LINHA 189
Instanciamos o objeto principal que vai gerenciar a execução da aplicação.
/
LINHA 190
Escrevemos uma mensagem para o título da janela.
LINHA 191
Configuramos as dimensões da janela.
LINHA 192
Chamamos o método “mainloop”, que coloca a aplicação para executar até que o usuário interrompa a
execução.
Acompanhe no vídeo a seguir a finalização da construção do protótipo do sistema utilizando a linguagem
Python, uma interface GUI e a conexão ao banco de dados.
VERIFICANDO O APRENDIZADO
1. CONSIDERE O FRAGMENTO DE CÓDIGO PYTHON ABAIXO QUE UTILIZA A
BIBLIOTECA “PSYCOPG2” PARA FAZER CRIAR A TABELA PRODUTOV2 NO
POSTGRESQL:
 1 IMPORT PSYCOPG2 
 2 LACUNA_I 
 3 CONN = PSYCOPG2.CONNECT(DATABASE = "POSTGRES", USER =
"POSTGRES", PASSWORD = "SENHA123", HOST = "127.0.0.1", PORT = "5432") 
 4 PRINT("CONEXÃO COM O BANCO DE DADOS ABERTA COM SUCESSO!") 
 5 CUR = CONN.CURSOR() 
 6 CUR.EXECUTE('''CREATE TABLE PRODUTOV2 
 7 (CODIGO INT PRIMARY KEY NOT NULL, 
 8 NOME TEXT NOT NULL, 
/
 9 PRECO CHAR(12));''') 
10 PRINT("TABELA CRIADA COM SUCESSO!") 
11 LACUNA_II 
12 CONN.COMMIT() 
13 CONN.CLOSE() 
SELECIONE A OPÇÃO CORRETA, PARA QUE O PROGRAMA EXECUTE
CORRETAMENTE:
A) As palavras lacuna_I e lacuna_II devem ser substituídas por “#” (símbolo de comentário), pois não
afetam a execução do programa.
B) O tipo campo “PRECO” deve ser modificado para “REAL NOT NULL”, caso contrário vai ocorrer um erro
na criação da tabela.
C) As palavras lacuna_I e lacuna_II devem ser substituídas por “try:” e “except (Exception, psycopg2.Error)
as error:” para prevenir a ocorrência de exceções.
D) A tabela deve ser renomeada para “PRODUTO”, ao invés de “PRODUTOv2”.
E) As palavras lacuna_I e lacuna_II devem ser substituídas por “Begin”, para marcar o início do programa,
e “End”, para indicar o fim do trecho sql.
2. DURANTE A EXECUÇÃO DE UM PROGRAMA EM PYTHON PODEM OCORRER
PROBLEMAS QUE, SE NÃO FOREM TRATADOS ADEQUADAMENTE, VÃO
INTERROMPER O PROGRAMA E EXIBIR UMA MENSAGEM DE ERRO PARA O
USUÁRIO SEM NENHUM TIPO DE TRATAMENTO. NESSE SENTIDO, SELECIONE A
OPÇÃO CORRETA QUE APRESENTA A FORMA ADEQUADA DE TRATAR
EXCEÇÕES NO PYTHON:
A) if-else
B) try-except
C) if-elif
D) try-catch
E) if-else
GABARITO
1. Considere o fragmento de código Python abaixo que utiliza a biblioteca “psycopg2” para fazer
CRIAR a tabela PRODUTOv2 no PostgreSQL:
/
 1 import psycopg2 
 2 lacuna_I 
 3 conn = psycopg2.connect(database = "postgres", user = "postgres", password = "senha123",
host = "127.0.0.1", port = "5432") 
 4 print("Conexão com o Banco de Dados aberta com sucesso!") 
 5 cur = conn.cursor() 
 6 cur.execute('''CREATE TABLE PRODUTOv2 
 7 (CODIGO INT PRIMARY KEY NOT NULL, 
 8 NOME TEXT NOT NULL, 
 9 PRECO CHAR(12));''') 
10 print("Tabela criada com sucesso!") 
11 lacuna_II 
12 conn.commit() 
13 conn.close() 
Selecione a opção correta, para que o programa execute corretamente:
A alternativa "C " está correta.
 
Apesar de não serem obrigatórias,as cláusulas “try-except” previnem a ocorrência de exceções, evitando
que o programa seja interrompido abruptamente, caso ocorra algum problema.
2. Durante a execução de um programa em Python podem ocorrer problemas que, se não forem
tratados adequadamente, vão interromper o programa e exibir uma mensagem de erro para o
usuário sem nenhum tipo de tratamento. Nesse sentido, selecione a opção correta que apresenta a
forma adequada de tratar exceções no Python:
A alternativa "B " está correta.
 
A cláusula “try” tenta executar o fluxo normal do programa. Caso ocorra algum problema, a cláusula
“except” permite tratar a exceção e exibir uma mensagem amigável para o usuário sem a interrupção do
programa. O Python não obriga o uso das cláusulas “try-except”, mas trata-se de uma boa prática de
programação.
CONCLUSÃO
CONSIDERAÇÕES FINAIS
/
No decorrer do texto, apresentamos os principais frameworks e bibliotecas para desenvolver aplicações de
interface gráfica, exploramos a biblioteca “tkinter” com exemplos para usar os seus componentes gráficos e
também a biblioteca “psycopg2”, para realizar operações no PostgreSQL, além de apresentarmos uma
aplicação que integra interface gráfica com operações no banco de dados.
A linguagem Python facilita bastante o desenvolvimento de aplicações de interface gráfica e que façam
operações no banco de dados. É natural que o desenvolvedor iniciante tenha a impressão de que é um
projeto complexo, mas, com um pouco de prática, as vantagens de programar nesse ambiente vão ficar
evidentes.
O Python é uma linguagem muito bem documentada e possui uma comunidade engajada em resolver
problemas e disponibilizar as soluções em ambientes públicos. Exploramos algumas bibliotecas, mas
existem muitas outras. A escolha de uma delas deve levar em consideração questões como tempo para
desenvolvimento, maturidade do programador e quais os recursos computacionais que se têm à disposição.
REFERÊNCIAS
MEIER, B. A. Python GUI Programming Cookbook. Birmingham, United Kingdom: Packt Publishing Ltd.,
2015.
PYTHON.ORG. Python 3.8.5 documentation. Publicado em meio eletrônico em: 23 out. 2020.
PYTHON.ORG. Tkinter ‒ Python interface to Tcl/Tk. Consultado em meio eletrônico em: 23 out. 2020.
SPYDER-DE. Spyder. Consultado em meio eletrônico em: 23 out. 2020.
EXPLORE+
Para saber mais sobre os assuntos tratados neste tema, pesquise na internet:
/
Os sites oficiais do tkinter e do psycopg2 e aprenda mais detalhes técnicos sobre aplicações GUI e de
banco de dados, além de poder fazer downloads.
Os sites oficiais das bibliotecas/frameworks/pacotes Kivy, Pyforms, PyQt, wxPython, PyAutoGUI e
PySimpleGUI para obter mais informações sobre aplicações GUI no Python.
Os sites oficiais das bibliotecas/frameworks/pacotes pyMySQL, cx_Oracle, PySqlite e PyMongo para
obter mais informações sobre aplicações de banco de dados no Python.
CONTEUDISTA
Sérgio Assunção Monteiro
 CURRÍCULO LATTES
javascript:void(0);
/
DESCRIÇÃO
Aplicação da metodologia de desenvolvimento rápido de software (RAD) com descrição do
levantamento de requisitos, modelagem de negócios e de dados, Design de interface com o
usuário e uma aplicação prática com o uso da linguagem de programação Python.
PROPÓSITO
Compreender a aplicação da metodologia RAD para o desenvolvimento de um sistema.
PREPARAÇÃO
Antes de iniciar o conteúdo deste tema, o aluno precisa ter instalado o Python versão 3.8.5 e a
IDE Spyder.
OBJETIVOS
MÓDULO 1
/
Descrever as etapas para tratamento dos requisitos de um sistema na metodologia de
desenvolvimento rápido de software (RAD)
MÓDULO 2
Descrever as modelagens de negócios e de dados da RAD
MÓDULO 3
Definir o design de interface com o usuário na RAD
MÓDULO 4
Esquematizar uma aplicação RAD implementada em Python
INTRODUÇÃO
A metodologia de desenvolvimento rápido de software (RAD) é caracterizada por um processo
evolutivo em que usuários e desenvolvedores são engajados através de entregas de versões
funcionais do sistema que, apesar de incompletas, permitem que a colaboração seja otimizada.
Os usuários podem operar essas versões e fazer comentários, críticas e sugestões que
auxiliam bastante os desenvolvedores a direcionar seus esforços para atender, de fato, às
necessidades do cliente. Essas versões parciais são chamadas de protótipos e a ideia é que,
ao longo do processo, avancem no sentido de se tornarem a versão final do sistema.
Aspectos como custo-benefício, uso efetivo de tempo, alcançar a satisfação do cliente e
controlar riscos são abordados pela RAD através da rápida verificação de inconsistências e
alinhamento de entendimento.
/
Ao longo do texto, abordaremos as etapas de requisitos de um sistema, as modelagens de
negócios e de dados e o design da interface com o usuário. No último módulo, apresentaremos
uma aplicação RAD simples desenvolvida com o uso da linguagem de programação Python.
MÓDULO 1
 Descrever as etapas para tratamento dos requisitos de um sistema na metodologia de
desenvolvimento rápido de software (RAD)
REQUISITOS
CONTEXTUALIZAÇÃO
O desenvolvimento rápido de software (RAD) é uma abordagem iterativa e incremental,
portanto é um modelo para a construção de software caracterizado pela adaptabilidade,
prototipagem rápida e colaboração das partes interessadas.
/
 
Fonte: Shutterstock
A ênfase da metodologia está na intensificação da colaboração entre as partes interessadas,
ao invés de estar no planejamento do que será feito. É uma forma de as equipes colaborarem
com mais sinergia para que desenvolvam aplicações com mais rapidez.
 COMENTÁRIO
Além disso, o progresso do desenvolvimento pode ser medido facilmente através da evolução
do protótipo, que é a principal forma de maximizar a comunicação entre desenvolvedores e
usuários sobre melhorias, ou mudanças do sistema. Os objetivos da RAD são bem definidos:
Maior eficiência no uso do tempo das partes envolvidas, comunicação mais produtiva e
processo de desenvolvimento otimizado.
A RAD faz uso de ferramentas de desenvolvimento que padronizam a implementação dos
sistemas e apoiam os desenvolvedores na implementação de interfaces gráficas com o
usuário, manipulação de dados, desenvolvimentos de APIs e outros serviços que poupam o
tempo do desenvolvedor, para que possa usá-lo de forma mais eficiente para a implementação
do sistema. Segundo Martin (1991), a RAD possui quatros fases distintas, que são:
Quatro fases da RAD
/
Fase de
planejamento de
requisitos:
Trata das necessidades de negócios, escopo do projeto,
restrições e requisitos do sistema.
Fase de design
do usuário:
Nessa fase, são desenvolvidos modelos e protótipos para
representar todos os processos, entradas e saídas do sistema.
Fase de
construção:
É nesta fase que os protótipos são desenvolvidos.
Fase de
transição:
Aqui, são feitos processamento de dados, testes, mudança para
o novo sistema e treinamento do usuário.
 Atenção! Para visualização completa da tabela utilize a rolagem horizontal
A seguir, trataremos detalhadamente a fase de planejamento de requisitos.
FASE DE PLANEJAMENTO DE REQUISITOS
CONCEITOS
Independentemente da metodologia que seja empregada para desenvolver um software, é um
fato que todo sistema é desenvolvido com um propósito. Para chegar a esse objetivo, um
conjunto de itens, chamado de requisitos, deve ser implementado.
 SAIBA MAIS
/
A área que trata desse assunto é a Engenharia de Requisitos. Ela tem como metas a
identificação, modelagem, comunicação e documentação dos requisitos de um sistema e em
quais situações ele vai operar. O modo como os requisitos serão implementados é uma
decisão que deve ser tomada pela equipe de desenvolvimento.
Os requisitos do sistema basicamente descrevem o que deve ser feito. É importante garantir
que eles sejam completos, não se contradigam e que sejam relevantes para o desenvolvimento
do sistema.
REQUISITOS
Quanto maior o detalhamento dos requisitos logo no começo do projeto, menores serão
aschances de haver a necessidade de mudanças no sistema, quando o desenvolvimento
já estiver avançado.
A Engenharia de Requisitos consiste em cinco atividades principais (vide Pressman, 2011):
Elicitação: Identifica os requisitos do sistema.
Análise: Elenca os elementos necessários para tratar os requisitos.
Documentação: Comunica as partes envolvidas sobre o entendimento dos requisitos.
Validação: O que foi implementado deve ser o que foi solicitado.
Gerenciamento: Consiste na priorização dos requisitos.
A seguir, cada uma dessas atividades será detalhada.
ELICITAÇÃO DE REQUISITOS
A elicitação de requisitos, ou ainda, levantamento de requisitos, tem por objetivo identificar os
requisitos do sistema e em qual contexto será feita a operação deste com o apoio das partes
javascript:void(0)
/
interessadas. Por contexto, entende-se: Qual é o domínio da aplicação, quais as necessidades
do negócio, quais são as restrições do sistema, a quem se destina e quais os pormenores da
operação, a fim de obter uma melhor compreensão do sistema a ser desenvolvido.
Entrevistar as partes interessadas é um método para descobrir fatos e opiniões de usuários em
potencial e evitar mal-entendidos que podem comprometer o desenvolvimento do sistema. As
entrevistas podem ser de dois tipos:
 
Shutterstock
FECHADAS
As partes interessadas respondem um conjunto predefinido de perguntas.

/
 
autor/shutterstock
ABERTAS
O engenheiro de requisitos e as partes interessadas discutem o que esperam do sistema.
As entrevistas são vantajosas por fornecerem informações úteis para os desenvolvedores. A
desvantagem é que, por se tratar de informações subjetivas, o entrevistador deverá estar
atento com a possibilidade de informações conflitantes. Dada a importância do levantamento
de requisitos para todo o projeto, é necessário fazer uso de técnicas que auxiliem extrair a
maior quantidade de informações úteis. Entre essas técnicas, estão:
CASOS DE USO:
São usados para descrever as interações entre os usuários e o sistema. Eles especificam uma
sequência de interações entre um sistema e um ator externo (por exemplo, uma pessoa, uma
peça de hardware, outro produto de software). Os requisitos funcionais do sistema de software
são representados pelos Casos de Uso, que são, portanto, um importante instrumento para
que analistas e usuários possam interagir e validar o entendimento dos requisitos.
OS CENÁRIOS:
Têm por objetivo simular situações de interações entre os usuários e o sistema. Na descrição
dos cenários, deve ser informado como o sistema estava antes de o usuário começar a
interação e como ficou depois de esta ter sido concluída.
OBSERVAÇÃO E ANÁLISE SOCIAL:
/
Aqui, um analista observa os usuários enquanto trabalham e faz anotações. A principal
vantagem desta técnica é mostrar o modo como os usuários realmente trabalham e não uma
descrição idealizada de como devem trabalhar.
GRUPOS FOCAIS:
É formado por grupos com visão de partes do sistema, os quais ajudam a identificar as
necessidades e percepções dos usuários.
BRAINSTORMING: A
Ou tempestade cerebral, é uma reunião em que os participantes podem desenvolver soluções
criativas para problemas específicos. Esse processo tem duas fases: A de geração, na qual as
ideias são coletadas, e a de avaliação, em que as ideias coletadas são discutidas.
PROTOTIPAGEM:
A ideia é desenvolver aplicações rápidas que ajudem a entender melhor os requisitos do
sistema como um todo. Os protótipos podem ser descartáveis e evolutivos.
ANÁLISE DE REQUISITOS
Todas as questões relacionadas aos requisitos são tratadas pela análise de requisitos, desde a
determinação das precedências, da consistência deles (ou seja, não devem ser contraditórios
entre si), da integridade dos requisitos (isto quer dizer que nenhum serviço ou restrição estará
ausente) até a viabilidade dos requisitos. Portanto, a análise preocupa-se em verificar se a
implementação dos requisitos é viável com o orçamento e cronograma disponíveis para o
desenvolvimento do sistema. A partir da negociação de priorização com as partes
interessadas, os conflitos são resolvidos. A principal técnica usada para análise de requisitos
são sessões JAD.
 SAIBA MAIS
As sessões JAD ― Acrônimo do inglês para Joint Application Development ― são oficinas de
trabalho em que os desenvolvedores e clientes discutem sobre o sistema. O objetivo da JAD é
detalhar a solução, de modo que seja possível extrair elementos passíveis de monitoramento
até que o projeto seja concluído. Depois da extração dos requisitos, é necessário priorizá-los
/
para estabelecer um cronograma de trabalho que contemple o uso eficiente de recursos e
atenda às expectativas do cliente.
DOCUMENTAÇÃO DE REQUISITOS
Nesta etapa, o objetivo é comunicar os requisitos do sistema para as partes interessadas:
Clientes e desenvolvedores. O documento de requisitos é a referência para avaliar o sistema,
ou seja, para construir testes diversos, verificação e validação e para fazer o controle de
mudanças. Esse documento é essencial para que haja concordância entre as partes envolvidas
e pode, inclusive, fazer parte do contrato.
GERENCIAMENTO DE REQUISITOS
A captura, o armazenamento, a disseminação e o gerenciamento de informações compõem o
gerenciamento de requisitos. Portanto, é nessa etapa que as atividades relacionadas ao
controle de mudança e versão, rastreamento de requisitos e dos estados dos requisitos são
tratadas. A rastreabilidade de requisitos mapeia a conexão entre requisitos, design e
implementação de um sistema para gerenciar mudanças em um sistema.
MODELO TRADICIONAL DE ENGENHARIA
DE REQUISITOS APLICADO PARA
DESENVOLVIMENTO RÁPIDO DE
SOFTWARE (RAD)
Segundo Pressman (2011), o modelo tradicional de engenharia de requisitos para
desenvolvimento rápido de software tem as seguintes etapas:
/
 
Autor/Shutterstock
Alguns dos problemas para aplicar técnicas de engenharia de requisitos dos modelos
tradicionais para a RAD são:
A RAD se caracteriza por ser um processo evolutivo no qual é incluída uma característica
para o projeto em cada ciclo de desenvolvimento. Isso ocorre porque existe a premissa
de que os usuários evoluem o seu entendimento do projeto com a análise das entregas,
portanto o modelo tradicional é inadequado quando tenta levantar todos os requisitos logo
no início do desenvolvimento.
O modelo tradicional não trata de forma específica dos conflitos que podem ocorrer com a
implementação dos requisitos ao longo do projeto, como é o caso da RAD em que o
projeto vai incorporando sugestões dos usuários ao longo das iterações.
Os mecanismos de priorização de requisitos no modelo tradicional de engenharia de
requisitos não se aplicam a projetos baseados na RAD, pois a cada iteração de
desenvolvimento do protótipo é necessário estabelecer quais são os requisitos de alta
prioridade.
Na RAD, quando o cliente faz sugestões a partir da análise do protótipo, é necessário
gerenciar as prioridades do que vai ser implementado para a próxima versão. Os modelos
tradicionais não tratam de como deve ser feito o gerenciamento dessas mudanças.
/
Como visto, então, a RAD precisa de um tratamento específico para fazer o gerenciamento dos
requisitos.
MODELO DE ENGENHARIA DE REQUISITOS
PARA RAD
A elicitação de requisitos é a principal etapa na RAD. Isto ocorre porque o protótipo depende
dela. A técnica mais utilizada para levantamento de requisitos na RAD é a JAD (Joint
Application Development) . Nas oficinas JAD, as partes interessadas discutem o sistema e
definem seus requisitos. São sessões em que as partes interessadas ― usuários e
desenvolvedores ― debatem sobre as necessidades do negócio. Isto é muito útil para
direcionar o desenvolvimento do projeto e remover todas as ambiguidades a respeito dos
requisitos. Assim, ganha-se tempo, que é um recurso caro e limitado para qualquer projeto.
Ao final da extração dos requisitos pela JAD, é necessário analisá-los. Isso é necessário para
garantirsua integridade e consistência. Uma das técnicas comumente utilizadas para análise
de requisitos é o gerenciamento de conflitos.
MODAL
A gestão de conflitos vai tratar das possíveis contradições que surgiram na JAD. Como a
RAD tem como característica desenvolver protótipos, é fundamental que os conflitos, se
existirem, sejam removidos, pois não faz sentido implementar um protótipo com requisitos
conflitantes.
Agora, depois da remoção dos conflitos entre os requisitos, é necessário fazer a priorização
deles para poder partir para o desenvolvimento do protótipo. Seguindo uma sequência lógica,
no protótipo, primeiro desenvolve-se as principais funcionalidades do sistema. Uma técnica
usada para isso é a classificação por cartões, que consiste na atribuição de “graus de
importância” para cada requisito. Dessa forma, é possível comparar as prioridades das
diferentes partes interessadas.
javascript:void(0)
/
ETAPA 1
Na classificação por cartões, todas as funcionalidades do sistema são escritas em cartões
individuais. Em seguida, os cartões são dados para todos os participantes das oficinas de
trabalho.

ETAPA 2
Cada um atribui a prioridade que acha ser a adequada para o requisito e mostra para os
demais. Após algumas rodadas, todos os cartões têm algumas prioridades. Em seguida, faz-se
a análise dos graus de todos os cartões para analisar os dados.

ETAPA 3
Depois de analisados, é feita a priorização das funcionalidades com as quais todas as partes
interessadas concordam. Trata-se de uma técnica colaborativa e orientada para atender às
necessidades do cliente.
Com a priorização dos requisitos definida, passa-se para a documentação deles. Trata-se da
formalização do acordo sobre o entendimento dos requisitos entre as partes interessadas. Uma
das técnicas para fazer a documentação dos requisitos é através da especificação de
requisitos de software. Essa técnica também é utilizada pelos modelos tradicionais para
documentação dos requisitos.
Agora, sim, chega-se à principal característica do ciclo de vida de desenvolvimento da RAD,
que é a implementação do protótipo.
/
O protótipo é um programa funcional com um escopo reduzido que reflete para onde o
desenvolvimento do sistema está sendo direcionado. O desenvolvimento é feito a partir da
priorização dos requisitos, que significa que, inicialmente, as principais funcionalidades do
sistema devem ser implementadas.
 
Shutterstock
Terminado o protótipo, ele é apresentado para ser validado pelo cliente. Essa é a etapa mais
importante em qualquer ciclo de vida de desenvolvimento, pois todo sistema tem um propósito
e, quem o avalia, é o usuário. Na RAD, a validação do protótipo é muito importante para
direcionar quais serão as ações a serem tomadas para a próxima iteração.
 ATENÇÃO
Na validação do protótipo, o cliente o verifica com base na documentação dos requisitos. No
caso de o protótipo corresponder aos requisitos, ele será válido e a próxima fase é a de design.
Mas se o cliente rejeitar o protótipo e solicitar melhorias, então será necessário ir para o
gerenciamento de requisitos.
O desenvolvimento rápido de software pode ser um método muito eficaz, desde que sejam
observados os pré-requisitos para sua aplicação. A RAD cria um ambiente colaborativo e
criativo em que as partes interessadas podem participar de um projeto muito detalhado. Com a
RAD, pode-se obter resultados rápidos e ideias de sucesso que, dificilmente, seriam
implementadas nos modelos tradicionais. É um fato, no entanto, que a RAD também tem suas
desvantagens. Seu uso depende de uma equipe de trabalho com diversas habilidades e
motivada que se adéque rapidamente a mudanças ao longo do projeto.
/
VÍDEO
Analisando os requisitos de um sistema
VERIFICANDO O APRENDIZADO
/
1. A RAD É UMA METODOLOGIA EVOLUTIVA BASEADA EM ITERAÇÕES
INCREMENTAIS COM FASES BEM DEFINIDAS. SOBRE AS FASES DA
RAD, SELECIONE A OPÇÃO CORRETA QUE DESCREVE O
DESENVOLVIMENTO DO PROTÓTIPO DE DESIGN DE INTERFACE COM O
USUÁRIO:
A) Preocupa-se com o desenvolvimento de componentes interativos que atendam aos
requisitos do sistema.
B) Tem foco na aparência do sistema, pois, desse modo, é mais fácil o usuário operá-lo.
C) Esta fase não está relacionada, necessariamente, com a confecção de um protótipo com
componentes interativos.
D) Faz parte da primeira fase da RAD.
2. A RAD TEM COMO META ENTREGAR SISTEMAS RAPIDAMENTE, MAS
SÓ FAZ SENTIDO ENTREGAR RAPIDAMENTE UM SISTEMA QUE TENHA
UMA BOA QUALIDADE, CASO CONTRÁRIO SERÃO NECESSÁRIAS
NOVAS ITERAÇÕES PARA FAZER CORREÇÕES E AJUSTES. EM
RELAÇÃO À METODOLOGIA RAD, SELECIONE A OPÇÃO CORRETA QUE
INDIQUE COMO EVITAR RETRABALHO:
A) Desenvolvendo protótipos.
B) Através da combinação de processos bem consolidados das metodologias tradicionais com
os métodos ágeis.
C) Aplicando um processo exaustivo de documentação logo no início do projeto, a fim de
minimizar imprevistos ao longo do desenvolvimento.
D) Através da colaboração contínua das partes interessadas ao longo do projeto.
GABARITO
1. A RAD é uma metodologia evolutiva baseada em iterações incrementais com fases
bem definidas. Sobre as fases da RAD, selecione a opção correta que descreve o
desenvolvimento do protótipo de design de interface com o usuário:
/
A alternativa "A " está correta.
 
O protótipo de design gráfico faz parte da segunda fase da RAD. É muito importante para que o
usuário possa interagir com o sistema e verificar se os requisitos são atendidos.
2. A RAD tem como meta entregar sistemas rapidamente, mas só faz sentido entregar
rapidamente um sistema que tenha uma boa qualidade, caso contrário serão necessárias
novas iterações para fazer correções e ajustes. Em relação à metodologia RAD,
selecione a opção correta que indique como evitar retrabalho:
A alternativa "D " está correta.
 
A colaboração entre as partes interessadas é fundamental para o sucesso da RAD. O
desenvolvimento dos protótipos é o meio de comunicação para que os usuários deem suas
opiniões a respeito do projeto e o validem, para que, assim, os desenvolvedores façam os
ajustes necessários de modo que o sistema atenda aos requisitos.
MÓDULO 2
 Descrever as modelagens de negócios e de dados da RAD
MODELAGEM (NEGÓCIOS E DADOS)
A modelagem de sistema formaliza como os sistemas são definidos. É comum que, durante o
desenvolvimento, sejam usadas imagens para ajudar a visualizar alguns aspectos do sistema.
Através de representações por meio de diagramas, a modelagem fornece um meio para
compreender e comunicar as ideias associadas ao desenvolvimento do sistema.
 
Shutterstock
A RAD é uma metodologia de desenvolvimento de software evolutiva que, além do
levantamento de requisitos, visto no Módulo 1, possui outras fases. De modo resumido,
/
segundo Kerr e Hunter (1994), elas podem ser descritas como:
Modelagem de negócios
Nessa fase, é feita a obtenção de informações a respeito dos requisitos funcionais do sistema,
reunidas por várias fontes relacionadas aos negócios. Essas informações são então
combinadas para criar uma documentação que será utilizada para modelar o ciclo de vida dos
dados: Como os dados podem ser usados, quando são processados e a sua transformação em
informações que serão utilizadas por alguma área, ou setor específico do negócio. Trata-se,
portanto, de uma análise com viés comercial.

Modelagem de dados
Nessa fase, todas as informações que foram obtidas durante a fase anterior são analisadas
para formar conjuntos de objetos de dados essenciais para os negócios. Através da análise, as
informações são agrupadas de modo que sejam úteis para a empresa. Por exemplo, na
determinação de quais são as entidades principais que serão tratadas pelo sistema. A
qualidade de cada grupo de dados, então, é examinada e recebe uma descrição precisa. Em
seguida, é feito mapeamento que relaciona esses grupos entre si e qual o significado desses
relacionamentos, conforme definido na etapa precedente. Avançando um pouco mais, agoradeve-se identificar e definir os atributos de todos os conjuntos de dados. Também é
estabelecida e definida em detalhes de relevância para o modelo de negócios a relação entre
esses objetos de dados.
 COMENTÁRIO
A modelagem não é um método exato e exige muita atenção do analista, pois vai ter impacto
para todo o projeto. Quanto melhor for o entendimento do sistema, melhor será a qualidade da
modelagem e, portanto, mais eficiente será a tradução das demandas do cliente para a
implementação do sistema. Os modelos e as informações são representados por meio de
diagramas conectados.
A seguir, detalharemos tanto a modelagem de negócios como a modelagem de dados.
/
MODELAGEM DE NEGÓCIOS
Uma das principais técnicas para representar a modelagem de negócios é utilizar o diagrama
de Casos de Uso da UML. Cabe lembrar que a UML (Unified Modeling Language) - que é
traduzida para o português como Linguagem Unificada de Modelagem - é uma linguagem
padrão para modelagem orientada a objetos. O objetivo dela é dar suporte para que analistas
de negócios e desenvolvedores visualizem os seus projetos em diagramas padronizados. Os
diagramas mais comuns são o de Casos de Uso e o de Classes.
A escolha do diagrama de Casos de Uso para modelagem de negócios ocorre porque esse
diagrama incorpora a dinâmica dos negócios sob várias perspectivas, descrevendo, assim,
como as partes interessadas ― chamadas de atores ― interagem com o sistema e entre si. Na
Figura 1, é apresentado um exemplo de caso de uso de um sistema simplificado de embarque
em um aeroporto.
 
Fonte: Autor
No modelo, são destacados os atores “passageiro” e “guia de turismo”.
Nas elipses, estão os Casos de Uso que representam os elementos do sistema com os
quais os usuários interagem.
Além disso, o diagrama possui um nome, no exemplo do diagrama de Casos de Uso da Figura
1, o nome é “Aeroporto”, que ilustra o escopo do negócio que está sendo modelado. Outros
pontos a serem destacados são como os elementos do negócio interagem entre si
representando um fluxo de trabalho que será, posteriormente, implementado no sistema.
/
Em um negócio, existem, pelo menos, três elementos de Casos de Uso de negócios:
Processos de Negócios Principais
Processos Auxiliares
Processos de Gerenciamento
 Atenção! Para visualizaçãocompleta da tabela utilize a rolagem horizontal
Os processos de negócios principais: Que tratam das principais atividades do negócio.
Os processos auxiliares: São atividades que precisam ser feitas de qualquer modo,
para que o negócio funcione.
Os processos de gerenciamento: Representam os processos que gerenciam outros
processos e os relacionam com seus proprietários.
Para ilustrar melhor os conceitos apresentados até agora, será dado o exemplo de um
restaurante: Os principais Casos de Uso de negócios são marketing e serviços de almoço e de
jantar, e o caso de uso auxiliar é a compra de itens de alimentação e limpeza.
 ATENÇÃO
Os Casos de Uso principais de negócios devem estar, obrigatoriamente, relacionados a um
ator de negócios. Isso ocorre para impor que os negócios estejam vinculados aos serviços que
seus usuários solicitam. Uma forma de verificar que a modelagem de negócios está errada é se
modelo de caso de uso tiver Casos de Uso que ninguém solicita.
Os Casos de Uso principais de negócios representam a dinâmica do negócio. São acionados
por atores que os iniciam e esperam como resposta aos serviços deles. Em outras situações,
javascript:void(0)
javascript:void(0)
javascript:void(0)
/
um ator receberá respostas, ainda que os Casos de Uso não tenham sido iniciados por ele
(ator de negócios).
A modelagem de Casos de Uso de negócio facilita o entendimento dos principais processos
que estão sendo mapeados, além de auxiliar na reutilização de partes de fluxos de trabalho
que são compartilhados entre muitos Casos de Uso de negócios e é um importante instrumento
de interação entre as partes interessadas, para evoluir aspectos que precisem de mais
detalhamento, ou mesmo correção.
 
Fonte:Shutterstock
Trata-se de uma forma muito flexível de trabalho em que é possível fazer generalizações,
detalhamentos e reutilizações de Casos de Uso dependendo como ele se contextualiza dentro
do negócio.
O esforço de modelagem de negócios deve estar circunscrito às necessidades que serão
tratadas pelo sistema, ou seja, o escopo da modelagem não deve ultrapassar o que realmente
precisa ser modelado, sob o risco de perder o foco do que será tratado e perdendo, assim, a
vantagem da modelagem com um excesso de informações que acabam gerando confusão e
que, posteriormente, podem ser difíceis de ser eliminadas da modelagem.
/
 
Fonte:Shutterstock
A modelagem foca apenas em um subconjunto dos processos de negócios, ou seja, nos
processos que realmente fazem parte das necessidades demandadas pelos clientes.
Uma modelagem de Casos de Uso de negócios de boa qualidade deve ter como
características:
O mapeamento das partes do negócio que compõem a demanda do cliente.
Os Casos de Uso devem estar de acordo com o negócio que descrevem.
Deve haver um equilíbrio entre o número e o tamanho dos Casos de Uso.
Ter poucos Casos de Uso torna o modelo mais fácil de entender, mas não podem deixar de
descrever algum fluxo de trabalho que seja relevante para o negócio. Outra coisa a ser
considerada é evitar a redundância de Casos de Uso. Caso perceba-se a ocorrência de uma
situação dessas, deve-se fazer uma generalização dos Casos de Uso, pois não fazer isso pode
provocar inconsistências na modelagem dos negócios.
TEORIA NA PRÁTICA
/
Como exemplo de generalização, seja um sistema de pagamento que permite que os
frequentadores de uma academia paguem de duas formas: Online e por telefone. Certamente,
esses dois cenários terão muitas coisas em comum e diferentes, reflita sobre esse contexto e
escreva alguns desses aspectos comuns entre esses dois cenários:
RESOLUÇÃO
Alguns aspectos comuns são: a especificação das informações pessoais e a especificação do
meio de pagamento.
Portanto, a melhor maneira de fazer essa modelagem é criar um Caso de Uso (o pai) que
contém o comportamento comum e, em seguida, criar dois Casos de Uso filho especializados
que herdam o comportamento do pai e que contêm as diferenças específicas para fazer o
pagamento online, ou por telefone.
MODELAGEM DE DADOS
A modelagem de dados é o processo que formaliza o ciclo de vida dos dados de modo que
possam ser tratados de um jeito formal, por exemplo, o armazenamento em um banco de
dados. Trata-se, portanto, de uma representação conceitual de objetos de dados, de suas
associações e regras de manipulação. Ela auxilia na representação visual dos dados e no
modo como as regras de negócios e demais imposições regulatórias devem ser cumpridas.
Um exemplo dessas imposições é a Lei Geral de Proteção de Dados ― mais conhecida pelo
acrônimo, LGPD ―, que impõe diversas regras sobre a transparência e a proteção do uso de
dados. Os modelos de dados aumentam a qualidade dos dados dos sistemas, uma vez que
fazem uso de convenções de nomenclatura e de segurança.
/
 
Fonte:Shutterstock
O modelo de dados indica quais são os dados necessários e como devem ser organizados,
ao invés de apontar quais operações precisam ser feitas. Os tipos de técnicas mais comuns
para representar os modelos de dados são:
Modelo de entidade e relacionamento (E-R).
UML (Unified Modeling Language).
MODELO DE DADOS
Na sua essência, o modelo de dados visa a garantir que todos os objetos de dados ―
que serão usados pelo sistema ― sejam representados com precisão. A ausência de
dados pode produzir inconsistências com grande impacto para o negócio do cliente.
Em relação aos bancos de dados dos sistemas, os modelos de dados ajudam a fazer os
projetos nos níveis conceitual, físico e lógico. O modo como o modelo é estruturado ajuda a
definir as tabelas relacionais, seus campos, chaves primárias e estrangeiras e o modo como
devem ser manipulados paraatender às regras dos negócios. É um processo trabalhoso, mas
investir na construção de um modelo de dados de qualidade vai trazer benefícios no longo
javascript:void(0)
/
prazo tanto sob o ponto de vista tecnológico, com a facilidade de manipulação e manutenção
dos dados, como do ponto de vista do negócio.
Basicamente, existem três tipos diferentes de modelos de dados:
Conceitual
Define o que está contido no sistema. Seu objetivo é a organização, definição do escopo, dos
conceitos e das regras de negócios.

Lógico
Define o modo como o sistema deve ser implementado independentemente do banco de
dados. O objetivo é desenvolver estruturas de dados e um conjunto de regras técnicas.

Físico
Este modelo descreve a forma como o sistema será implementado usando um sistema de
banco de dados específico. O objetivo é a implementação do banco de dados que vai, de fato,
operar.
Detalhando um pouco mais os modelos, o principal objetivo do modelo conceitual é
determinar quais são as entidades, seus atributos e como elas se relacionam. Aqui, não há
detalhes da estrutura real do banco de dados. Os elementos básicos do modelo conceitual são:
Entidade: Um elemento que é distinguível no domínio do negócio.
Atributo: Características, ou propriedades de uma entidade.
Relacionamento: Relação de dependência ou associação entre entidades.
 EXEMPLO
/
Exemplos de entidades são Escola e Aluno. O nome, matrícula e endereço são exemplos de
atributos da entidade Aluno. Um exemplo de relacionamento entre as entidades Escola e Aluno
é dado por “Uma Escola pode ter vários Alunos”.
O modelo conceitual organiza os conceitos de negócios, portanto são essenciais no início do
projeto como um meio de comunicação eficiente entre analistas de negócios e clientes. Ele é
desenvolvido independentemente das especificações de hardware, ou de software.
O objetivo é fazer a representação dos dados da forma como um usuário os visualiza no
contexto do negócio. Também são conhecidos como modelos de domínio, isso porque criam
um vocabulário comum para todas as partes interessadas através de conceitos básicos e
escopo.
Em relação aos modelos de dados lógicos, o foco está na definição da estrutura dos dados e
nas relações entre eles. Ele é iniciado a partir do modelo conceitual e da análise das
requisições técnicas e de desempenho das operações que serão realizadas com os dados.
Esse modelo cria a base para o modelo físico. Ele não está vinculado a nenhuma tecnologia
específica, mas a forma como os dados serão estruturados visa a obter a otimização do
desempenho e segurança deles apesar de sua estrutura de modelagem ser genérica.
Uma das técnicas mais comuns para representá-lo é através do diagrama Entidade-
Relacionamento, conforme pode ser visto na Figura 11.
 
Fonte: O Autor
Nesse diagrama, são modeladas as entidades Produto e Tipo de Produto.
 SAIBA MAIS
/
A entidade Produto possui os atributos preço, descrição e código e a entidade Tipo de Produto
possui os atributos código e descrição. Além disso, as entidades são relacionadas entre si e os
atributos códigos são utilizados para identificar de forma única cada elemento de suas
respectivas entidades.
O modelo lógico, portanto, descreve as necessidades de dados para um projeto. Ele é
projetado independentemente do banco de dados que será utilizado e os atributos das
entidades fornecem a base da sua especificação que será implementada no banco de dados.
Existe outra etapa importante a respeito do modelo lógico, que é a normalização dos dados.
Trata-se de uma técnica de organizar os dados de modo a evitar problemas de inconsistências
entre eles.
 ATENÇÃO
Na seção “Explore +”, são feitas algumas sugestões para você se aprofundar mais sobre o
tópico normalização de dados.
Por fim, o modelo de dados físicos descreve detalhadamente como será a implementação no
banco de dados. Com esse modelo, o desenvolvedor pode visualizar como os dados serão
armazenados no banco de dados e usá-lo para fazer geração do esquema do banco de dados.
Na figura 12, é apresentado um exemplo de modelo físico de dados.
 
Shutterstock
Na Figura 12, as entidades são representadas por tabelas com campos e seus respectivos
tipos de dados. Por exemplo, a tabela Produto possui os atributos “código”, que é do tipo
inteiro, e “descrição,” que é um tipo “cadeia de caracteres”.
javascript:void(0)
/
CADEIA DE CARACTERES
Cadeia de caracteres: Em muitos bancos de dados, esse tipo de dado é chamado de
“VARCHAR”.
Esse modelo de dados ajuda a visualizar a estrutura do banco de dados e modelar os
identificadores das tabelas (chaves primárias), as colunas, restrições, índices e outros recursos
do gerenciamento do banco de dados. Além disso, ele contém relacionamentos entre tabelas.
MAIS ALGUMAS CONSIDERAÇÕES SOBRE
A MODELAGEM DE DADOS E DE
NEGÓCIOS
O objetivo principal de um modelo de dados é oferecer meios para que os objetos de dados
sejam representados com precisão. Para isso, eles devem ser detalhados o suficiente para ser
aplicados na construção do banco de dados físico. As informações obtidas a partir deles
podem ser usadas para definir quais são as chaves primárias e estrangeiras das tabelas, o
relacionamento entre elas, além de outras informações que serão úteis para fazer manipulação
e manutenção dos dados.
A modelagem de dados é um importante instrumento para a comunicação entre
desenvolvedores e clientes, além de ajudar a documentar os mapeamentos de dados,
comumente utilizados no processo de extração-transformação-carga de dados (ETL). Por fim, a
modelagem de dados identifica fontes corretas de dados para preencher o banco de dados que
será utilizado pelo sistema.
adaptável
ciclo de vida
componentes
O modelo de dados é uma etapa
essencial no de
qualquer desenvolvimento
independentemente da
/
diretamente
estabilize
foco
protótipos
usuário
metodologia utilizada. No caso da
RAD, na qual a dinâmica do
aprendizado do sistema está
relacionada às
entregas através dos ,
é natural que o modelo de dados
também evolua, mas é esperado
que ele rapidamente e
o esteja em questões
relacionadas ao detalhamento de
regras de negócio e na
interatividade do usuário com o
sistema, ou seja, questões
relacionadas a 
interativos e experiência do
. O perfil esperado de
um desenvolvedor da RAD é de
um profissional com formação
sólida, facilidade de aprendizado
e muito . Isso,
inclusive, é a principal
desvantagem da RAD, pois
existem muitas expectativas,
/
especialmente, dos
desenvolvedores.
RESPOSTA
A sequência correta é:
O modelo de dados é uma etapa essencial no ciclo de vida de qualquer desenvolvimento
independentemente da metodologia utilizada. No caso da RAD, na qual a dinâmica do
aprendizado do sistema está diretamente relacionada às entregas através dos protótipos, é
natural que o modelo de dados também evolua, mas é esperado que ele rapidamente
estabilize e o foco esteja em questões relacionadas ao detalhamento de regras de negócio e
na interatividade do usuário com o sistema, ou seja, questões relacionadas a componentes
interativos e experiência do usuário. O perfil esperado de um desenvolvedor da RAD é de um
profissional com formação sólida, facilidade de aprendizado e muito adaptável. Isso, inclusive,
é a principal desvantagem da RAD, pois existem muitas expectativas, especialmente, dos
desenvolvedores.
A evolução do sistema pode ter impacto significativo no que foi feito até então. No sentido de
construir um sistema que realmente atenda às expectativas do cliente é excelente, pois as
constantes interações fortalecem o entendimento e se concretizam em módulos que atendam
às requisições do negócio, por outro lado, para o desenvolvedor, torna-se um grande desafio
para que tenha tempo de reagir rapidamente e apresentar as melhorias e correções levantadas
para as próximas iterações através de incrementos no protótipo.
/
 
Shutterstock
Tanto a modelagem de dados, como a modelagem de negóciossão etapas fundamentais na
RAD para compreender corretamente como o negócio funciona, como deve ser formalizado e
como os dados devem ser estruturados de modo que sejam adequadamente armazenados e
estejam disponíveis para serem usados quando houver necessidade.
/
VÍDEO
Modelando o sistema
VERIFICANDO O APRENDIZADO
1. A RAD POSSUI FASES COM PROPÓSITOS ESPECÍFICOS. NESSE
SENTIDO, SELECIONE A OPÇÃO CORRETA QUE TEM COMO OBJETIVO
CAPTURAR TODAS AS INFORMAÇÕES RELEVANTES SOBRE O
PROPÓSITO DO SISTEMA E COMO ELE SE CONTEXTUALIZA NO
NEGÓCIO:
A) Modelagem de dados, pois identifica o fluxo de dados no sistema que dão suporte para o
negócio.
B) Modelagem de negócios, pois identifica os elementos que caracterizam o negócio.
C) Levantamento de requisitos, uma vez que caracteriza as principais necessidades do
negócio.
D) Modelagem de processos, dado que faz a conexão entre a concepção do sistema até a sua
disponibilização para o usuário.
/
2. A FASE DE MODELAGEM DE DADOS TEM POR OBJETIVO FORMAR
CONJUNTOS DE OBJETOS DE DADOS ESSENCIAIS PARA OS
NEGÓCIOS. EM RELAÇÃO À FASE DE MODELAGEM DE DADOS, É
CORRETO AFIRMAR QUE:
A) Detalhes sobre como os dados serão implementados são tratados nesta fase.
B) Por ser uma etapa avançada da RAD, nela são tratados cenários de testes.
C) Aspectos relacionados à interatividade do sistema são discutidos nesta fase.
D) Informações sobre o negócio são mapeadas nessa fase.
GABARITO
1. A RAD possui fases com propósitos específicos. Nesse sentido, selecione a opção
correta que tem como objetivo capturar todas as informações relevantes sobre o
propósito do sistema e como ele se contextualiza no negócio:
A alternativa "B " está correta.
 
A modelagem de negócios levanta aspectos da dinâmica em que o sistema vai operar, ou seja,
atividades e pessoas relacionadas aos negócios sob análise.
2. A fase de modelagem de dados tem por objetivo formar conjuntos de objetos de
dados essenciais para os negócios. Em relação à fase de modelagem de dados, é
correto afirmar que:
A alternativa "A " está correta.
 
Na fase de modelagem de dados, além da identificação das entidades do negócio, elas são
detalhadas e é feito o mapeamento de como se relacionam entre si, além de tratar o modo
como será feita a implementação do modelo de dados.
MÓDULO 3
/
 Definir o design de interface com o usuário na RAD
DESIGN DA INTERFACE COM USUÁRIO
A criação de uma interface de usuário tem como meta ser um meio de interação para atender
às necessidades de modo prático. Portanto, exige do projetista a capacidade de antecipar
comportamentos e um conhecimento das diversas soluções existentes que tornem a
construção do projeto viável. Isso significa que as limitações de tempo e recursos financeiros
também são impostas para o projeto de design com o usuário.
 
Shutterstock
Questões relacionadas à forma, cor e espaço devem ser tratadas quando se considera um
sistema que deve resolver problemas e que será usado por diversos usuários. A interatividade
do usuário com um sistema é dinâmica, pois trata de eventos que são acionados a partir das
ações do usuário para atingir seus objetivos, logo é necessário que o sistema seja intuitivo e
que, além disso, leve em consideração restrições que o usuário possa ter tanto físicas, como
de ambiente tecnológico que o software vai operar.
Desenvolver um projeto de interface demanda ferramentas e frameworks que facilitem a
visualização de protótipos que, após serem testados e aprovados, nortearão os
desenvolvedores para a implementação delas. Esses protótipos permitem testar rapidamente
/
conceitos de interação com o usuário, facilitando, assim, a melhor compreensão do sistema,
uma vez que são expostos a situações reais, ainda que em um ambiente controlado.
 
Fonte:Shutterstock
Trabalhar na implementação de protótipos aumenta o engajamento dos usuários e da equipe
de desenvolvimento. Isso ocorre porque as ideias relacionadas ao projeto passam a se
concretizar em um ambiente interativo em que limitações são evidenciadas e necessidades de
melhorias surgem naturalmente.
Quando se fala sobre design de um sistema, o pensamento mais comum é fazer uma
associação com elementos de interface do usuário, normalmente, referenciados pelo acrônimo
do inglês UI (User Interface) , ou, ainda, GUI (Graphical User Interface) , que tratam de
componentes visuais com os quais o usuário vai interagir, tal como botões, janelas e barras de
rolagem.
Mas existe outro elemento muito importante que também compõe o projeto de interface de um
sistema, que é a experiência do usuário, conhecido pelo acrônimo em inglês UX (User
Experience). Ambos os conceitos serão tratados com mais profundidade mais adiante.
PROTÓTIPO DE INTERFACE
O protótipo de interface de um sistema visa à experimentação de conceitos, de modo que
evolua para uma representação do sistema no usuário. Trata-se de uma atividade muito
/
importante, uma vez que vai guiar, concretamente, as escolhas dos desenvolvedores quando
começarem a fazer a implementação do sistema.
Para cada componente escolhido, existe um conjunto de propriedades e de métodos
associados que devem ser explicitamente configurados e tratados. Isso significa que o tempo
de pessoas será alocado no estudo da configuração e no uso de componentes, além de como
devem ser testados.
 COMENTÁRIO
Em especial, na metodologia RAD, a evolução do projeto de interface pela implementação de
protótipos é esperada. Então, além das necessidades de profissionais bem treinados, é
necessário que tenham à disposição ferramentas que facilitem esse processo pelo qual podem
tornar a definição da interface em algo concreto.
Desenvolver protótipo de interface do usuário ajuda a refinar os requisitos funcionais logo no
início do projeto. A implicação disso tem como consequências positivas a redução dos custos
de manutenção, treinamento e melhoria do sistema, além de aumentar as chances de o
usuário final aceitar a versão final. De modo resumido, segundo Alavi (1984), entre os diversos
benefícios de desenvolver protótipos de interface para o usuário, tem-se:
A possibilidade de fazer testes para tratar de questões específicas do produto que
dificilmente seriam respondidas por pesquisas.
Um ambiente real para avaliar os conceitos de UI/UX.
Um meio pelo qual todos os envolvidos no projeto podem usar como um ponto de
referência para se comunicarem.
Facilita o engajamento dos usuários, pois podem fazer comentários sobre algo com que
podem interagir, facilitando, assim, o trabalho posterior da equipe de desenvolvimento.
Melhora a qualidade das especificações funcionais.
Aumenta as chances de o produto atender às demandas.
/
Tem o potencial de reduzir o custo total de desenvolvimento do produto.
Na RAD, o desenvolvimento de protótipo é um processo natural. No caso de protótipo de
interface do usuário, a ideia é que os esforços empregados nos estágios iniciais podem reduzir
bastante o custo do software final. Isso ocorre porque depois de algumas interações a interface
se estabiliza e, portanto, as chances de ter que implementar muitas mudanças mais adiante no
projeto diminuem.
 ATENÇÃO
Apesar de todos os benefícios associados à implementação do protótipo de interface, é
necessário ter alguns cuidados, entre os quais, estão:
Ignorar limitações que se aplicam ao produto real no processo de prototipagem.
Criar expectativas irreais sobre o produto.
Estabelecer limites no processo de prototipagem.
Questões relacionadas a licenças de produtos, contexto em que vai operar e viabilidade
técnica, além de gerenciamento de recursos de tempo e financeiros sempre devem fazer parte
da criação de protótipos. Na RAD, isso é essencial, pois a ideia é que o sistema evolua a partir
de iterações e incrementos nos protótipos. Se, desde o início do projeto, houver muitos itens
para serem tratados, o processo terá mais custos.
A NECESSIDADE DA CONTEXTUALIZAÇÃO
A sociedade evoluiu em muitos aspectos, inclusive no acessoà informação. Atualmente, os
sistemas são usados para diversas aplicações, desde operações financeiras, educativas e de
entretenimento. Além disso, os sistemas operam em diversas plataformas, como aplicações
web e móveis.
O perfil do usuário também está mais abrangente, desde as pessoas que têm mais facilidade
de usar tecnologias, as que ainda não estão habituadas e aquelas que possuem restrições
/
visuais, por exemplo. Portanto, os desafios de projetar uma interface de usuário ficaram bem
mais complexos no sentido de que são muitas perspectivas que devem ser observadas. Por
outro lado, existem muitas ferramentas e frameworks disponíveis para apoiar o
desenvolvimento de protótipos.
 
Fonte:Shutterstock
O primeiro ponto a ser considerado no desenvolvimento de um projeto de interface é entender
a que público ele se destina. A compreensão de que o sistema será usado por outras pessoas
e sobre em que contexto vai operar auxilia na criação de protótipos que atinjam mais
rapidamente o objetivo esperado. De um modo simplificado, um projeto de interface deve levar
em consideração alguns pontos:
Os elementos de interface, tais como os botões, barras de rolagem e menus devem ter um
comportamento previsível, isso significa dar previsibilidade para os usuários, de modo que a
interação com os componentes seja intuitiva.
Aplicação de recursos que destaque um componente no contexto da aplicação. Por exemplo,
usar sombras para botões.
A interface deve ser simples, ou seja, os elementos devem atender aos propósitos dos
usuários.
A organização dos elementos deve ser legível. Para obter isso, é importante que haja uma
hierarquia que os relacione, além da preocupação em fazer alinhamentos que priorizem o bem-
estar do usuário.
O uso de recursos de cores e contrastes deve ser moderado e sempre com o propósito de
guiar o usuário para realização de suas tarefas.
/
Os tamanhos das fontes, estilo ― negrito e itálico, por exemplo ―, maiúsculas e distância
entre letras também devem ser contextualizados com o objetivo de dar destaque para o usuário
sobre o significado de uma mensagem. Por exemplo, um texto em letras maiúsculas pode ser
usado para destacar o cuidado que o usuário deve ter ao realizar alguma ação específica no
sistema, como excluir um registro.
Por unidade de interação, por exemplo, telas, a quantidade de ações para executar tarefas
deve ser a menor possível. O foco sempre deve ser o usuário, portanto a interface deve ser um
guia, para que progridam na execução de tarefas complexas.
Os controles devem estar próximos dos objetos que os usuários desejam controlar. Por
exemplo, um botão para enviar um formulário deve estar próximo dele.
Fornecer informações para os usuários a respeito de suas ações do sistema, como mensagens
de confirmação de envio, por exemplo.
Em algumas situações, é apropriado aplicar padrões de utilização do sistema para facilitar o
trabalho do usuário. Por exemplo, preencher formulários previamente. Essa opção, no entanto,
deve ser aplicada com bastante ponderação, pois, apesar de ser bastante útil em muitas
situações, pode ser utilizada por pessoas mal-intencionadas para obter indevidamente dados
dos usuários.
O design dos componentes deve ser contextualizado com o posicionamento do negócio a que
se destina. No caso de sistemas para empresas, é esperado que haja um estilo visual que
deve ser mantido.
A interface deve fornecer os próximos passos de como os usuários devem proceder para
navegar no sistema e atingir seus objetivos em qualquer contexto.
Na RAD, o desenvolvimento rápido de protótipo é enfatizado em detrimento do planejamento.
Ele é feito por meio do fluxo de ideias que são exploradas a partir da interação com as partes
interessadas e das soluções de problemas que são detectados durante o processo de
prototipagem rápida. Desde o início da RAD, o desenvolvimento de aplicações passou a ser
utilizado em diversas situações, como aplicações web e móveis.
A RAD é adequada para situações em que os projetos não são complexos. Por exemplo,
funciona bem para criação, ou renovação de páginas de comércio eletrônico. Portanto, a
escolha da RAD para implementar o design de interface de usuário deve satisfazer:
ESCOPO DO PROJETO
Deve ser bem definido, para que seja viável visualizar como será a versão final do sistema e,
assim, estimar os esforços e recursos necessários para o desenvolvimento do projeto.
/
DADOS DO PROJETO
Para aplicar a RAD, o projeto já deve ter informações sobre os dados, evitando, assim, a
necessidade de aplicar processos de análise de dados que podem consumir bastante tempo e
esforços que são difíceis de dimensionar.
DECISÕES DO PROJETO
Apesar de as interações com as partes interessadas serem muito importantes, as decisões
sobre o projeto também precisam ser rápidas. Em um projeto em que a hierarquia das decisões
é muito forte, o uso da RAD é inadequado, especialmente na confecção de um protótipo de
interface com o usuário.
EQUIPE DE PROJETO
O dimensionamento das equipes deve ser pequeno.
Em relação ao último item, parece ser simples, mas a implicação imediata é que os
profissionais dessas equipes devem ter múltiplas habilidades, ou seja, além de trabalhar com
programação visual, é esperado que o profissional tenha conhecimento sobre banco de dados,
desenvolvimento de micro serviços e arquitetura de software. Portanto, a escolha da RAD deve
levar em consideração todas estas questões. Logo, depois de analisar esses pontos, e a RAD
for a melhor opção, o processo deve seguir as seguintes etapas:
ETAPA 1
Escolha de uma equipe com profissionais que serão capazes de desenvolver projetos de
interface e que contribuam sobre a escolha dos componentes.

ETAPA 2
Analisar as metas do projeto e entender o que precisa ser feito, como se encaixam no projeto e
o que é necessário fazer para cumprir as metas.
/

ETAPA 3
Criar um processo iterativo, onde podem ser desenvolvidos protótipos e testes de usabilidade
até que seja atingido um ponto que se alinhe com os objetivos do projeto.
TÉCNICAS DE PROTOTIPAGEM DE
INTERFACE COM O USUÁRIO
Em outras metodologias de desenvolvimento, faz-se o uso de protótipos também. No entanto,
elas se diferenciam da RAD em relação ao objetivo do protótipo. Nas demais metodologias, o
protótipo é usado para provar conceitos e, ao longo do desenvolvimento, o sistema é
desenvolvido em características. No caso da RAD, a ideia é que o protótipo evoluirá para a
versão final do sistema. Portanto, é importante que a RAD trabalhe com o engajamento do
cliente por meio da experiência do usuário. Existem algumas técnicas para o desenvolvimento
de protótipos de interface, são elas:
SKETCHES
Trata-se de esboços de um projeto. Eles são fáceis de criar e úteis para verificar se os
conceitos e requisitos foram totalmente compreendidos sem consumir muito esforço. O seu uso
deve ser limitado ao início do projeto, pois é inadequado testar funcionalidades do sistema.
WIREFRAMES
São muito úteis para fazer uma abordagem mais complexa para mapear a interface do usuário.
Eles são mais detalhados do que os Sketches, além disso, algumas ferramentas permitem
adicionar componentes interativos. Desse modo, o usuário pode fazer navegações no protótipo
sem a implementação das funcionalidades.
MOCKUP
/
Também conhecida como “maquete”, é usada para refletir as opções de design para a escolha
de cores, layouts, tipografia, iconografia e aspectos visuais de navegação do produto.
PROTÓTIPOS
São modelos funcionais de sistema. São construídos para tratar tanto das funcionalidades do
produto, como também da aparência.
Preparar versões, ainda que simplificadas da interface com o usuário, ajuda os
desenvolvedores e designers a implementarem suas ideias e, assim, fornece protótipos
interativos para os clientes.
A escolha de uma ferramenta para desenvolver protótipos de interface com o usuário depende
de diversos fatores, mas, de um modo simples, entre os itens a serem consideradosestão:
Licença Integração Fidelidade
Curva de aprendizagem Facilidade de uso e conforto Compartilhamento
 Atenção! Para visualizaçãocompleta da tabela utilize a rolagem horizontal
LICENÇA
A primeira preocupação de qualquer projeto deve ser a respeito dos direitos de uso de
um software. O risco de iniciar um projeto em uma versão de testes de uma ferramenta
que não poderá ser usada pela equipe posteriormente pode ser grande. Só faz sentido
analisar os demais quesitos se este item for satisfeito.
INTEGRAÇÃO
Algumas ferramentas de prototipagem geram código que pode ser usado diretamente por
algumas linguagens de programação.
javascript:void(0)
javascript:void(0)
javascript:void(0)
javascript:void(0)
javascript:void(0)
javascript:void(0)
/
FIDELIDADE
Os protótipos na RAD são essenciais para a versão final do sistema, portanto devem ser
levadas em consideração quais as diferenças entre os elementos de interface do
protótipo e o sistema esperado.
CURVA DE APRENDIZAGEM
A metodologia RAD exige ferramentas que apoiem o desenvolvimento rápido, portanto as
ferramentas devem ser intuitivas e fáceis de serem utilizadas e aprendidas pelos
membros da equipe.
FACILIDADE DE USO E CONFORTO
As ferramentas de prototipagem devem ajudar a aumentar a produção com a redução de
etapas necessárias para criar protótipos.
COMPARTILHAMENTO
A ferramenta deve fornecer capacidade de colaboração entre várias pessoas.
/
A tarefa de projetar o design de um sistema é complexa. Portanto, as escolhas que devem ser
tomadas logo no início do projeto RAD precisam considerar fatores que apoiem o
desenvolvimento.
VÍDEO
Projetando a interface com o usuário
VERIFICANDO O APRENDIZADO
/
1. O DESIGN DE INTERFACE COM O USUÁRIO É UM PONTO
FUNDAMENTAL NO DESENVOLVIMENTO DE SOFTWARE. EM RELAÇÃO
À METODOLOGIA RAD, SELECIONE A OPÇÃO CORRETA SOBRE AS
VANTAGENS DE DESENVOLVER PROTÓTIPOS DE INTERFACE COM O
USUÁRIO:
A) Limitar as possibilidades de evolução do sistema.
B) Criar expectativas no usuário aumentando, assim, seu interesse pelo sistema.
C) Ter um ambiente que sirva como referência para que as partes envolvidas possam interagir.
D) Utilizar frameworks que acelerem o desenvolvimento.
2. O DESIGN DE INTERFACE COM O USUÁRIO CONTRIBUI PARA O
ENGAJAMENTO DAS PARTES INTERESSADAS NO PROJETO, UMA VEZ
QUE PODEM INTERAGIR COM UM SISTEMA REAL. APESAR DISSO,
PODEM EXISTIR ALGUMAS DESVANTAGENS NESTE PROCESSO. EM
RELAÇÃO À IMPLEMENTAÇÃO DO DESIGN DE INTERFACE COM O
USUÁRIO NA METODOLOGIA RAD, SELECIONE A OPÇÃO CORRETA
SOBRE AS DESVANTAGENS DE DESENVOLVER PROTÓTIPOS DE
INTERFACE COM O USUÁRIO:
A) As funcionalidades do protótipo não funcionam completamente.
B) Criar expectativas que dificilmente serão atendidas
C) Criar dificuldades no teste do sistema.
D) Consumir muito tempo na escolha de uma arquitetura de desenvolvimento adequada.
GABARITO
1. O design de interface com o usuário é um ponto fundamental no desenvolvimento de
software. Em relação à metodologia RAD, selecione a opção correta sobre as vantagens
de desenvolver protótipos de interface com o usuário:
A alternativa "C " está correta.
/
 
A interface gráfica fornece um ponto de referência para que os usuários possam interagir com
o sistema e fazer comentários que vão auxiliar os desenvolvedores no direcionamento do
projeto.
2. O design de interface com o usuário contribui para o engajamento das partes
interessadas no projeto, uma vez que podem interagir com um sistema real. Apesar
disso, podem existir algumas desvantagens neste processo. Em relação à
implementação do design de interface com o usuário na metodologia RAD, selecione a
opção correta sobre as desvantagens de desenvolver protótipos de interface com o
usuário:
A alternativa "B " está correta.
 
O protótipo de interface com um usuário é um excelente recurso de comunicação entre as
partes interessadas, mas é importante entender que o papel do protótipo na RAD é caracterizar
a evolução do sistema. Portanto, na apresentação de um protótipo, deve-se ter cuidado de criar
expectativas que não serão atendidas depois.
MÓDULO 4
 Esquematizar uma aplicação RAD implementada em Python
IMPLEMENTAÇÃO EM PYTHON
Neste módulo, será desenvolvida uma aplicação prática de RAD usando o Python (ver Python
3.8.5, 2020). Antes de começar, é necessário pensar sobre alguns pontos sobre a RAD:
A entrega de protótipos para os usuários permite que eles possam interagir com o
sistema e, portanto, munir os desenvolvedores com comentários que darão suporte para
implementarem melhorias e fazer ajustes.
É uma metodologia adequada para projetos de baixa complexidade.
/
 
Shutterstock
Ser uma metodologia voltada para entregas rápidas não quer dizer que o desenvolvedor não
precisa saber programar bem, ao contrário, pois o perfil dos profissionais de desenvolvimento
na RAD exige que tenham domínio em linguagens de programação e ferramentas/frameworks,
além de serem adaptáveis e motivados.
Muitas linguagens de programação podem ser aplicadas para um projeto RAD. Neste trabalho,
o foco está na linguagem Python por se tratar de uma escolha natural por diversos motivos.
Entre eles, estão: A simplicidade da sintaxe, disponibilidade de muitos pacotes, ampla
aceitação no mercado, uma grande comunidade engajada na resolução de problemas e licença
de software livre.
O exemplo escolhido para apresentar a RAD na prática é de um sistema simples que faz o
cadastro das informações pessoais básicas sobre um estudante e de suas notas. Ao final do
cadastro, o sistema exibe os dados que foram cadastrados, a média das notas e a situação do
estudante, ou seja, se foi aprovado, ou reprovado, ou se está em recuperação.
A seguir, as etapas de requisitos, modelagem de negócios e de dados, além da implementação
do sistema serão tratadas.
REQUISITOS
Aqui serão apresentados os requisitos do sistema, que são:
/
PROPÓSITO
Apresentar uma descrição do Sistema Simplificado de Cadastro de Notas de Alunos. Esta
descrição destina-se tanto aos usuários como aos desenvolvedores do sistema.
ESCOPO
Este software será um Sistema de Cadastro de Notas de Aluno. Ele será projetado para
informar se os alunos estão aprovados, em recuperação, ou reprovados. Além disso, os dados
são gravados em um arquivo Excel para facilitar a integração com outros sistemas. O sistema
atenderá às necessidades básicas da coordenação da escola para orientar os alunos enquanto
permanece fácil de entender e usar.
INTERFACES DO SISTEMA
O sistema foi projetado para operar no Windows.
INTERFACES DE USUÁRIO
A GUI do sistema possui botões, caixas de texto e grades, facilitando o controle por teclado e
mouse.
INTERFACES DE SOFTWARE
O software permite importar e exportar dados em um documento estruturado do MS Excel via
formato de dados XLSX.
ESPECIFICAÇÃO DE REQUISITOS FUNCIONAIS
O usuário deve ser capaz de cadastrar o nome do aluno e suas notas.
O usuário deve ser capaz de visualizar os dados cadastrados do aluno, sua média e sua
situação: Aprovado, ou reprovado, ou em recuperação.
Os dados são gravados e lidos de uma planilha do Excel.
MODELAGEM DE NEGÓCIOS
A escola RAD decidiu construir um novo aplicativo para facilitar a visualização da situação
escolar dos seus alunos. Dados como nome e notas dos alunos serão cadastrados no sistema.
/
Com isso, serão calculadas automaticamente as médias dos alunos e apresentada a sua
situação escolar: Aprovado, ou reprovado, ou em recuperação.
Na Figura 18 é apresentado o diagrama de Casos de Uso do sistema de cadastro de notas e
visualização da situação escolar dos alunos.
 
Fonte: O autor
No diagrama estão destacados os atores do sistema que são os alunos e funcionários da
escola. Os funcionários vão cadastrar os dados dos alunos que, por sua vez, poderão
visualizar as suas respectivas situações escolares.
MODELAGEM DE DADOS
O sistema visa a ser apenas um facilitador de uma etapa do gerenciamento das notas dos
alunos. Além disso, os dados serão armazenados em uma planilhaExcel.
Na tabela é apresentado o modelo de dados do sistema.
Campo Aluno Nota1 Nota2 Média Situação
Tipo Texto Decimal Decimal Decimal Texto
 Atenção! Para visualizaçãocompleta da tabela utilize a rolagem horizontal
/
DESIGN DA INTERFACE COM USUÁRIO
A interface gráfica do sistema de cadastro e visualização da situação escolar de alunos foi feita
com o uso do pacote Tkinter (TKINTER, 2020). Trata-se da biblioteca de interface gráfica
padrão da linguagem de programação Python. No ambiente de desenvolvimento Spyder (ver
Spyder, 2020), para fazer a instalação do pacote “tkinter”, basta digitar:
!pip install tkinter
Existem algumas pequenas variações quando se faz a instalação de um pacote no Python. No
caso do Spyder, é necessário colocar o símbolo exclamação “!” antes do comando “pip”. Para
outras IDEs, é necessário retirar o caractere “!” (símbolo de exclamação) do comando. O
pacote Tkinter está disponível na maioria das plataformas Unix, bem como em sistemas
Windows. Portanto, é uma boa escolha para o desenvolvimento de interfaces com o usuário.
Para poder usar os componentes gráficos do Tkinter no código é necessário escrever logo no
início do sistema as seguintes linhas de código:
import tkinter as tk
from tkinter import ttk
A interface gráfica do sistema é apresentada na figura 19.
 
Fonte: O autor
Nela, são destacados seis tipos de componentes:
/
Janela: Trata-se do formulário no qual os demais componentes são organizados. No
caso da implementação do sistema, esse componente foi usado da seguinte maneira:
janela=tk.Tk()
Rótulo: Que é usado para textos estáticos. No caso do sistema, foi usado para os textos
“Nome do Aluno”, “Nota 1” e “Nota 2”. Para referenciá-los no código, é necessário
escrever: tk.Label(janela, text='Texto estático').
Caixa de texto: São usadas para os usuários entrarem com os dados dos alunos. No
caso do sistema, foi usado para entrar com o “nome do aluno”, a “nota 1” e a “nota 2”.
Para referenciá-los no código, é necessário escrever: tk.Entry().
Botão: Usado para iniciar uma ação. No caso do sistema, foi aplicado para cadastrar os
dados dos alunos, calcular suas respectivas médias e determinar situação escolar em
que o aluno se encontra. Para referenciá-los no código, é necessário escrever:
tk.Button();
Visão de árvore: Bastante útil para visualizar os dados. No sistema, foi usado para uma
visualização em grade dos dados dos alunos, suas médias e respectivas situações. Para
referenciá-lo no código, é necessário escrever: ttk.Treeview().
Barra de rolagem: É um componente útil para interagir com a tabela da “visão de grade”,
quando a quantidade de linhas de registros ultrapassa o limite inicial. Para usar no
código, é necessário escrever ttk.Scrollbar().
A interface gráfica auxilia no entendimento do sistema. Certamente, é mais fácil fazer
sugestões de melhorias a partir de uma experiência real com o sistema do que em um nível
abstrato.
DETALHES DE IMPLEMENTAÇÃO
Agora, serão abordados aspectos que se referem à implementação do sistema em Python. Vá
até a seção “Explore +” e faça o download do arquivo “listaMediaAlunoFinal-v03.py”, assim
será possível acompanhar a implementação.
http://estacio.webaula.com.br/cursos/temas/aplicando_rad/docs/listaMediaAlunoFinal-v03.py
/
A primeira parte está na escolha dos pacotes que foram utilizados no desenvolvimento do
sistema. No caso, foram escolhidos: Tkinter e Pandas. O Tkinter foi escolhido por ser a
biblioteca padrão de componentes gráficos do Python e poder ser utilizada em múltiplas
plataformas, apesar de o sistema, inicialmente, ter sido projetado para operar no Windows. O
pacote Pandas é útil para manipular conjuntos de dados, mais conhecidos pela expressão em
inglês de “datasets”. Para usar as bibliotecas/pacotes, foi necessário escrever no código as
seguintes linhas:
import tkinter as tk
from tkinter import ttk
import pandas as pd
Antes de continuar, é importante verificar se a instalação das bibliotecas está correta. Na linha
de comandos da IDE Spyder, digite a seguinte linha:
import tkinter
Pressione Enter e, em seguida, digite:
tkinter._test()
Pressione a tecla Enter novamente. Se tudo funcionar corretamente, aparecerá uma janela,
conforme a figura 20.
 
Fonte:Shutterstock
Caso não tenha aparecido a janela, houve algum problema de instalação e será necessário
corrigi-lo. Com os problemas de instalação resolvidos, passa-se à criação dos elementos de
interface gráfica.
Na parte principal do programa, escreva as seguintes linhas de código, conforme a figura 21:
/
 
Fonte:Shutterstock
A primeira linha trata da instanciação de um objeto “raiz” do Tkinter onde serão colocados os
demais componentes gráficos.
Na linha 2, é feita a instanciação do objeto principal do projeto, onde o ciclo de vida dos
componentes será gerenciado – isso inclui a criação, tratamento de ações e liberação para a
memória.
Na linha 3, é dada a mensagem “título” para o projeto.
Na linha 4, são estabelecidas as dimensões altura e largura da janela principal.
Na linha 5, por fim, o sistema começa a executar até que o usuário feche a janela principal.
Agora vem a construção do ciclo de vida do programa. Na figura 22, é apresentado o trecho
inicial do ciclo de vida dos componentes.
 
Shutterstock
Mesmo para um projeto pequeno, existem muitos detalhes a ser observados. Logo na linha 1
está a implementação da classe principal do sistema. É nessa classe que vai estar a lógica do
tratamento do ciclo de vida dos componentes gráficos. Das linhas 4 a 21, cada objeto que se
refere a um componente gráfico é instanciado. Em especial, merece atenção a linha 11:
self.btnCalcular=tk.Button(win, text='Calcular Média', command=self.fCalcularMedia)
/
Nessa linha, o objeto ‘btnCalcular’ do tipo ‘tk.Button’ recebe o texto ‘Calcular Média’, que vai
aparecer no botão e, além disso, é associado à função “fCalcularMedia”.
Outro ponto importante para observar no trecho de código da Figura 22 é a linha 2:
def __init__(self, win)
Que é a função “construtora” da classe, ou seja, o primeiro método a ser acionado no ciclo de
vida do componente raiz principal.
Ainda na função “init”, os componentes são posicionados na janela principal conforme é
possível verificar na Figura 23.
 
Shutterstock
Um trecho interessante de ser destacado é a linha 21. Nele, é feito uma chamada para o
método “carregarDadosIniciais”. Esse método é o responsável por carregar os dados que já
estão armazenados na planilha para o componente “treeview”, que é a grade que aparece na
tela principal. Na Figura 11, é apresentado o código do método “carregarDadosIniciais”.
/
 
Shutterstock
Como dito anteriormente, o objetivo desse método é carregar os dados da planilha para o
componente “treeview” que é a grade que aparece na janela principal. Um dos problemas que
podem ocorrer nessa tentativa de carregar os dados é que ainda não existem dados, ou
mesmo, uma planilha de onde carregá-los.
 SAIBA MAIS
Caso não seja dado um tratamento explícito para essa situação de exceção, o programa vai
apresentar uma mensagem de erro, caso a planilha não exista. O ideal é detectar todas as
situações de exceção logo no começo do projeto, pois isso evitará o consumo de horas de
testes que podem ser mais bem direcionadas para tentar descobrir problemas mais complexos
que podem ser vulnerabilidades para o sistema. O tratamento de exceção foi dado pela
aplicação das cláusulas “try-except” (linhas 2 e 21).
Outro ponto interessante de se observar é na linha 4: “dados = pd.read_excel(fsave)”.
Com apenas um único comando, os dados da planilha de dados dos alunos são carregados
para a variável “dados”. Isso ocorre com o uso da função “read_excel” da biblioteca “pandas”.
Com isso, esses dados podem ser facilmente manipulados no código. O nome pelo qual esse
tipo de dado é conhecido é “datasets”. Das linhas 6 a 20, os dados são obtidos da variável
/
“dados” e inseridos no componente “treeview”. Caso ocorraalgum problema, será enviada a
mensagem “Ainda não existem dados para carregar”.
Esse tipo de programação protege o sistema de eventuais problemas através do
estabelecimento de um comportamento previsível. Assim, o código fica menos vulnerável
contra ataques que tentem ver mensagens padrões não tratadas que revelem características
sobre o código, ou o ambiente em que o sistema está operando.
Agora vem o cálculo da média do aluno, identificação de sua situação escolar e
armazenamento de dados no sistema.
Na Figura 25 é apresentado o código que é responsável por essas operações.
 
Fonte: O Autor
Novamente, deve ser destacado o bloco “try-except” nas linhas 2 e 17, pois o sistema está
esperando um nome ― que é um campo texto ― e duas notas ―, que são campos numéricos.
Caso o usuário entre com um dado inválido, ao invés de gerar uma falha o sistema vai exibir a
mensagem “Entre com dados válidos”. Além disso, esse método ainda possui a cláusula
“finally” que vai ser executada de qualquer modo. No caso, os campos de entrada serão
“limpos”.
No método “fCalcularMedia” são feitas chamadas para os métodos “fSalvarDados” e
“fVerificarSituacao”. O método “fSalvarDados” já foi explicado. Em relação ao método
“fVerificarSituacao”, ele é apresentado na Figura 26.
/
 
Fonte: O autor
É no método “fVerificarSituacao” em que a média é calculada e a situação escolar do aluno é
determinada. Das linhas 3 a 8, é encadeada uma série de testes a partir do cálculo da média
na linha 2. No final do método, na linha 10, são retornadas as variáveis “media” e a “situacao”
que correspondem, respectivamente, à média e à situação escolar do aluno para o método que
fez a chamada. Aqui, está mais uma vantagem da sintaxe do Python: Retorno de múltiplas
variáveis. Isso facilita bastante o processo de programação, poupando tempo para o
desenvolvedor.
 ATENÇÃO
Outro ponto que precisa ser observado, mais no sentido da sintaxe do Python, é o uso da
palavra reservada “self”. Esse projeto foi programado orientado a objetos (POO). Na POO, a
classe é formada por atributos e métodos. Quando são feitas referências aos métodos e
atributos na própria classe, é necessário indicar sua origem com o uso da palavra “self”
seguida de “.” (ponto-final).
EVOLUÇÕES
O sistema “simplificado de cadastro de notas de alunos” é funcional. Ou seja, com o que
foi construído até agora, é possível ter reuniões com os usuários para apresentar resultados,
detectar vulnerabilidades, fazer ajustes e propor avanços.
/
POR EXEMPLO, O USUÁRIO PERCEBEU A
NECESSIDADE DE UMA TELA DE LOGIN EM
QUE ALUNOS E FUNCIONÁRIOS TIVESSEM
VISÕES ESPECÍFICAS DAS FUNCIONALIDADES
DO SISTEMA. OUTRO PONTO PARA EVOLUIR É
SOBRE O ARMAZENAMENTO DE DADOS, OU
SEJA, PARTIR PARA UMA SOLUÇÃO QUE USE
UM SISTEMA GERENCIADOR DE BANCO DE
DADOS. DE ACORDO COM ESSE CONTEXTO,
QUE TIPOS DE VISUALIZAÇÕES DE
INFORMAÇÕES QUE OS USUÁRIOS PODERIAM
SENTIR NECESSIDADE?
RESPOSTA 1
RESPOSTA
Os usuários poderiam perceber a necessidade de ter mais algumas visualizações de
informações, como, por exemplo, a média e o desvio-padrão da turma, pois essas
informações poderiam apoiar o setor pedagógico da escola no desenvolvimento de
estratégias para detectar problemas e propor soluções para a turma de um modo geral.
Portanto, tem uma série de questões nesse exemplo que se encaixam em uma metodologia
evolutiva como a RAD. Mas é importante que fique claro que a parte mais importante da RAD
está na qualidade dos profissionais envolvidos no processo, portanto investir em qualificação
técnica e acadêmica é fundamental e no ambiente colaborativo entre as partes interessadas.
javascript:void(0)
/
VÍDEO
Construindo o protótipo
VERIFICANDO O APRENDIZADO
/
1. NO INÍCIO DE UM PROJETO, É NECESSÁRIO COMPREENDER QUAIS
SÃO OS REQUISITOS QUE DEVEM SER TRATADOS PARA ATENDER ÀS
DEMANDAS DO NEGÓCIO. NESSE SENTIDO, SELECIONE A OPÇÃO
CORRETA RELACIONADA À DESCRIÇÃO DOS REQUISITOS DE UM
SISTEMA:
A) Escopo: Apresenta pormenores da implementação do sistema.
B) Interfaces do sistema: Descreve os componentes interativos do sistema.
C) Propósito: Apresenta uma descrição do Sistema e para quem ele se destina.
D) Interfaces de usuário: Identifica com quais sistemas do usuário será feita a integração do
software.
2. A COMPREENSÃO DOS REQUISITOS DE UM SISTEMA É ESSENCIAL
PARA INICIAR UM PROJETO DE DESENVOLVIMENTO DE SOFTWARE.
NESSE PROCESSO, ALGUMAS INFORMAÇÕES A RESPEITO DO
SISTEMA DEVEM SER EXPOSTAS DE MODO A RECEBER O
TRATAMENTO ADEQUADO NAS ETAPAS POSTERIORES DO
DESENVOLVIMENTO DO SISTEMA. NESSE SENTIDO, SELECIONE A
OPÇÃO CORRETA QUE RELACIONA INFORMAÇÕES SOBRE
REQUISITOS DE UM SISTEMA E SUA RESPECTIVA JUSTIFICATIVA:
A) Propósito: Descrever as funcionalidades do sistema e como deve ser sua operação no dia a
dia.
B) Escopo: Descrição do sistema e delimitação de funcionalidades.
C) Interfaces de software: Descrição dos elementos de interface com o usuário.
D) Especificação de Requisitos Funcionais: Definição dos papéis funcionais dos usuários no
sistema e quais requisitos devem ser atendidos para sua correta operação.
GABARITO
1. No início de um projeto, é necessário compreender quais são os requisitos que devem
ser tratados para atender às demandas do negócio. Nesse sentido, selecione a opção
correta relacionada à descrição dos requisitos de um sistema:
/
A alternativa "C " está correta.
 
O propósito de um sistema descreve o que é o sistema e identifica quais serão os seus
usuários.
2. A compreensão dos requisitos de um sistema é essencial para iniciar um projeto de
desenvolvimento de software. Nesse processo, algumas informações a respeito do
sistema devem ser expostas de modo a receber o tratamento adequado nas etapas
posteriores do desenvolvimento do sistema. Nesse sentido, selecione a opção correta
que relaciona informações sobre requisitos de um sistema e sua respectiva justificativa:
A alternativa "B " está correta.
 
O escopo do sistema é a descrição do que ele se propõe a fazer. Portanto, é necessário
apresentar suas funcionalidades e outras informações relevantes que deem suporte para que o
usuário tenha uma clara compreensão sobre o sistema.
CONCLUSÃO
CONSIDERAÇÕES FINAIS
No decorrer do texto, apresentamos aspectos práticos das fases da metodologia RAD, tais
como as etapas para identificar os requisitos de um sistema, as modelagens de negócios e de
dados, o design de interface com o usuário e o desenvolvimento de uma aplicação utilizando a
linguagem de programação Python.
A compreensão de como estas etapas devem ser realizadas e como se relacionam é um
requisito para poder utilizar a RAD da forma adequada. Essa metodologia não é recomendável
para qualquer situação, no entanto, em casos de sistemas com baixa complexidade que,
atualmente, correspondem à maioria das situações do cotidiano, a RAD é uma forte candidata
para apoiar o desenvolvimento.
/
Os benefícios da aplicação da RAD têm impacto desde a melhor utilização do tempo das
partes envolvidas até a minimização dos riscos do projeto, através de um processo
colaborativo. A escolha da linguagem Python para projetos RAD é natural devido à vasta
disponibilidade de documentação e de pacotes de componentes gráficos e de manipulação de
dados que facilitam o desenvolvimento.
REFERÊNCIAS
ALAVI, M. An assessment of the prototyping approach to information systems
development. In: Communications of the ACM, 27, 556-563, 1984.
 
BERGER, H.; BEYNON-DAVIES, P. The utility of rapid application development in large-
scale, complex projects. In: Information Systems Journal, 2009, 19(6), 549– 570.
 
DOCS.PYTHON. Python 3.8.5 Documentation. Consultado em meio eletrônico em: 01 out.
2020.
 
DOCS.PYTHON. Tkinter ‒ Python interface to Tcl/Tk. Consultado em meio eletrônico em: 01
out. 2020.
 
KERR, J.; HUNTER, R. Inside RAD: How to Build Fully Functional Computer Systems in 90
Days or Less. New York: McGraw-Hill, 1994.
 
https://docs.python.org/3/library/tkinter.html#module-tkinter/
MARTIN, J. Rapid Application Development. USA: Macmillan, 1991.
 
PRESSMAN, R. Engenharia de Software: Uma abordagem Profissional. 7. ed. Porto Alegre:
Bookman, 2011.
 
SPYDER-IDE. Spyder. Consultado em meio eletrônico em: 01 out. 2020.
EXPLORE+
Para saber mais sobre os assuntos tratados neste tema, visite os seguintes sites na internet:
O site oficial do Python e leia sobre conceitos da linguagem e de aplicações GUI, além de
poder fazer downloads de diversos pacotes para desenvolvimento rápido.
O site oficial de documentação da Microsoft e procure por normalização de tabelas de
bancos de dados.
O site oficial do Planalto do Governo Federal e procure pela lei nº 13.709. Veja também
mais detalhes sobre a Lei Geral de Proteção de Dados.
CONTEUDISTA
Sérgio Assunção Monteiro
 CURRÍCULO LATTES
javascript:void(0);