Apostila - Pensamento-Computacional

PENSAMENTO
COMPUTACIONAL
PARA INDÚSTRIA 4.0
Professores Reginaldo Barbosa Nunes & Victorio Albani de Carvalho
Ministério da Educação
Ministro da Educação
Milton Ribeiro
Instituto Federal de Educação, Ciência

e Tecnologia do Espírito Santo - Ifes
Reitor
Jadir Pella
Campus Vitória
Diretor Geral
Hudson Cogo
Diretor de Extensão
Christian Mariani Lucas dos Santos
Oficinas 4.0
Coordenação Geral
Rodrigo Varejão Andreão
Marcelo Queiroz Schimidt
Gabriel Tozatto Zago
Jordando Celestrini
Professores Autores
Reginaldo Barbosa Nunes/Ifes
Victorio Albani de Carvalho
Equipe Pedagógica
Ítalo Severo/Ifes
Wagner Scopel/Ifes
Jaqueline Almeida/Ufes
Equipe de Design Institucional

Paloma de Souza Martins
Natalia Manarte
Eduardo Helmer
Tiago Casagrande
©2021 Instituto Federal de Educação, Ciência e

Tecnologia do Espírito Santo - Campus Vitória
É proibida a reprodução, mesmo que parcial,

por qualquer meio, sem autorização escrita
dos autores e do detentor dos direitos autorais
Instituto Federal de Educação, Ciência e

Tecnologia do Espírito Santo - Campus Vitória
Av. Vitória, 1729 - Jucutuquara, Vitória - ES
CEP: 29040-780
Telefone: 3331 2211 - Diretoria de Extensão
E-mail: direx.vi@ifes.edu.br
Laboratório
LabTef - Ifes - Campus Vitória
A nossas famílias, por sua compreensão em tempos de Cornavírus.
3 ••••
Agradecimentos
Agradeço a todos que contribuíram para a realização deste trabalho.
4 ••••
Indicação de ícones
Os ícones são elementos gráficos utilizados para ampliar as formas de linguagem e facilitar a
organização e a leitura hipertextual
Atenção:
Indica pontos de maior relevância no texto
Saiba mais:
oferece novas informações que enriquecem o assunto ou notícias recentes
relacionadas ao tema estudado.
Glossário:
indica a definição de um termo, palavra ou expressão utilizada no texto.
Mídias integradas:
sempre que se desejar que os estudantes desenvolvam atividades empregando
diferentes mídias: vídeos, filmes, jornais, ambiente AVEA e outras.
Exemplo:
apresenta um exemplo ou um exercíco resolvido a fim de que o estudante
possa compreender melhor o conteúdo estudado.
Atividades de aprendizagem: apresenta atividades em diferentes níveis de

aprendizagem para que o estudante possa realizá-las e conferir o seu domínio
do tema estudado.
Faça sua Busca:

apresenta perguntas que possam despertar a curiosidade do leitor e provocar
uma busca pela resposta.
5 ••••
“As invenções são, sobretudo, o resultado de um trabalho teimoso.”
(Santos Dumont)
6 ••••
Sumário
INTRODUÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Apresentação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Palavra do Professor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Apresentação do Curso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
PENSAMENTO COMPUTACIONAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Conceito de Pensamento Computacional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Sistemas de Computadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15
O Hardware dos Computadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
O Software dos Computadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Sistemas de Numeração . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Notação posicional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Conversão entre bases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Representação dos Dados no Computador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Tipos Básicos de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Ambientes de Programação C/C++ e Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Declaração de Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Atribuição de valor a Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
INTRODUÇÃO À LÓGICA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Conceitos Básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Construção de Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37
Controle do Fluxo de Execução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Fluxo Sequencial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Entrada e Saída de Dados em C/C++ e Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Operadores Lógicos, Relacionais e Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Fluxo de Execução com Estruturas de Decisão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Estrutura de Seleção Simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Estrutura de Seleção Múltipla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .48
Fluxo de Execução com Estrutura de Repetição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Estruturas de Repetição. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Estrutura para número de Repetições conhecidas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Comandos de Desvio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
7 ••••
MODULARIZACÃO E FUNÇÕES. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Construindo Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Passagem de Parâmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Módulos em Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Importando parte de um Módulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Bibliotecas e Cabeçalhos em C/C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Criando o Arquivo Cabeçalho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Criando o Arquivo .cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Criando o arquivo biblioteca . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

ESTRUTURAS DE DADOS COMPLEXAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Estruturas Homogêneas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Listas e Tuplas em Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Acessando Elementos nas Estruturas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Percorrendo Listas e Arrays usando Laços . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Métodos Associados a uma Lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Estruturas de Dados Heterogêneas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
struct em C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
Atribuindo e Acessando os Dados em uma Struct . . . . . . . . . . . . . . . . . . . . . . . . . 80
Dados Heterogêneos em Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Persistência . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Persistência em Arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
REFERÊNCIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
8 ••••
Introdução
Apresentação
Prezado estudante,
Bem-vindo ao projeto Transformação Digital!
Você faz parte de uma rede nacional pública de ensino, o Instituto Federal do Espírito Santo, e
agora ao LabTef - Laboratório de Tecnologias do Futuro, que tem o objetivo de democratizar o acesso
as transformações digitais pelas quais o mundo atual esta passando. Neste curso, isto se dará a partir
de ensino de programação na modalidade a distância. Este projeto é resultado de uma parceria entre
o Ministério da Educação, por meio das Secretarias de Educação a Distancia (SEED) e de Educação
Profissional e Tecnológica (SETEC), as universidades e Institutos estaduais e federais.
A educação a distância no nosso país, de dimensões continentais e grande diversidade regional
e cultural, longe de distanciar, aproxima as pessoas ao garantir acesso à educação de qualidade, e
promover o fortalecimento da formação de jovens moradores de regiões distantes, geograficamente
ou economicamente, dos grandes centros, especialmente quando o mundo passa por uma crise
de proporções consideráveis e nos obriga à contenção e ao isolamento social em virtude dessa
pandemia (Covid19).
Este projeto leva cursos atualizados voltados para o desenvolvimento das capacidades
cognitivas alinhadas à mundo digital, incentivando os jovens a se engajar no processo de
transformação digital pelo qual passam nossa sociedade, quer seja na indústria no comécio e
principalmente na a educação. O Ministério da Educação, as instituições públicas de ensino, seus
servidores técnicos e professores acreditam que uma educação profissional qualificada e integradora
é capaz de promover o cidadão com capacidades para produzir, mas também com autonomia diante
das diferentes dimensões da realidade: cultural, social, familiar, esportiva, política e ética.
Nós acreditamos em você! Desejamos sucesso na sua formação profissional!
LabTef - Ifes - Ministério da Educação.

Maio de 2020
Capítulo 1. Introdução 9 ••••

Palavra do Professor
Caro Aluno,
Se Você ainda se pergunta: Por que estudar programação?
Vamos à resposta: Desde o lançamento dos primeiros computadores pessoais, ferramenta
que tem se tornado cada vez mais popular, essas tecnologias vêm evoluindo, aumentando seu
grau de penetração na sociedade e sendo utilizadas na realização das mais variadas tarefas, seja no
comércio, na indústria, na academia e até mesmo no cotidiano das pessoas. Ter conhecimentos sobre
computação deixou de ser uma opção e tornou-se necessidade, não só para inclusão no mercado de
trabalho, mas até para relacionar-se com pessoas ou grupos de interesse.
Há alguns anos, na área de informática, você poderia optar por três a quatro especializações
apenas; hoje estas possibilidades se multiplicaram, pelo fato de a informática permear praticamente
todas as atividades da sociedade moderna. Entretanto, dentre estes caminhos possíveis, a
programação ainda apresenta uma das maiores demandas de técnicos. Além disto, o estudo de
programação desenvolve um tipo de raciocínio (sequencial e lógico) base para resolver problemas
de várias outras áreas.
A formação deste tipo de raciocínio, necessário para você prosseguir com sucesso na
programação, é o principal objetivo deste curso. Embora exista uma certa dificuldade dos estudantes
de estruturar um raciocínio lógico computacional, nesta oficina, vamos ajudá-lo no desenvolvimento
de sua capacidade de abstração e análise de situações problema e de elaborar estratégias para
solucioná-las.
Se você não tem experiência com computadores, ainda assim você poderá realizar este curso
e concluí-lo com bom aproveitamento. Esta afirmativa é feita baseada em nossa experiência com
vários alunos de cursos presenciais, que chegam sem nenhuma experiência, enfrentando algumas
dificuldades no começo, mas que conseguem se superar e se tornam bons programadores. Como o
aluno a distância é especial, acreditamos que também conseguirá superar as dificuldades iniciais. Se
for preciso, peça a ajuda da equipe de apoio e também o auxílio de seus colegas.
Lembre-se: a melhor forma de aprender é praticando! Esta frase é ainda mais verdadeira para
a programação. Assim, organize seu tempo, dedique-se ao curso e aproveite: você deverá divertir-se
durante o processo de aprendizado.
Um abraço!
Prof. Reginaldo Barbosa Nunes

Apresentação do Curso
O curso de Programação para Transformação Digital será seu primeiro passo no aprendizado da
programação de computadores. Assim, ela é de fundamental importância para o seu desenvolvimento
nesta área, pois é nele que você aprenderá os fundamentos básicos que servirão de alicerce para os
desafios que a transfomação digital exige dos profissionais e cidadãos de modo geral.
Neste curso você aprenderá os principais conceitos sobre o pensamento computacional
e sobre programação. Entenderá o funcionamento básico de um computador, como ele trata os
diversos tipos de informação e aspectos sobre o armazenamento destas informações. Irá aprender
como traduzir instruções da linguagem natural para as linguagens utilizadas pelos computadores,
como C++ e Python. Além disso, terá a oportunidade de aplicar esses conceitos na prática, criando
algoritmos e programas completos e funcionais utilizando uma dessas duas linguagens de
programação.
A formação do raciocínio, necessário para você prosseguir com sucesso na programação, é o
principal objetivo deste curso. Por isso, nas primeiras aulas, você usará sua linguagem natura, porém
com uma sintaxe formal para escrever programas, mas que não é uma linguagem de programação
(no sentido ser entendida pelo computador). Na sequência do curso você estudará também as
linguagem C e Python.
Por que escolhemos estas duas linguagens para você iniciar com a programação? Porque C é
a base da sintaxe de diversas outras linguagens de programação, inclusive para Internet (Java, PHP,
Java Script...), com as quais você lidará caso pretenda continuar nesta área.
E o Python? Bem, esta linguagem tem ganhado um enorme destaque nos últimos anos. Dentre
todas as características dessa linguagem de programação, sem sombra de dúvidas, a simplicidade
é a que mais chama a atenção. Para usá-la, basta instalá-la em seu sistema e chamá-la no console.
Python nasceu com esse objetivo: ser simples, acessível e fácil de usar. Entretanto, não podemos
atribuir o sucesso da linguagem a um único fator. A tecnologia é muito mais que simplicidade.
Lembre-se de que, apesar de se tratar de um curso a distância, você não está sozinho nesta jornada.
Qualquer dúvida que tenha poderá acionar o tutor a distância e, sempre que necessário, poderá
solicitar que o tutor entre em contato com o professor. Além disso, temos à nossa disposição um
ambiente virtual cheio de recursos para nos auxiliar neste processo.
Bons estudos e sucesso!

Pensamento
Computacional
Objetivos
Conceituar Pensamento Computacional;

Identificar as partes dos sistemas computacionais;
Conhecer os sistemas de numeração utilizados em computadores.
Conhecer a representação dos tipos de dados usados em computadores.
Conceito de Pensamento Computacional
As Características do pensamento computacional Consistem em: realizar a formulação

de problemas; fazer uso da organização e análise lógica de dados; representar o mundo a partir
de abstrações; Buscar soluções automatizadas por meio de algoritmos; identificação análise e
implementação de soluções; generalização e transferência do processo de solução encontrado para
resolução de outros problemas.
Pensamento Computacional: pensar nos problemas de forma analítica e

desenvolver soluções em forma de algoritmos.
Algoritmos: é uma sequência finita de ações executáveis que visam obter

uma solução para um determinado tipo de problema.
Assim, o pensamento computacional deve tornar o estudante capaz de reconhecer elementos

da computação no mundo que os rodeia, aplicar técnicas e ferramentas do campo computacional
para entender os processos e sistemas naturais, artificiais e sociais presentes em todas as áreas.
Esse pensamento propõe o desenvolvimento de maneiras novas e criativas de pensar na
qual as pessoas sejam capazes de identificar problemas e buscar soluções a partir de diferentes
competências, que podem ser divididas em 4 grandes grupos:
Capítulo 2. Pensamento Computacional 12 ••••

Abstração
Essa habilidade propõe o foco em processos relevantes em vez de priorizar os detalhes, de
modo que a solução possa ser válida para outros problemas.
Ao filtrar e classificar os dados mais relevantes para a resolução das questões, voce deve ser
capaz de desenvolver uma análise mais crítica e atenta à essência do tema trabalhado.
Decomposição
Corresponde à habilidade de dividir um problema complexo em partes menores. Trabalhar um
fragmento do problema por vez facilita a solução desse problema, permitindo ainda maior atenção a
cada etapa. A decomposição ajuda a diminuir a ansiedade e o medo frente aos desafios. E possibilita
encontrar as respostas de cada parte do problema com mais confiança e rapidez, enquanto seguem
um passo a passo para a solução da grande questão.
Reconhecimento de Padrões
Para identificar tendências de comportamento é necessário observar atentamente a questão,
reconhecendo padrões e similaridades. Essa competência permite a construção de soluções para
problemas comuns de forma inovadora e empreendedora.
Construção de Algoritmos
Ainda que a palavra algoritmo seja mais utilizada no contexto computacional, esse pensamento
corresponde à criação de passos e soluções para alcançar um objetivo específico para qualquer
problema, de ordem matemática ou não. Desenvolver essa competência nos alunos estimula a
criatividade, a fim de construir soluções cada vez mais eficazes.
Atenção: Pensar computacionamente não está somente relacionado

a construir programas para computadores. Na verdade, pensar
computacionalmente é ser capaz estruturar de forma estratégica e analítica
uma sequência de ações aplicadas a qualquer situação problema.
Mídias: Entenda melhor a partir do vídeo:

https://www.youtube.com/watch?v=VhjoXRJ2teg

Exemplo: Suponha que você tenha que resolver uma situação problema de solução
inicialmente desconhecida.
Primeiro observamos o problema de maneira macro entendendo qual será
o resultado final esperado e quais recursos serão necessários para alcançar este
resultado (abstração);
Em seguida, focamos no problema e tentamos identificar como dividir este
problema em problemas menores, para resolvermos um de cada vez. Assim, para
cada problema menor repetimos o procedimento, verificando quais resultados deste
serão recursos para o próximo problema, e assim por diante (decomposição)
O passo anterior pode se repetir até um nível de detalhe em que os probleminhas
sejam tão simples que possam ser facilmente resolvidos. Se você chegou neste ponto
é por que os probleminhas têm solução conhecida, ou seja, você reconheceu um
padrão e identificou a solução usada para resolvê-lo (reconhecimento de padões).
Por fim, basta encadear a sequência de ações de forma a ir resolvendo cada
etapa da decomposição, e usar os resultados obtidos no problema maior, até obter a
solução do problema macro (construir o algoritmo).
Tente relacionar os passos anteriores à figura 1.
Figura 1 – Passos para resolução de problemas.

Atividade 1: Existem bolas vermelhas e azuis em uma caixa preta. Estas bolas precisam
ser separadas e armazenadas em outras duas caixa com as cores das respectivas
bolas. Escreva os passos necessários para executar esta tarefa em dois níveis de
detalhes diferentes, um com menos detalhes e outro com maior detalhamento que
o primeiro.
Embora, desenvolver o pensamento computacional possa ajudar em qualquer
atividade, nosso foco é aplicá-lo ao aprendizado de programação de computadores.
Assim, precisamos entender como um sistema computacional funciona. Na próxima
seção será apresentado um computador básico, quais os principais componentes e
dispositivos que o integram e como estas partes se relacionam.
Sistemas de Computadores
Muitos são os conceitos e exemplos associados aos sistemas computacionais. Todo processo
que envolve tecnologia computacional e seres humano, ou seja, Máquinas, programas e pessoas
compondo processos complexos e dinâmicos, pode ser considerado um sistema computacional.
Sistema de Computadores: consiste num conjunto de dispositivos

eletrônicos (hardware) capazes de processar informações de acordo com
um programa (software).
Assim, um sistema baseado em computadores é composto por hardware e software. Hardware

é o nome que se dá para a parte física do computador. É tudo que você pode tocar (mouse, teclado,
caixas de som, placas, fios, componentes em geral). Software é o nome que se dá a toda parte lógica
do computador, ou seja, os programas que você vê funcionar na tela e que dão “vida” ao computador.
Sem um software adequado às suas necessidades, o computador, por mais bem equipado e avançado
que seja, é completamente inútil.
Os sistemas computacionais atuais são compostos por algum tipo de microcontolador ou
microprocessador. Estes componentes são considerados máquinas digitais, pois trabalham com as

grandezas físicas representadas por digitos numéricos. Estas máquinas digitais são empregadas em
diversas áreas:
• Automação;
• Computadores e celulares;
• Robótica;
• Ciência e tecnologias médicas;
• Transporte;
• Telecomunicações;
• Entretenimento, entre outros.
De uma forma geral, podemos considerar estes sistemas como uma caixa preta que tem
entradas e saídas digitais e que realiza uma função determinada. As entradas são representadas
simbolicamente por uns e zeros e correspondem, por exemplo, ao estado de um interruptor (ligado
ou desligado) ou de um botão de pressão (pressionado ou não pressionado) ou ainda, ao estado de
uma afirmação (verdadeiro ou falso);
O Hardware dos Computadores
Nesta seção voce conhecerá as principais partes que compõem o hardware de um computador
. A figura 2 apresenta estas partes e vias pelas quais as partes se comunicam.
Hardware: é a parte física, isto é, todos os elementos concretos do

computador: dispositivos, placas e fios.
Unidade Central de Processamento:

A CPU (do inglês Central Processing Unit ou UCP - Unidade Central de Processamento),
microprocessador ou processador, é a parte do computador que interpreta e executa as instruções
contidas no software. Na maioria das CPUs essa tarefa é dividida entre uma unidade de controle que
dirige o fluxo do programa e uma ou mais unidades que executam operações em dados.
A UCP é constituída pelos seguintes componentes: a ULA (Unidade de Lógica e Aritmética), a
UC (Unidade de Controle) e os registradores. É no interior deste componente que os programas são
executados. A UC funciona como um coordenador que controla a ULA, responsável por realizar as
operações lógicas e aritméticas contidas em cada uma das instruções do programa. Para que isto
ocorra é preciso que tanto a instrução quanto os operandos estejam armazenados nos registradores.

Exemplo: Suponha que deseja-se realizar a soma dos números 5 e 3. Observe na figura 2, que
os valores dos operandos e a operação a ser realizada se encontram armazenados nos resgistradores.
A UC ordena que a ULA que execute a operação e armazene o resultado em outro registrador, para
que este possa ser utilizado posteriormente. Assim, um dos registradores receberá o número 8 como
resultado da operação de soma.
Figura 2 – Partes físicas do computador e as vias de intecomunicação.
Como saber, dentre dois processadores diferentes, qual é o mais rápido?
Memórias:
O computador deve ser dotado de alguma forma de armazenamento temporário (RAM
do inglês Random Access Memory ou memoria de acesso aleatório) ou permanente (ROM do
Inglês textitRead Only Memory ou memória somente de leitura), para que os dados coletados ou
processados possam ser armazenados. A essa estrutura damos o nome genérico de memória (não
está contextualizado aqui o tipo da memória).

Qual é a memória mais rápida de um computador?
A memória armazena, essencialmente, os bits. A menor unidade de informação em um

computador é o bit, que pode assumir os valores 0 ou 1. Como um único bit é insuficiente para
representar informações, eles são agrupados e combinados. Num primeiro agrupamento, são
reunidos em conjuntos de oito bits, recebendo a denominação de Byte.
Entretanto, a unidade byte (unidade de medida de armazenamento) também é,
consideravelmente, pequena quando precisamos manipular informações mais complexas, por isso,
utilizamos um conjunto de bytes, denominado palavra do computador: 4 bytes (32 bits) ou 8 bytes
(64 bits) por exemplo.
A palavra do computador indica que porção de bytes pode ser armazenada em cada registrador
do processador. Entretanto, para identificar a capacidade que uma memória tem para armazenar
dados utilizamos múltiplos do bytes: Kilobyte, Megabyte, Gigabyte, Terabyte e assim por diante.
Bit: A contração das palavras dígito binário em ingles (binary digit) é o

bit. O bit é a menor unidade de informação em sistemas computacionais.
Daqui por diante o dígito binário será chamado de bit.
Byte: As unidades de medida de informação indicam a quantidade de

informação manipulada. No modelo digital utilizamos potências de base
2. Por exemplo: 1 byte é igual a 23 = 8 bits; 1 kB é igual a 210 = 1024 bytes.
Mídias: Se preferir ver um vídeo com mais informações sobre o

funcionamento da CPU e da Memória, click no link abaixo:
https://www.youtube.com/watch?v=69svptJTE9Y.

Unidades ou dispositivos de entrada e saída:
“Os dispositivos de E/S (Entrada e Saída) são constituídos, geralmente, de
duas partes: o controlador e o dispositivo propriamente dito. O controlador
é um chip ou um conjunto de chips que controla fisicamente o dispositivo;
ele recebe comandos do sistema operacional (software), por exemplo, para
ler ou escrever dados nos dispositivos” (TANEMBAUM, 2003).
Unidades de entrada são, portanto, dispositivos físicos que capturam os dados a serem
processados. Os dados podem ser do tipo texto, vídeo ou áudio. Para cada tipo de dado temos um
dispositivo de entrada especifico para sua leitura: teclado, mouse, scanner, etc.
Unidades de saída apresentam os resultados finais do processamento. Para o usuário, os
dispositivos de saída são tão normais que quase não são percebidos: monitores de vídeo, Capítulo
2. Pensamento Computacional 18 impressoras, plotter, telas de terminais bancários, impressoras de
extratos, painéis de senha, quiosques de consultas de preços, etc.
Existem também alguns dispositivos que podem ser classificados com ambas as denominações,
entrada e saída, por exemplo: telas touch screen, etc.
Dispositivos de armazenamento de massa:

Dispositivos ou unidades de armazenamento são aqueles componentes que, embora, não
apresentem resultados para observação direta com o usuário, também são de entrada e saida do
ponto de vista do processador. É nestes dispositivos que são armazenados os software e a mídias
como áudios, vídeos, textos e todo tipo de informação. Esses componentes armazenam estes
dados de forma permanente, ou seja, enquanto os dados da memória RAM são perdidos quando o
computador é desligado, nos dispositivos de armazenamento os dados permancem sem alteração.
Alguns exemplos de dispositivos de armazenamento são: HDs, SSDs, pen drives, cartões SD e outros.
Saiba Mais: você pode encontrar no link abaixo mais informações sobre
os dispositivos de armazenamento, entrada e saída de dados:
https://blog.maxieduca.com.br/tipos-dispositivos-perifericos/
Mídias: se você prefere ver um vídeo, copie e cole o link abaixo no seu
navegador: https://www.youtube.com/watch?v=1BUaQSpGfxct=8s

O Software dos Computadores
Um programa de computador pode ser definido como uma série de instruções ou declarações,
em forma inteligível pelo computador, preparada para obter certos resultados. Um programa pode
ser chamado de software, porém esse termo pode ser utilizado também para um grupo de programas
ou para todo o conjunto de programas de um computador.
Software: é uma sequência de instruções escritas para serem interpretadas

por um computador com o objetivo de executar tarefas específicas.
Também pode ser definido como os programas que comandam o
funcionamento de um computador.
Podemos classificar os software ou programas de várias formas. A seguir apresentamos uma

classificação genérica.
Software Básico
São software destinados à operação do computador. Têm como função principal controlar os
diversos dispositivos do computador e servir de comunicação intermediária entre o computador e
os outros programas normalmente utilizados, o que permite que esses possam ser executados. Sua
classificação básica pode ser:
• Sistemas ou Ambientes Operacionais - é o grande responsável pelo funcionamento do

computador, a interação e sincronização de todos os elementos que fazem parte do conjunto
computacional. Sem um sistema operacional o computador não passa de um monte de placas
de circuito sem função definida. Os sistemas operacionais mais utilizados nos dias de hoje são
o Windows, o Android, o IOS e o Linux.
• Compiladores e Interpretadores - São os softwares responsáveis por transformar as instruções

escritas em uma liguagem de programação de alto nível (linguagem que as pessoas entendem)
para instruções em linguagem de baixo nível (linguagem de máquina - linguagem que o
computador entende).

Qual a diferença entre um compilador e um interpretador?
Software de Aplicação
São os programas destinados a nos oferecer certos tipos de serviços. Podemos incluir nessa
categoria todos os demais programas utilizados diretamente pelo usuário final do computador. Eles
podem ser classificados ainda como:
• Uso Geral - São programas ou conjunto de programas desenvolvidos para atender diversos
tipos de usuários nas mais diversas atividades: os processadores de texto, as planilhas
eletrônicas, os programas gráficos, os sistemas gerenciadores de banco de dados e outros.
• Uso Específico - São software desenvolvidos sob encomenda para empresas que utilizam
aplicações específicas, como, por exemplo, aplicações de controle financeiro, controle de
produção, controle de clientes, faturamento, etc.
Os software são construídos a partir de outros softwares, por exemplo, utilizamos um editor
de texto para escrever um programa em linguagem de alto nível, depois utilizamos um compilador
para traduzir o programa para a linguagem de máquina (zeros e uns), Capítulo 2. Pensamento
Computacional 20 transformando-o em programa executável. Este último, então, pode ser executado
a partir do sistema operacional do computador.
Tendo em mente que estas máquinas operam com digitos, e especialmente digitos binários,
na próxima seção iremos conhecer as representações por dígitos numéricos mais utilizadas quando
tratamos de sistemas computacionais.
Atividade 2: Qual a diferença entre hardware e software?

Atividade 3: Os dispositivos muitas vezes possuem um controlador que faz com que
o dispositivo funcione de acordo com o comando do usuário no sistema operacional.
Pensando assim, você entende que esse controlador é um hardware ou um software?
Explique.
Atividade 4: Como o tamanho da memória pode interferir no funcionamento do
computador?
Atividade 5: Indique uma função do Sistema Operacional de seu computador que
você mais utiliza. Atividade 6: Pesquise e indique quais são as duas unidades de
medida acima do TeraByte (TB).

Sistemas de Numeração
O Homem, através dos tempos, sentiu a necessidade de utilização de sistemas numéricos. Entre
eles, temos os Sistema Decimal, o binário, o octal e o hexadecimal. O sistema decimal é utilizado por
nós no dia-a-dia e é, sem dúvida, o mais importante dos sistemas numéricos. Os outros sistemas, em
especial o binário e o hexadecimal, são muito utilizados nas áreas técnicas digitais e na informática.
Saiba Mais: você pode encontrar no link abaixo mais informações

sobre a história dos sistemas de numeração:
http://www.uel.br/projetos/matessencial/fundam/numeros/numeros.html
Mídias: se você prefere ver um vídeo, copie e cole o link abaixo no seu
navegador: https://www.youtube.com/watch?v=ntylzQWvzCA
Notação posicional
O Homem, através dos tempos, sentiu a necessidade de utilização de sistemas numéricos. Entre
eles, temos os Sistema Decimal, o binário, o octal e o hexadecimal. O sistema decimal é utilizado por
nós no dia-a-dia e é, sem dúvida, o mais importante dos sistemas numéricos. Os outros sistemas, em
especial o binário e o hexadecimal, são muito utilizados nas áreas técnicas digitais e na informática.

Exemplo: Suponha que o número 1264 esteja representado por um sistema de
numeração de base B. Assim o valor de cada digito deve ser multiplicado por seu
peso, onde o peso é a base elevada ao valor correspondente à posição do dígito no
número.
Observe então, que o número 1264 escrito na base 8 (octal) tem o valor de 692 em
decimal (base 10). No sistema decimal, um número é expresso através da soma
de potências de base 10 multiplicadas pelo respectivo coeficiente (dígito). Como
características do sistema de numeração decimal temos: Base: 10 Dígitos possíveis:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Já para o sistema de numeração octal (base 8) as potências são
de base 8 e suas características são as que seguem: Base: 8 Dígitos possíveis: 0, 1, 2,
3, 4, 5, 6, 7.
Assim, na base 2 (binária) teremos apenas dois símbolos e as características
são as que seguem: Base: 2 Dígitos possíveis: 0, 1. Para o sistema de numeração
hexadecimal (base 16) será necessário acrecentar mais 06 (seis) digitos diferentes (as
letras maiúsculas de A a F). Assim, temos como características deste sistema: Base:
16 Dígitos possíveis: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F. Onde: A vale 10, B vale 11 e
assim por diante, até F com valor 15.
Atenção: O valor da Base de um sistema de numeração indica quantos

dígitos diferentes podemos usar para expressar um número nesta base.

Como é contagem nestes Sistemas de Numeração?
Comece com o primeiro dígito possível como primeiro número, o próximo dígito possível
representa o segundo número e assim por diante até terminar os dígitos possíveis. Como não há mais
dígitos diferentes para usar, o próximo número será o segundo dígito possível seguido do primeiro
dígito possível. veja a tabela a seguir com os 17 (dezessete) primeiros números de cada sistema:
* Onde terminam os digitos possíveis em cada sistema de numeração.

# A partir deste número hexadecimal precisamos acrescentar as letras de A ate F.
Porque os computadores não usam o sistema Decimal?

Suponha um computador decimal com erro de 10 %, ou seja, um valor no computador para
representar o Dígito “1”poderia ser medido entre 0,9 e 1,1 volts de tensão elétrica. veja a que para
algumas medidas pode ocorrer ambiguidade. O sistema binário, mesmo com erro de 50 % ainda
consegue evitar ambiguidades nos valores.
Conversão entre bases
A passagem de uma base X para outra base Y, consiste em decompor o número de acordo com
a estrutura posicional, usando as operações de produto, divisão e soma. Para facilitar o cálculo das
operações de conversão de base, vale pena relebrar as potências das base numéricas utilizadas em
computação:
Bases : 2 (binária), 8 (octal), 10 (decimal) e 16 (hexadecimal).
Atenção: Para indicar a qual base um número pertence vamos adotar o

seguinte formato: sequência de digitos seguida do número da base entre
parênteses: 123(8) -> indica que o número 123 está escrito na base 8 (octal).

Passagem da base B para base 10
Basta multiplicar cada dígito pela potência de B correspondente a sua posicão e somar os
resultados das multiplicações.
Como visto, multiplica-se cada digito pelo peso correspondente a sua posição
Exemplo: deseja-se passar o número 1423(8) para decimal:
Como resultado, temos o número decimal 787.
Passagem da base 10 para base B

Basta fazer a divisão inteira do número por B repetidas vezes, até que o quociente seja menor que B.

Conversão entre as base 2 e 8
Observe que 8 = 23 . Assim, cada dígito na base 8 corresponderá a 3 (três) dígitos na base 2.
A conversão deve ser feita considerando cada dígito octal de forma independente para gerar três
dígitos binários. Para conversão inversa, cada três dígitos binários tomados da direita para esquerda
deverão ser convertidos de modo independente para o dígito octal correspondente.
Conversão entre as base 2 e 16

Observe que 16 = 24 . Assim, cada dígito na base 16 corresponderá a 4 (quatro) dígitos na
base 2. A conversão deve ser feita considerando cada dígito hexadecimal de forma independente
para gerar quatro dígitos binários. Para conversão inversa, cada quatro dígitos binários tomados da
direita para esquerda deverão ser convertidos de modo independente para o dígito hexadecimal
correspondente.

Como converter entre as bases 8 (octal) e 16 (hexadecimal)?
Dica: Use a base binária como intermediária.
Atividade 7 – Converter os números abaixo para a base decimal:

a) 722(8) -> __________(10)
b) 101100(2) -> __________(10)
Capítulo 2. Pensamento Computacional 26
c) 2AE(16) -> __________(10)
d) 5B1(16) -> __________(10)
Atividade 8 – Faça a conversão da base decimal para as bases especificadas nos

parênteses:
a) 789(10) -> __________(8)
b) 219(10) -> __________(2)
c) 463(10) -> __________(16)
d) 5432(10) -> __________(16)
Atividade 9 - Converter cada um dos números binários para as bases octal e

hexadecimal:
a) 1100110(2) -> __________(8) e __________(16)
b) 11010111(2) -> __________(8) e __________(16)
c) 11110010(2) -> __________(8) e __________(16)
d) 10001001(2) -> __________(8) e __________(16)
Atividade 10 - Converter os números das respectivas bases para a base binária:

a) 1C2(16) -> __________(2)
b) 741(8) -> __________(2)
c) D4(16) -> __________(2)
d) 327(8) -> __________(2)

Representação dos Dados no Computador
Os sistemas computacionais tratam de diferentes tipos de dados, caracteres, valores inteiros,

valores reais, valor lógico (verdadeiro ou falso), cores entre outros. Porém todos são representados
por alguma sequência ou conjunto de sequências de dígitos binários.
Como diferenciar os tipos dados, se tudo é representado por

dígitos binários?
Na verdade quem diferencia os conjuntos de dígitos binários é o programa de computador que

está sendo executado. Veremos como isto é feito com mais detalhes quando estivermos estudando
as linguagens de programação.
Os valores lógicos, por exemplo podem ser representados por um único dígito binário (bit), enquanto
um caracter pode precisar de 8 bits. Valores inteiros e reais podem precisar de ainda mais bits.
Tipos Básicos de Dados
Há variações nos termos para linguagens diferentes, porém, em geral, podemos ter os seguintes
tipos de dados em linguagens de programação:
Lógico: Um dado lógico armazena 1 bit para representar verdadeiro ou true (1) ou para
representar falso ou false (0). Para Java, usa-se a palavra reservada boolean. Já na Linguagem C
padrão não existe esse tipo primitivo de dado, podendo ser usado o tipo inteiro para isto onde zero
(0) é falso, e qualquer valor diferente de zero (x<>0) é verdadeiro.
Literal: Dados deste tipo incluem um caractere ou um conjunto deles, incluindo letras, símbolos
e números. Vale destacar que não se pode usar dados literais para realização de operações matemáticas. Em
geral os dados literais ocupam 8 bits, independente do hardware, uma vez que são, em sua maioria,
baseados na tabela ASCII (Fig.3). Para declarar uma variável ou uma constante literal em Linguagem C,
pode-se usar a palavra reservada char, que armazenará apenas 1 caractere. Já em Java pode-se utilizar
char para 1 caractere ou String para um conjunto deles;

Figura 3 – Tabela de caracteres ASCII.
Inteiro: Um número inteiro é aquele que não possui parte fracionária, podendo representar
quantidades positivas, negativas ou zero. Para declarar uma variável ou constante inteira em Java ou
Linguagem C, é utilizada a palavra reservada int;
A representação de inteiros pode variar quanto ao número de bits que ocupa. E quanto maior
o número de bits utilizado maior o range de valores que a variável pode armazenar:
Variável inteira com 8 bits (1 byte) - pode armazenar um entre 256 (28) números diferentes, no
range de 0 a 256 se for sem sinal (uint8) ou de -128 a 127 se for com sinal (int8).
Podemos ter ainda inteiros com 16, 32 ou 64 bits, e nesse caso a o range de valores que poderá
ser armazenado aumenta conforme a potência de 2 (216, 232 e 264).
Real: Um número real em computação não possui a mesma definição rigorosa da matemática,
já que para ela existem infinitos números entre 0 e 1 (0.1, 0.01, 0.001,
. . . ). Há uma certa limitação de acordo com a capacidade de armazenamento do hardware
do computador, que definirá quais são os limites possíveis para se representar números ditos reais.
Dessa forma, pode representar números com parte fracionária positivos e negativos, além do zero.
Para declarar uma variável ou contante real em linguagem C ou Java, podem ser utilizadas as palavras
reservadas double ou float, cada qual com sua capacidade específica;
Um real float é representado com 32 bits, dos quais um (1) é utilizado para o sinal (+ zero e -
um), 8 bits para o expoente e 23 para a mantissa. Por exemplo:w

Figura 4 – Exemplo de representação de número real tipo float.
Um real de dupla precisão, o tipo double é representado por 64 bits, sendo um para o sinal, 11
bits para o expoente e 52 bits para a mantissa
Atenção: Muitas linguagens exigem que voce declare qual o tipo de

dado uma determinada variável do programa vai conter. Estas linguagens
são chamadas linguagens tipadas: C, C++, Java, Pascal e outras. Entretanto
existem linguagens que não exigem esta formalidade, ou seja, no momento
em que um dado é armazenado na variável é que o tipo dela é identificado.
Isto ocorre com as linguagens não tipadas: Python e MatLabScript e outras.

Ambientes de Programação C/C++ e Python
Quando queremos construir algoritmos que computadores possam entender e executar, é
necessário que utilizemos uma linguagem de programação que disponha de um compilador que
transforme o algoritmo em um programa a ser executado. O arquivo contendo o algoritmo que
desenvolvemos é chamado de “fonte”, pois é a partir dele que o compilador vai criar o programa a
ser executado.
Linguagem de Programação: É uma forma padronizada para expressar

instruções para um computador;
Compilador É um programa que traduz algoritmos construídos em uma
determinada linguagem de programação para arquivos em linguagem
de máquina.
Linguagem de Máquina é a linguagem de mais baixo nível, que pode
ser entendida pelo processador (UCP). É constituída inteiramente de
números binários.
A partir daqui, iremos trabalhar com duas linguagens de programação, C/C++ e Python.
Os exemplos quando necessários serão apresentados nas duas linguagens.
Portanto, precisamos conhecer os ambientes para editar compilar e executar programas
nestas linguagens.
Os ambientes de desenvolvimento integrados (do inglês Integrated Development
Environment - IDE) são softwares que facilitam o desenvolvimento de programas pois possuem
em um único ambiente editores de textos com recursos específicos para editarmos um programa fonte,
um compilador para determinada linguagem de programação e além disso, outras ferramentas para
possibilitar encontrar determinados erros na criação do programa.
Saiba Mais: Existem vários sites que disponibilizam compiladores online para
diversas linguagens. Entre eles está o OnlineGDB, que pode ser acessado
pelo link: https://www.onlinegdb.com

Declaração de Variáveis
Este termo já foi utilizado na seção 2.5.1, mas vale uma definição.
Variável: Uma variável pode ser definida como um espaço de memória

reservado para uma utilização específica cujo valor armazenado pode ser
alterado ao longo da execução do programa
Em termos de hardware, as variáveis podem ser armazenadas em memórias que podem ser
regravadas, como por exemplo na memória RAM. Uma variável pode assumir apenas um valor a cada
instante.
Para facilitar o entendimento da programação em médio e alto níveis, não se utiliza o endereço
físico da memória na qual está o valor de uma possível variável em uso. O que se faz é utilizar
nomes associados a tais endereços. A alocação de variáveis não é necessariamente uma tarefa do
programador, sendo executada automaticamente pelo compilador.
Em algumas linguagens, para que as variáveis existam, elas devem ser previamente declaradas. É
neste momento, da declaração de variáveis, que informamos o tipo da variável. É importante observar
que se uma variável foi declarada como sendo do tipo inteiro, ela não poderá armazenar valores reais.
Neste caso, há um erro de semântica, uma vez que uma variável de um tipo só pode armazenar valores
deste mesmo tipo.
A sintaxe em liguagem C a seguir exemplifica a declaração de diferentes tipos de variáveis:
Modelo:
tipo variável;
Exemplos:
int numero_1; /* a variável numero_1 é declarada como tipo inteiro de 32 bits*/;
float salario; // a variável salario é declarada como tipo ponto flutuante de 32 bits;
char letra; // a variável letra é declarada como tipo caracter de 8 bits.
char palavra[n] // palavra será um conjunto de n (natural) caracteres de 8 bits

Comentários: Em programação utilizamos comentários para explicar a
lógica utilizada em nossos algoritmos.
Em C/C++, os sinais /* e */ indicam o início e o fim de um comentário, que
pode ocupar mais de uma linha. Os sinais // indicam um comentário que
vai até o fim da linha.
Em Python, as aspas triplas / / / ou ” ” ” tem a mesma função das sequencias
/ * e * /, porém o comentário irá aparecer na documentação do programa. No
python você pode usar # como comentário de apens uma linha exatamente
como o //.
Para deixar o código mais organizado e economizar tempo de digitação, pode-se declarar
várias variáveis do mesmo tipo da seguinte forma:
Modelo:
tipo nome1, nome2, nome3;
Exemplos:
float salario, caixa, desconto; // as 3 variáveis foram declaradas como float 32 bits.
É importante destacar que algumas regras e recomendações devem ser seguidas para
declaração de variáveis:
• Pode conter 1 ou mais caracteres alfanuméricos, sendo que o primeiro sempre deve ser uma
letra;
• Não utilizar espaços ou caracteres especiais (salvo o famoso “underline” _);
• Não é permitido criar variáveis usando palavras reservadas (ex.: int, float, etc);
• Usar preferencialmente nomes que possuam relação com o objetivo da variável, sendo sucinto,
mas sem exagerar nas abreviações para não dificultar a compreensão;
• Atenção especial para linguagens ditas “case sensitive”, uma vez que diferenciam
letras maiúsculas das minúsculas (ex.: int Valor; é diferente de int valor;);
Atribuição de valor a Variáveis
Agora vejamos como fica a sintaxe, tanto em C quanto em Python, para associar um valor a
uma variável:
Modelo:
variável = Valor;

Exemplos:
numero_1 = 10; // a variável numero_1 recebe o valor 10; salario = 880.34; // o valor 880.34 é
atribuído à variável salario; letra = ’A’; // a variável letra recebe o caracter A;
Há um diferença entre o C e o Python para atribuição de mais de um caracter a uma variável.

Python:
palavra = “Bela frase”; // a frase é atribuida diretamente à variável palavra.
C:
strcpy(palavra,”Bela frase”); // o C precisa de uma função de manipulação de
strings.
A função strcpy foi necessária, pois não se pode em C atribuir completamete os valores a este
tipo de variável diretamente. Mas isto veremos nos próximos capítulos.
String: Este termo corresponde a um conjunto de um ou mais caracteres
Atividade 11 - Você precisa declarar algumas variáveis para utilizar durante a

execução de um programa que calcula o reajuste de salário dos empregados. além
disso o programa calcula o tempo em anos que falta para cada empregado se
aposentar. Sendo que para mulheres o tempo é 5 anos menor que para homens.
Quais variáveis e de que tipo serão necessárias se o programa lê os dados do
empregado, e em seguida apresenta o reajuste acresecentando 1% a cada ano
trabalhado e o tempo restante para aposentadoria? o programa lê e apresenta as
respostas para cada empregado, sendo um por vez.
Atividade 12 - Você está para fazer um programa que calcula a quantidade de

homens e a quantidade de mulheres que se cadastraram como clientes. Quais
e de que tipo serão as variáveis necessárias para o correto funcionamento do
programa.
Atividade 13 - Quanto de memória, em bytes, ocupam as variáveis declaradas

nas atividades anteriores?

Introdução à lógica
Objetivos
Compreender os conceitos de lógica de programação e de algoritmos.
Conhecer operações e operadores lógicos e aritméticos.
Conhecer as principais estruturas de controle de fluxo de execução de algoritmos.
Conceitos Básicos
Nesta seção iniciaremos os estudos sobre Lógica de Programação. Mas antes, seria útil uma
reflexão sobre o significado da palavra “Lógica”. Assim, o que é Lógica?
Lógica: A lógica tem como objeto de estudo o pensamento, assim como

as leis e regras que o controlam, para que esse pensamento seja correto.
Os elementos constituintes da lógica são o conceito, juízo e raciocínio.
Aristóteles.
Utilizamos a lógica de forma natural em nosso dia a dia. Por exemplo:

a) Sei que o livro está no armário; Sei que o armário está fechado. Logo, concluo que tenho de
abrir o armário para pegar o livro.
b) Sei que sou mais velho que João; Sei que João é mais velho que José. Então, concluo
que eu sou mais velho que José.
Capítulo 3. Introdução à lógica 36 ••••

Atividade 1 – Sejam os seguintes fatos:
- Todos os filhos de João são mais altos do que Maria.
- Antônio é filho de João.
Então, o que podemos concluir logicamente?
Atividade 2 – Considere os fatos abaixo:

- José é aluno do IFES.
- Para ser aprovado, um aluno do IFES precisa obter nota maior ou igual a 60 e
comparecer a mais de 75
- José compareceu a todas as aulas e obteve nota igual a 80.
Então, o que podemos concluir?
Construção de Algoritmos
A lógica de programação é essencial para pessoas que desejam trabalhar com desenvolvimento
de programas para computadores. Lógica de programação pode ser definida como um conjunto de
técnicas para encadear pensamentos a fim de atingir determinado objetivo.
O objetivo fundamental de toda programação é construir algoritmos. Mas, afinal, o que é um
algoritmo?
Algoritmo: Como segunda definição podemos pensar em algoritmo como

uma receita, uma sequência de instruções que dão cabo de uma meta
específica (FORBELLONE et al., 2005).
Em outras palavras, quando criamos um algoritmo, apenas apontamos uma sequên- cia de
atividades que levam à solução de um problema. Até mesmo as soluções para os problemas cotidianos
mais simples podem ser descritas por sequências lógicas de atividades, ou seja, por algoritmos:
Problema: Trocar uma lâmpada.
Sequência de Passos para Solução:
1. Pegue uma escada;
2. Posicione a escada embaixo da lâmpada;

3. Pegue uma lâmpada nova;
4. Suba na escada;
5. Retire a lâmpada velha;
6. Coloque a lâmpada nova
Atenção: Esta solução é apenas uma das muitas soluções possíveis para o
problema apresentado. Assim, ao criarmos um algoritmo, indicamos uma
dentre várias possíveis sequências de passos para solucionar o problema.
Por exemplo, o problema acima poderia ser resolvido mesmo se alterássemos a sequência de
passos para:
1. Pegue uma lâmpada nova;
2. Pegue uma escada;
3. Posicione a escada embaixo da lâmpada;
4. Suba na escada;
5. Retire a lâmpada velha;
6. Coloque a lâmpada nova.
Entretanto, como vimos no capitulo anterior, quando se trata de algoritmos para computadores
precisamos transformar a sequência de passos que escrevemos em linguagem natural para uma
linguagem que possa ser “entendida” pelo computador.
Atividade 3 – Escreva um algoritmo (sequência de passos) para trocar um

pneu de um carro.
Atividade 4 – Descreva um algoritmo que defina como fritar um ovo.

Controle do Fluxo de Execução
De acordo com o modo como este controle é feito, as estruturas básicas de controle do fluxo
de instruções de um algoritmo, são classificadas em: Estruturas Seqüenciais, Estruturas de Decisão e
Estruturas de Repetição.
Fluxo Sequencial
Um fluxo sequencial de execução é caracterizado por conjunto de um ou mais comandos

simples, como instruções primitivas, que são executados numa seqüência pré- estabelecida, onde
cada comando é executado somente após o término do comando anterior. A figura 5 apresenta um
fluxograma de execução de comandos sequenciais basatante simples.
Figura 5 – Exemplo de fluxo sequencial de execução.
Atenção: Observe que o formato dos objetos está relacionado a sua

finalidade. Há uma forma própria para início e fim, operações, leitura
(entrada) e impressão (saída).
Entrada e Saída de Dados em C/C++ e Python
Comandos para entrada de dados:

Frequentemente, na construção de algoritmos, precisamos solicitar que usuários informem,
por meio do teclado, alguns valores a serem utilizados durante a execução. Por exemplo: se fizermos
um algoritmo para calcular a média das notas de um aluno, precisaremos solicitar quais foram as

notas, para depois calcularmos a média. Esses valores informados devem ser armazenados em variáveis
para que sejam utilizados quando neces- sário. Em C/C++ precisamos de uma biblioteca para isso,
por exmemplo a «stdio.h>”.
O comando de entrada de dados será responsável pela leitura e armazenamento desses dados
na variável que indicarmos. A sintaxe do comando de entrada de dados:
modelo em C/C++: modelo em Python:

scanf(“string”,&variavel); variavel = typecast(input(“string”))
Exemplo: Exemplo:
int numero; numero = int(input(“Digite um número: “))
scanf(“%d”,&numero);
o typecast no modelo em python é utilizado para transformar o string lido pela função input
para o tipo que se deseja por na variável. No exemplo, o input lê caracteres que são transformados em
um número inteiro (int) para ser armazenado na variável numero.
Comandos para saída de dados:

Apresentar resultados de um processamento ou de um algoritmo para o usuário, também
é uma necessidade. Existem diversos comando para executar esta tarefa tanto em C/C++ quanto
em Python. A sintaxe abaixo é uma das formas mais versáteis de apresentar resultados, pois é
possível formatá-los como assim desejarmos.
no exemplo a seguir iremos imprimir valores reais na tela com a formatação de 6 (seis) caracteres
sendo 2 (dois) depois do ponto decimal. para isto usaremos uma sequência especial de caracteres:
em C/C++ “%6.2f” - onde o % indica que naquele ponto entrará o valor de uma variável e o
f indica que a variável é do tipo float.
em Python “{:6.2f}” - onde o que está dentro das chaves será utilizado pela função format()
para formatar a variável passada como parâmetro.

printf(“string”, variável) print([“string”,] variável)
Exemplo: Exemplo:
float numero = 4/3; numero = 4.3
printf(“o número é: %6.2f”,numero); print(“o número é :{:6.2f }”.format(numero))
Saída Saída
o número é: 1.33 o número é : 1.33

Saiba Mais: Existem outros comando para entrada e saída de dados, como
os presentes na biblioteca <iostream> do C++. Você pode encontram
mais informações no seguinte link: https://www.learncpp.com/cpp-
tutorial/introduction-to-iostream-cout-cin-and-end
Tabelas de formatacão de saída

As tabelas das figuras 6 e 7 podem ser utilizadas para formatar a saída de dados na tela ou
impressora.
Figura 6 – Tabela de formatos utilizadas em C/C++ e Python
Figura 7 – tabela de caracteres de controle de cursor em C/C++ e Python

Atividade 5: Faça um programa em C++ ou Python que leia a partir do
teclado três dados de ums pessoa: código de identificação, idade e a renda
familiar. O programa deve imprimir na primeira linha, e identificando cada
campo, o valor do código e em outra linha a idade e a renda com dois digitos
após o ponto decimal.
Atividade 6: Faça um programa que leia dois valores reais e calcule a soma
dos numeros e também a sua diferença. O programa deve imprimir as
operações uma ao lado da outra, como no exemplo
17.84 17.84
+ 6.56 − 6.56
______ _______
24.40 11.28
Operadores Lógicos, Relacionais e Aritméticos
Operadores Aritméticos
As linguagens de programação podem lidar diretamente com algumas operações matemática,
enquanto para outras será necessário o uso de bibliotecas próprias onde foram construídas funções
matemáticas mais complexas. Entre uma linguagem e outra pode haver alguma diferença sobre
quais operações são nativas e quais não são. a figura 8 mostra a Tabela com os operadores
aritméticos que podem ser utilizados diretamene em C/C++ e Python.
Figura 8 – tabela de operadores aritméticos em C/C++ e Python

Em C/C++, tanto a potenciação quanto a raiz quadrada só são possiveis de serem realizadas
utilizando uma biblioteca chamada “math.h”. Para Python a potenciação pode ser feita diretamente,
enquanto que a função raiz quadrada também será encontrada na biblioteca “math”. Vejamos como
fica a sintaxe para utilizar as bibliotecas tanto em C/C++, quanto em Python.

#include <biblioteca> import biblioteca
#include “biblioteca”
Exemplo:
Exemplo: import math
include <math.h> print(“A raiz de 64 é: “, math.sqrt(64))
printf(“A raiz de 64 é: %d”, sqrt(64)); Saída
Saída A raiz de 64 é: 8.0
A raiz de 64 é: 8
Operadores Relacionais
Operadores relacionais são utilizados para comparar valores, o resultado de uma expressão
relacional é um valor booleano (VERDADEIRO ou FALSO). Não é necessário explicar cada um, pois
eles são auto-explicativos. Mas para quem é iniciante em desenvolvimento de softwares algumas
informações podem ser importantes, principalmente pelo fato de haver diferença nos operadores entre
as linguagens de programação. No caso de C++ e Python não há diferenças, observe na figura 9 a
tabela de operadores relacionais usados nestas linguagens:
Figura 9 – tabela de operadores relacionais em C/C++ e Python

Operadores Lógicos
Todos os operadores relacionais vistos até agora consideraram uma operação de teste simples.
Como por exemplo: b != 0, contador <= 5, numero == 5. Estas expressões testam uma condição.
Portanto, quando mais de uma condição precisa ser testada, precisamos usar sentenças um pouco
mais complexas.
Normalmente, as linguagens de programação suportam operadores lógicos, que podem ser
usados para criar operações lógicas mais complexas, combinando várias condições simples. O resultado
de uma expressão lógica, assim como as relacionais, é sempre VERDADEIRO ou FALSO.
Atenção: Lembre que em C/C++, diferente do Python, não há constantes

lógicas VERDADEIRO e FALSO, ou seja, em C/C++ as expressões lógicas
resultam em 0, que é interpretado como FALSO, ou qualquer valor diferente de
zero, que é interpretado como VERDADEIRO.
A figura 10 apresenta uma tabela com os operadores lógicos utilizados em C/C++ e Python:
Figura 10 – tabela de operadores lógicos em C/C++ e Python
Os operadores relacionais e lógicos são muito utilizados em programação, as decisões dos

algoritmos geralmente são tomadas nas operações lógicas e relacionais, ou seja, as decisões baseiam-
se em testes do estado das variáveis. Então é muito importante entender o que são operações lógicas e
relacionais e quais os operadores utilizados nesse tipo de expressão.

Atividade 7: Faça um programa que leia três números inteiros (A,B,C) e
imprima o resultado das quatro comparações a seguir: 1) A é maior que B; 2) A
é menor ou igual a C; 3) A é igual a B e A é maior que C; 4) A é menor ou igual a
B ou A é maior ou igual a C.
Fluxo de Execução com Estruturas de Decisão
Os algoritmos que construímos até agora apresentam uma sequência de passos que devem ser
seguidos para atingir um objetivo bem definido. Note que todos os passos dos algoritmos devem ser
executados a fim de que o objetivo seja alcançado.
Porém, há algoritmos nos quais a execução de alguns passos pode depender de decisões
a serem tomadas. Dessa forma, algum fato indicará se um ou mais passos do algoritmo serão
executados ou não.
Por exemplo, o nosso primeiro algoritmo define uma sequência de passos para
trocar uma lâmpada. Em momento algum perguntamos se a lâmpada está queimada.
Simplesmente trocamos a lâmpada sem fazer qualquer teste. Para resolver esse problema,
podemos acrescentar ao nosso algoritmo um teste que verifique se a lâmpada deve ser
trocada:
1. Ligue o interruptor
2. Se a lâmpada não acender:
2.1. Pegue uma escada;
2.2. Posicione a escada embaixo da lâmpada;
2.3. Pegue uma lâmpada nova;
2.4. Suba na escada;
2.5. Retire a lâmpada velha;
2.6. Coloque a lâmpada nova.
Testes: Determinam quais ações serão executadas; são chamados de estruturas

de seleção ou estruturas de decisão.

Agora, estamos ligando os passos de efetuar a troca da lâmpada a uma condição. Assim, só
executamos os passos definidos de 2.1 a 2.6 caso a condição definida do passo 2 seja verdadeira, ou
seja, caso a lâmpada não acenda.
Na maioria das linguagens de programação podemos utilizar duas estruturas de seleção: as de
seleção simples e as de seleção múltipla.
Estrutura de Seleção Simples
Como vimos anteriormente, muitas vezes precisamos tomar decisões que podem interferir
diretamente no andamento do algoritmo. A representação dessas decisões em nossos programas
é feita através do uso de estruturas de seleção, ou estruturas de decisão. Uma estrutura de seleção
simples pode ser descrita em português da seguinte forma:
SE... ENTÃO... SENÃO ... FIM do SE.
A palavra reservada SE indica o início da estrutura de seleção. Após essa palavra, vem a condição
que definirá o bloco a ser executado. Qualquer expressão lógica poderá ser utilizada como condição,
pois deverá retornar verdadeiro ou falso. Caso a expressão da condição seja verdadeira, o bloco de
instruções ENTÃO será executado. Caso contrário, o bloco SENÃO o será. A palavra reservada FIM do
SE indica o final da estrutura de seleção.
Vale ressaltar que o bloco SENÃO não é obrigatório: caso só queiramos executar algumas
instruções se a expressão lógica for verdadeira, podemos omitir o bloco SENÃO.
A figura 11 mostra um fluxo de execução utilizando uma estrutura de seleção simples:
Figura 11 – Fluxo com Estrutura de Seleção Simples

A sintaxe dessa estrutura em C/C++ e Python é iniciada pelo palavra reservada if (SE em inglês),
e deve ser utilizado quando a execução de uma ou mais instruções do programa depender de uma
ou mais condições. veja o exemplo:
Sintaxe em C/C++ Sintaxe em Python

if (condição) { if condição:
instruções se verdadeiro;} instruções se verdadeiro
else{ else:
instruções se falso;} instruções se falso
Exemplo: Exemplo:
if (A > B) { if A > B :
//instruçoes se verdadeiro #instruções se verdadeiro
printf(“A é maior que B”);} print(“A é maior que B”)
else{ else :
//instruções se falso #instruções se falso
printf(“B é maior ou igual a A”); } printf(“B é maior ou igual a A”)
Atividade 8: Desenvolva um programa que leia a matrícula e a nota final de

um aluno de uma escola. Se a nota final for maior ou igual a 60, o programa
deve exibir a mensagem “Aluno aprovado”.
Atividade 9: Como complemento a atividade 8, o programa deverá exibir

também a mensagem “Aluno reprovado”, caso a nota final do aluno seja
menor que 60.
Atividade 10: Construa um programa que leia um número inteiro e imprima a

informação se este número é ou não divisível por 5. Dica: Utilize o operador
Atividade 11: Faça um programa que leia três valores distintos a serem
digitados pelo usuário, determine e exiba o menor deles. Dica: aqui voce
precisará utilizar estruturas de decisão dentro de estruturas de decisão.

Estrutura de Seleção Múltipla
Algumas linguagens de programação possuem estruturas de seleção múltipla. Este tipo de

estrutura permite que o programador avalie uma expressão cujo resultado tenha mais que duas
alternativas. Vejamos a seguinte situação.
Imagine que ao usar um programa o usuário tenha que escolher entre várias opções para informar
um tipo de operação matemática desejada (soma, subtração, divisão ou multiplicação).
A figura 12 apresenta um fluxo de execução para esta situação:
Figura 12 – Exemplo de fluxo de execução de seleção multipla.
No fluxograma utilizamos uma serie de estrutura de decisão simples aninhadas, uma após a
outra. Podemos fazer o mesmo para as linguagens formais C++ e Python. Em C++ basta usarmos
outro if dentro da cláusula else do if anterior. Porém em python, para encadear vários if’s utilizamos
a cláusula elif , enquanto a cláusula else é usada apenas na última decisão ou na estrutura de seleção
simples. Vejamos como fica a sintaxe para o exemplo do fluxograma:

if (OP == ’+’) { if OP == ’+’ :
printf(“%f”, A + B);} print(A + B)
else if (OP == ’-’) { elif OP == ’-’ :
printf(“%f”, A - B);} print(A - B)
else if (OP == ’x’) { elif OP == ’x’ :
printf(“%f”, A * B);} print(A * B)
else if (OP == ’/’) { elif OP == ’/’ :
printf(“%f”, A / B);} print(A / B)
else { else :
printf(“OP inválida”);} print(“OP inválida”)

Em C++, assim como o comando if , o comando switch é uma estrutura de decisão. Este
comando é utilizado em substituição ao encadamento de ifs, ou seja, quando o programa tiver
que escolher uma entre várias alternativas para uma determinada expressão ou variável. Em python não
existe um comando semelhante ao switch, mas é possível implementar um código para este fim.
Vejamos a sintaxe do switch em C++:
Sintaxe em C/C++
switch (OP) {
case ’+’:
printf(“%f”, A + B); break;
case ’-’:
printf(“%f”, A - B); break;
case ’x’:
printf(“%f”, A * B); break;
case ’/’:
printf(“%f”, A / B); break;
default:
printf(“OP inválida”); }
Observe que utilizamos a cláusula case é utilizada para identificar o caso em que a expressão
ou a variável se encaixa. A cláusula break evita que, uma vez escolhido um caso, outros casos sejam
testados. A cláusula default é executada caso nenhum dos casos anteriores seja selecionado.
Atividade 12: Desenvolva um programa que leia a matrícula e a nota final

de um aluno. O programa deve imprimir o conceito correspondente nota
do aluno. Exemplos: notas entre 0 e 49 insuficiente, entre 50 e 69 regular,
entre 70 e 89 bom e de 90 acima ótimo.
Atividade 13: Faça um programa que leia dois números reais e apresente
um menu para que o usuário escolha uma das seguintes operações aritméticas
(soma, subtração, divisão e multiplicação) . O programa deve apresentar o
resultado da operação.
Atividade 14: Faça um programa que leia a idade do usuário e imprima se o

usuário é “Criança”(de 0 a 12 anos), “Adolescente”(de 12 a 18 anos), “Jovem”(de
18 a 30 anos) “Maduro”(de 30 a 65 anos) e “Idoso”(acima de 65 anos).

Fluxo de Execução com Estrutura de Repetição
Note que, apesar de nosso algoritmo sobre a lâmpada estar verificando a necessidade de trocar
a lâmpada antes de fazê-lo, em momento algum verificamos se a lâmpada nova que foi instalada
funciona. Assim, vamos tentar alterar o nosso algoritmo a fim de garantir que ao fim de sua execução
tenhamos uma lâmpada funcionando. Para isso, vamos incluir um novo teste em seu final:
1. Ligue o interruptor
2.6. Coloque a lâmpada nova;
2.7. Se a lâmpada não acender:
2.7.1. Retire a lâmpada;
2.7.2. Coloque uma outra lâmpada;
2.7.3. Se a lâmpada ainda não acender:
2.7.3.1. Retire a lâmpada;
2.7.3.2. Coloque uma outra lâmpada;
Até quando ficaremos fazendo esses testes?
Pelo nosso novo algoritmo, caso a nova lâmpada não acenda, devemos trocá-la novamente e
repetir esse procedimento indefinidamente até que uma lâmpada funcione. Note que não sabemos
quantas vezes teremos de repetir o teste até acharmos uma lâmpada que funcione.
Em casos como esse, devemos utilizar estruturas de repetição. Essas estruturas definem
um fluxo de ações que se repete enquanto uma determinada situação acontece. Dessa forma,
substituímos nossa sequência indefinida de estruturas de decisão por uma estrutura de repetição:
1. Ligue o interruptor;

2.6. Coloque a lâmpada nova.
2.7. Enquanto a lâmpada não acender:
2.7.1. Retire a lâmpada;
2.7.2. Coloque uma outra lâmpada.
Assim, neste novo algoritmo, enquanto a condição definida na linha 2.7 for verdadeira (ou seja,
enquanto a lâmpada não acender), as ações definidas em 2.7.1 e 2.7.2 serão repetidas. Abstraímos os
fatos de ter de descer da escada para pegar uma lâmpada nova e subir novamente.
Conforme vimos na seção anterior, são comuns as situações nas quais precisamos repetir
determinadas ações enquanto não atingimos um objetivo. Da mesma forma, ao desenvolver nossos
algoritmos, deparamos com situações nas quais precisamos repetir um conjunto de instruções até
que uma determinada condição ocorra. Nessas situações, utilizaremos os comandos de repetição,
também conhecidos como laços ou loops.
Laços: As estruturas de repetição ou laços são técnicas de programação

que permitem que um bloco de instruções seja executado várias vezes até
que uma determinada condição seja satisfeita. Assim essas estruturas
são compostas por uma condição e um conjunto de instruções a serem
executados enquanto a condição não for satisfeita.
Estruturas de Repetição
As atividades 8 e 12 propõem a construção de um programa que lê a matrícula e a nota final de

um aluno e apresente sua situação ou seu conceito. Caso seja necessário apresentar resultados para
dois alunos utilizando apenas as estruturas que já estudamos, teríamos de praticamente escrever todo o
algoritmo novamente. É em situações assim que as estruturas de repetição são úteis. Com elas, um bloco
de instruções do seu algoritmo pode ser repetido diversas vezes sem ter de duplicar o código.
A figura 13 apresenta duas maneiras de implementar um laço. Na estrutura da esquerda o
teste de condicional é realizado antes da execução do bloco de comandos da repetição, portanto
pode ser que os comandos não sejam executados. Já a segunda estrutura garante que os comando
da repetição sejam executados pelo menos uma vez, isto porque o teste é realizado após o bloco de
comandos da repetição.

Figura 13 – Exemplo de fluxo de execução com estrutura de repetição.
Tanto em C++ quanto em Python, a palavra chave correspondente ao laço da esquerda é

textbfwhile. Segue a sintaxe utilizada para esta estrutura nestas linguagens.

while (condição) while condição :
{ bloco de comandos que irão se repetir
bloco de comandos a repetir;
} Exemplo
cont = 0
Exemplo while cont <= 10 :
int cont = 0; print(cont)
while (cont <= 10) { cont +=1
printf(“%d”, cont); / serão impressos os valores de 1 a 10
valor++; } else :
/* serão impressos os valores de 1 a 10 */ print(’comandos após o laço’)
Revisando o funcionamento deste laço:

1 - Testa a condição;
2 - Se a condição for falsa então pula todos os comandos do bloco subordinado
ao while e passa a executar os comandos após o bloco do while.
3 - Se condição for verdadeira então executa cada um dos comandos do bloco
subordinado ao while.
4 - Após executar o último comando do bloco do while volta ao passo 1.

Atenção: O comando while deve ser usado sempre que:
não soubermos exatamente quantas vezes o laço deve ser repetido;
o teste deva ser feito antes de iniciar a execução de um bloco de comandos;
houver casos em que o laço não deva ser repetido nenhuma vez.
O segundo tipo de laço utiliza as palavras chaves do e while. Este tipo de laço não existe em
Python, entretanto, observe que no exemplo em Python do laço anterio é possivel utilizar a cláusula
else para especificar comandos para serem executados quando a condição não for satisfeita. Isto pode
ser usado para simular o tipo de laço da direita na figura 13. A sintaxe em C++ para o laço da direita
é apresentado a seguir:
Sintaxe em C/C++
do
{
bloco de comandos a repetir;
}
while (condição);
Exemplo
int cont = 0;
do {
printf(“%d”, cont);
valor++; }
} while (cont <=10);

1 - Executa os comando dentro do bloco do-while;
3 - Se a condição for falsa então executa o comando que está logo após
o bloco subordinado ao do-while .
4 - Se condição for verdadeira então volta ao passo 1.

Atenção: O comando do deve ser usado sempre que:
não soubermos exatamente quantas vezes o laço deve ser repetido;
o teste deva ser feito depois da execução de um bloco de comandos;
o bloco de comandos deva ser executado pelo menos uma vez.
Estrutura para número de Repetições conhecidas
Há situações onde é possível determinar o quantidade de repetições necessária para

alcançar o resultado final. A figura 14 apresenta uma das maneiras de implementar um laço
com quantidade de iterações conhecida.
Figura 14 – Exemplo de fluxo de execução com estrutura de repetição com contagem conhecida.
Por exemplo, se o número de alunos da turma for conhecido, a estrutura de repetição recomendada,
tanto em C++ quanto em Python, é o laço for. Vejamos como fica a sintaxe desta estrutura:
Sintaxe em C/C++
for (cont = valor inicial; cont <= valor final; cont = cont + passo) {
bloco de comandos que irão se repetir;}
Exemplo
for (cont = 1; cont <= 10; cont = cont +1) {
printf(“%d”, contador; }
/* serão impressos os valores de 1 a 10 */

Sintaxe em Python
for contador in range(valor inical, valor limite, passo) :
bloco de comandos que irão se repetir
Exemplo
for contador in range(1,11,1) :
print(contador) # serão impressos os valores de 1 a 10.
else :
print(’comandos após o laço’)

1 - Executa os comandos de inicialização;
3 - Se a condição for falsa então executa o comando que está logo após
o bloco subordinado ao for.
4 - Se condição for verdadeira então executa os comandos que estão
subordinados ao for;
5 - Executa os comandos de incremento/decremento;
6 - Volta ao passo 2.
Atenção: O comando do deve ser usado sempre que:

soubermos exatamente quantas vezes o laço deve ser repetido;
o teste deva ser feito antes da execução de um bloco de comandos;
houver casos em que o laço não deva ser repetido nenhuma vez.
Existem outras maneiras de construir um laço for em python. Além disso, sempre que
necessário, voce poderá construir um laço dentro de outro laço. Quando o conteúdo sobre listas for
apresentado, você aprenderá a construir algumas destas estruturas.

Comandos de Desvio
Os laços vistos nas linguagens C++ e Python possuem dois comandos de desvios: break e
continue. Estes comandos funcionam com todos os comandos de repetição. O comando break
encerra o laço no ponto em que for executado. Já o comando continue desvia o fluxo para o início
do laço.
Nestes exemplos de utilização do comando break, caso o usuário digite um número negativo o
laço termina antes do contador chegar a 10.
Comamdo break em C++ break em Python

for (c = 1; c <= 10; c++) { for cont in range(1,11,1) :
printf(“Digite um Número :”) numero = int(input(’Número: ’))
scanf(“%d”, numero); if numero < 0 :
if (numero < 0) { break
break; } print(cont)
printf(“%d”, c); else :
} print(’após o laço’
Nestes exemplos de utilização do comando continue, mesmo contando de 1 a 10 o programa

imprimirá somente os números impares, pois o comando continue força um novo incremento do
contador sem execuar o restante do laço.
Comamdo continue em C++ continue em Python

for (c = 1; c <= 10; c++) { for cont in range(1,11,1) :
printf(“Digite um Número :”) numero = int(input(’Número: ’)) i
scanf(“%d”, numero); f numero < 0 :
if ((numero % 2) == 0) { continue
continue; } print(cont)
printf(“%d”, c); else :
} print(’após o laço’)

Atividade 15: Construa um programa capaz de ler uma série de números
até que apareça um número entre 1 e 5. Ao final, exiba a quantidade de
números digitados, o valor da soma e a média dos valores dos números
digitados.
Atividade 16: Faça um programa que leia a matrícula e a nota final dos 20
alunos de uma turma. O programa deve imprimir a matricula e a condição de
cada aluno (Aprovado ou Reprovado). Alunos com nota abaixo de 60 será
reprovado.
Atividade 17: Desenvolva um programa que leia a matrícula, a nota e

número de faltas dos 10 alunos de uma turma. O programa deve imprimir
a matricula e a condição de cada aluno (Aprovado ou Reprovado). O aluno
estará reprovado caso tenha mais de 16 faltas. Também será reprovado se a
nota for menor que 60.
Atividade 18: Desenvolva um programa que leia a matrícula e as cinco

notas dos 10 alunos de uma turma. O programa deve imprimir a matricula
e a condição de cada aluno (Aprovado ou Reprovado). O aluno estará
reprovado se a média das cinco notas for menor que 60.

Modularizacão e
Funções
Objetivos
Conceituar funções ou subprograms

Utilizar funções ou subprogramas na construção de algoritmos
Funções
As funções ou subprogramas são um conjunto de comandos que são agrupados e recebem

assim um nome específico que para identificá-los. Desta forma, podemos usar as funções para realizar
tarefas que se repetem várias vezes e em pontos diferentes na execução de um mesmo programa. O
uso de funções permite que possamos criar PROGRAMAS MODULARES, deixando estes mais bem
estruturados.
O uso de funções nos leva ao desenvolvimento de programas com uma abordagem em que
podemos dividir um grande problema em problemas menores, e assim, resolvê-lo mais facilmente.
Em C++ ou Python, nós muitas vezes usamos funções sem sequer perceber que estamos
fazendo uso deste tipo de recurso das linguagens. Por exemplo, o scanf e o printf em C++ e o input
e o print em Python são exemplos de algumas funções pré-definidas ou construídas em bibliotecas
destas linguagens.
Funções: Funções são blocos de código com um nome e podem possuir ou

não argumentos como interface entre o seu exterior e o seu interior.
Construindo Funções
Para utilizarmos uma função, ela precisa ser previamente construída, além disso, uma função
pode ou não retornar valores para o ponto do programa onde foi chamada. Por exemplo, as funções
scanf e input retornam valores, enquanto as funções printf e print, apesar de imprimirem na tela ou
Capítulo 4. Modularizacão e Funções 58 ••••

na impressora, estas não retornam valores para serem utilizados pelo programa depois que elas são
executadas.
A seguir são apresentados exemplos da construção de uma função cujo o nome é “media”,
tanto em C++ quanto em Python, para calcular a médias de três notas de um aluno. No primeiro caso
o valor é retornado ao programa que chamou a função no ponto de chamada. No segundo caso a
função não retorna o valor da média, apenas o imprime na tela.
Sintaxe em C++ Sintaxe em Python
Exemplo 1: Exemplo 1:
float media(float n1, float n2, float n3) { def media(n1, n2, n3):
return (n1 + n2 + n3)/3; } return (n1 + n2 + n3)/3
chamando a função: chamando a função:

nota = media(60.0, 72.5, 49.5); nota = media(60.0, 72.5, 49.5)
printf(“%5.2f”, media); print(media)
Exemplo 2: Exemplo 2:
void media(float n1, float n2, float n3) { def media(n1, n2, n3):
printf(“%5.2f”, (n1 + n2 + n3)/3); } print((n1 + n2 + n3)/3)
chamando a função: chamando a função:

media(60.0, 72.5, 49.5); media(60.0, 72.5, 49.5)
Passagem de Parâmetros
Normalmente os parâmetros ou argumentos passados para uma função são valores que poderão
ou não ser atribuidos a variáveis internas da função (variáveis locais). Entre- tanto, há situações em que
é necessário passar os argumentos por referência. Por exemplo, na função scanf em C++, os argumentos
que se seguem ao primeiro, são sempre passados por referência, isto é, na verdade o que a função
recebe não é o valor, e sim o endereço da variável. Além disso, há certos tipos de dados que só
conseguimos passar por referência, como por exemplo, uma cadeia de caracteres (string).
Em C++, qualquer tipo de dado pode ser passado por referência. Porém, para o Python,

certos valores que têm semântica por valor não podem ser passados diretamente por referência já
que a linguagem não provê sintaxe para isto.
O exemplo mostra como construir uma função que receba argumentos por referência. Neste
exemplo a função recebe dois argumentos do tipo inteiro, o primeiro por valor e o segundo por
referência:
Sintaxe em C+
void acumula (int numero, int *acumulador) {

acumulador = *acumulador + numero; }
chamando a função:
int cont, soma = 0;
for (cont=1; cont<=3; cont++ {
acumula(cont, &soma); }
Observe que a variável cont é passada para a função como valor, ou seja, o valor dela é que
será enviado para a função acumula. Já a variável soma é passada por referência, ou seja, o endereço
dela é que será enviado para a função acumula (devido ao uso do “*” na construção da função e
do “&” na passagem do parâmetro). Assim, quando o laço for terminar, a variável soma terá o valor
6 (seis), pois quando a passagem ocorre por referência, qualquer alteração da variável dentro da
função implica em alteração fora da função, pois o endereço de memória correspondente aos dois
nomes de variável, soma e *acumulador, é o mesmo.
Atividade 1: Construa um programa em C++ que leia 2 notas de 10 alunos

e apresente a média dos alunos. Façauma função que calcule média de dois
números e utilize esta função no programa.
Atividade 2: Construa um programa em C++ que números inteiro, e para

cada inteiro lido apresente seus divisores. Faça uma função que calcule os
divisores de um número inteiro e utilize esta função no programa.

Atividade 3: Construa um programa que leia dois valores e armazene nas
variáveis numA e numB. Faça uma função que seja capaz de trocar o
conteúdo de duas variáveis (use passagem por referência). Dica: Use variável
a auxiliar numAux. Exemplo: numA vai para numAux, numB vai para numA e
nunAux vai para numB. Se não utilizar nuAux, ao por numB em numA o valor
de numA se perderá). Utilize esta função, sempre que necessário, para que
ao terminar o programa o valor maior esteja armazenado em numA e o outro
valor em numB.
Atividade 4: Escreva, teste em um programa e identifique o que faz a

seguinte função: int fat(int n) { if (n<=1) return 1 else return n*fat(n-1); }
Módulos em Python
Um módulo é simplesmente um arquivo contendo códigos Python que podem ser explorados
por outros programas. Um módulo completo pode ser chamado por outros programas através da
declaração import (importar).
Atenção: só é possível importar módulos para um programa se eles estiverem

dentro do mesmo diretório, ou em algum diretório contido na lista de diretórios
da variável de ambiente PATH.
Como exemplo, o código do programa salvo como o nome area.py contém as funções
retangulo, triangulo e circulo construídas para calcular as áreas destas figuras geométricas. Este
código é mostrado a seguir:

Sintaxe em Python:
”””Programa que calcula a área de um retângulo, círculo ou triângulo”””

def retangulo(lado_a, lado_b):
”””Calcula a área de um retângulo”””
area = lado_a * lado_b
return area
def triangulo(lado, altura):
”””Calcula a área de um triângulo”””
area = (lado * altura) / 2
return area
def circulo(raio):
”””Calcula a área de um círculo”””
area = 3.14 * (raio ** 2)
return area
Uma vez salvo, o programa estará pronto para servir como um módulo. Se quisermos usar suas
funções dentro de outro programa ou mesmo no interpretador Python devemos usar a declaração
import para importar area.py como um módulo. Agora para usar o módulo primeiro é preciso digitar
o nome do módulo, colocar um ponto e digitar o nome da função que queremos usar e por fim
passar os argumentos necessários à função. Veja o exemplo abaixo:
includegraphics[height=1.5 cm]Exemplo.pdfSintaxe em Python:

”””Programa que irá imporar o módulo area.py”””
import area
”””Calculando a área de um retângulo 2 x 5”””
area.retangulo(2, 5) # o resultado será 10
”””Calculando a área de um triângulo de base 3 e altura 4”””
area.triangulo(3, 4) # o resultado será 6
”””Calculando a área de um círculo de raio 2”””
area.circulo(2) # o resultado será aproximadamente 12.56

Importando parte de um Módulo
Módulos podem ser muito grandes e sua importação completa pode gerar desperdício de memoria
se só vamos fazer uso de uma pequena parte do módulo. Assim é possível importar somente partes de
um módulo. No caso do módulo area.py podemos importar, por exemplo, somente a função circulo.
Veja a seguir:
Sintaxe em Python:
from nome_do_módulo import nome_da_função as apelido
Exemplo:
”””Programa para calcular o volume de um cilindro””’
from area import circulo as area_circulo
r = float(input(’Entre com o raio do cilindro: ’))
h = float(input(’Entre com a altura do cilindro: ’))
volume = area_circulo(r) * h
print(’O volume do cilindro é:’, volume)
Atenção: a cláusula as permite que usemos um apelido para a função a ser

importada. Isto evita conflito quando dois ou mais módulos tiverem funções com
o mesmo nome. Por exemplo, imagine se tivessemos um outro módulo chamado
perimetro.py, que calculasse o perímetro das mesmas figuras geométricas, e
para isso utilizasse os mesmos nomes em suas funções (“circulo”para calcular
o perímetro do círculo e assim por diante).
Atividade 5: Construa um módulo em python que calcule as raízes de funções

de primeiro e segundo graus. No caso de segundo grau, caso o determinante
seja negativo, deve ser impresso “Não há raízes reais”.

Atividade 6: Construa um módulo em python para determinar os divisores
e os 3 primeiros múltiplos de um número inteiro, e também para verificar se o
número tem raiz quadrada inteira.
Bibliotecas e Cabeçalhos em C/C++
Uma das tarefas menos compreendidas na programação C/C++ é a criação de bibliotecas

e arquivos de cabeçalho (ou headers .h). Portanto, nesta seção iremos ver as principais regras para
criação de bibliotecas e arquivos de cabeçalho, passo-a-passo, a partir de programas que já estejam
funcionando. O objetivo é facilitar para programadores iniciantes, pois é mais fácil fazer correções antes
de partir para separar o código em arquivos.
Primeiro vamos partir de um programa único, pronto, entender como ele funciona. Depois
iremos separá-lo em quatro partes fundamentais: includes, declarações, o programa principal
(main() e definições. A figura 15:
Figura 15 – Programa em C++.

Criando o Arquivo Cabeçalho
As primeiras regras de criação de arquivos de cabeçalho são as seguintes:

Regra 1. deve conter apenas as declarações que serão visíveis ao programa.
Regra 2. deve conter apenas as diretivas include necessárias para suas declarações. Vamos criar
um arquivo chamado troca.h (o ideal é que o nome seja todo em minúsculo, a nomenclatura será
importante em Criando bibliotecas em C++). Após a
aplicação da primeira e da segunda regras, teremos o seguinte resultado: void troca_int( int
*valor1, int *valor2);
void troca_float( float *valor1, float *valor2);
Note que apenas as duas declarações serão copiadas para o nosso arquivo de cabeçalho. Não
é necessária a inclusão de nenhuma diretiva include.
O cabeçalho já funciona assim, mas ainda pode nos causar problemas. Imagine que você
inclua troca.h em dois outros arquivos cabeçalho diferentes: cab1.h e cab2.h. Se por algum motivo
estes dois cabeçalhos forem incluidos em um programa, teremos o mesmo problema de declarações
duplicadas discutido na seção anterior. Para contornar esta situação faremos um teste para verificar se
esta declaração já foi feita ou não. Por isso vem a próxima regra:
Regra 3. proteja-o de declarações duplicadas usando uma guarda de cabeçalho.
Figura 16 – Teste de guarda cabeçalho.
Regra 4. nomeie corretamente o símbolo de seu arquivo de cabeçalho.

Existem algumas regras que devem ser seguidas na nomenclatura do símbolo correspondente
ao arquivo de cabeçalho. Primeiro, o nome não deve ser curto, pois deverá ser exclusivo no contexto
global. Usar maiúsculas é uma questão decestilo, mas melhora significativamente a leitura. Alguns
identificadores são reservados na definição do C, e devem ser evitados:
– usar dois underlines consecutivos (por exemplo);
– começar com sublinhado seguido por letra maiúscula (_TROCA_HEADER_).
Esta situação é reservada pela definição da linguagem;
– começar com um sublinhado no contexto global (_troca_header_), também é
reservado, pois está no contexto global.

Contexto Global: Tudo que é declarado no espaço exterior a qualquer
função, variáveis, constantes ou outras funções, é considerado global e
pode ser visto e utilizado por qualquer função.
Contexto local: São variáveis, constantes ou funções declaradas dentro do

espaço interior a uma função. Neste caso, só pode ser visto ou utilozado
dentro a respectiva função.
Criando o Arquivo .cpp
Para criarmos o arquivo .cpp. Crie um novo arquivo, troca.cpp, com as definições das funções
que declaramos em troca.h (perceba que os dois arquivos devem ter o mesmo nome, só muda a
extensão).
As primeiras regras para a criação do arquivo C++ são:
Regra 1. deve conter apenas as definições, que não serão visíveis ao programa.
Regra 2. deve conter apenas as diretivas #include necessárias para suas definições.
Neste exemplo, basta copiar a parte das definições, exatamente como está no original.
Dessa vez não é preciso se preocupar com guarda de cabeçalho. As definições em C++ funcionam
de maneira diferente dos arquivos de cabeçalho.
Figura 17 – Teste de guarda cabeçalho.
Regra 3. Nunca declare um inline dentro de um arquivo .cpp, toda função inline deve ter
sua definição conhecida antes de ser usada e apenas o arquivo de cabeçalho é conhecido até este
momento.

Criando o arquivo biblioteca
Uma vez criados os arquivos (troca.h e troca.cpp), para podermos utilizar as funções troca em
qualquer outro program C++, teremos que criar uma biblioteca. Existem dois tipos de bibliotecas:
bibliotecas estáticas (static library) e dinâmicas (dynamic library) . Bibliotecas estáticas são vinculadas
ao programa resultante, de modo que cada programa que usa essa biblioteca obterá sua própria
cópia do código da biblioteca.
Uma maneira mais eficiente economizar memória é usar bibliotecas compartilhadas (em janelas
chamadas DLL), que são carregadas sob demanda de um local específico para cada plataforma, mas
a vantagem é que apenas uma instância do código da biblioteca precisa ser carregada para memória
quando diferentes programas que usam a biblioteca estão sendo executados simultaneamente e o
código binário resultante desses programas não contém o código da biblioteca. ele reside em um
arquivo separado que precisa ser enviado junto com o aplicativo e instalado em um local apropriado.
biblioteca compartilhada (dll):

g++ -shared -o troca.so troca.cpp
g++ -o main main.cpp -L. -troca
o primeiro comando irá compilar troca.cpp em troca.o, o segundo criará uma

biblioteca estática libtroca.a a partir do arquivo troca.o. Se você deseja incluir mais
arquivos de objeto em sua biblioteca, adicione-os ao final desta linha de comando. O
último comando compila seu programa main.cpp enquanto o vincula ao arquivo de
biblioteca estática troca.a. A opção (-L.) instrui o vinculador a pesquisar o arquivo de
biblioteca no diretório atual. Como alternativa, você pode querer colocar o arquivo
de biblioteca em algum outro diretório, se for o caso use a opção -Ldiretorio.

biblioteca compartilhada (dll): g
++ -shared -o troca.so troca.cpp
g++ -o main main.cpp -L. -troca
O último comando deve ser executado para compilar o programa principal.

mas para executá-lo, o sistema deve ser capaz de localizar a biblioteca compartilhada.
Deste modo voce deve adicionar o diretório onde sua biblioteca está localizada à
variável de ambiente PATH.
Agora é possível utilzar as funções da definição em qualquer outro programa C++,
para isso basta inserir uma diretiva #include para troca.h no nosso programa. Observe
a figura 18:
obs: as includes stdio.h e stdlib.h foram inseridas para permitir a utilização das
funções printf() e system().
Figura 18 – Programa em C++ que usa as funções do cabeçalho.
Atividade 7: Construa uma biblioteca estática em C++ que calcule as raízes

de funções de primeiro e segundo graus. No caso de segundo grau, caso o
determinante seja negativo, deve ser impresso “Não há raízes reais”.
Atividade 8: Construa uma biblioteca compartilhada em C++ para

determinar os divisores e os 3 primeiros múltiplos de um número inteiro, e
também para verificar se o número tem raiz quadrada inteira.

Estruturas de Dados
Complexas
Objetivos
Conceituar vetores, listas, tuplas e sets de dados;

Utilizar estruturas homogêneas e multidimensionais;
Conhecer estruturas heterogêneas de dados;
Realizar operações com arquivos texto e binários.
Estruturas Homogêneas
Na atividade anterior, você construiu um programa que calculava a média das notas dos alunos
de uma turma. Nesse programa sempre líamos a nota de cada aluno utilizando a mesma variável para
armazenar o valor. Ou seja, a cada rodada do laço, a variável assumia uma das notas do aluno e essa
nota era acumulada numa variável soma, para ao final calcular a média.
Assim, se no final do programa quiséssemos exibir as notas de todos os alunos, não seria
possível, pois sempre substituíamos uma nota de um aluno pela próxima nota. Para que fosse possível
armazenar as notas de todos os alunos, teríamos duas alternativas: a primeira, menos inteligente,
seria declarar uma variável para armazenar cada nota de cada aluno; e a segunda seria declarar uma
estrutura de dados com um único nome que fosse capaz de armazenar todas as notas dos alunos.
Diferentes linguagens de programação possuem diferentes tipos de dados capazes de realizar esta
função. Neste capítulo veremos como o C++ e o Python trabalham com estes tipos de estruturas.
Array
Um array (vetor) é uma estrutura de dados utilizada para representar certa quantidade de
variáveis de valores homogêneos, ou seja: um conjunto de variáveis, todas do mesmo tipo. Podemos
dizer que um array é uma sequência de dados de mesmo tipo ocupando posições consecutivas de
memória, e por isso, existe uma ordem natural entre os elementos de um array (o primeiro elemento,
o segundo, e assim por diante). A grande vantagem de usar array é poder trabalhar com um grande
número de variáveis utilizando um único nome (para a variável). Para isso existe uma sintaxe especial
para pegar elementos do vetor em posições específicas (como o primeiro elemento ou o décimo
elemento). O valor de uma posição específica é definido como índice do array.
Capítulo 5. Estruturas de Dados Complexas 69 ••••

A figura 19 representa a organização dos elementos em um array de inteiros. O índices indicam
a posição dos valores no array. Por exemplo, a posicão de índice 0 (zero) indica o primeiro valor do array,
que no caso é o número inteiro 32 (trinta e dois), o último valor deste array está na posição de índice 9
(nove), e contém o valor inteiro -254 (menos duzentos e cinquenta e quatro).destas linguagens.
Figura 19 – Exemplo de armazenamento de inteiros em um array.
A linguagem Python encapsula bastante o conceito de array, agregando funcionalidades e por
isso geralmente o material didático sobre arrays em Python utiliza o nome lista. Por isso veremos
separadamente as estruturas da linguagem C++ e da linguagem Python.
A sintaxe em C++ para declarar e armazenar valores em um array e feita da seguinte forma:
Sintaxe em C++:
tipo variável[tamanho];
variável[índice] = valor;
Exemplos:
int numeros[10]; // a variável numeros possui 10 elementos do tipo inteiro
char letras[20]; // a variável letra possui 20 caracteres;
numeros[4] = 339; // a posição de índice 4 de numeros recebeu o valor 339
letras[7] = ’A’; // a posição de índice 7 de letras recebeu o caracter A
Atenção: em C++ você poderá alterar valores de um array somente

uma posicão por vez como nos exemplos. Há uma exceção no caso de
strings. Neste caso é possível entra com todos os valores de uma só vez,
mas apenas no momento da declaração da variável.

Exemplo:
char letras[] = “Oficinas 4.0”; // letras foi declarada e recebeu a string “oficinas 4.0”
/* para preencher um array precisamos utilizar um laço */
int cont, nums[5];
for (cont = 0; cont < 5; cont++) //laço for
{
nums[cont] = cont; // armazena em nums os números de 0 a 4
}
Há situações onde precisamos organizar os dados em estruturas multidimencionais. A

figura 20 ilustra o caso em que é preciso ler e armazenar três notas para cada um dos 9 (nove)
alunos de uma turma.
Figura 20 – Exemplo de armazenamento de inteiros em um array de duas dimensões.
Sintaxe em C++:
int lin, col;
float notas[3][9];
for (col=0; col<9; col++)
{
for (lin=0; lin<3; lin++)
{
scanf(“%f”, &notas[lin][col]);
}
}

Listas e Tuplas em Python
Listas e Tuplas em Python também são tipos de sequências de dados e possuem muitas
propriedades comum entre elas e com o tipo array, mas a diferença básica é que a lista é mutável, assim
como o array, enquanto a tupla é imutável.
Imutável: Conforme a documentação da linguagem Python, imutável refere-

se a um objeto com valor fixo. Objetos imutáveis incluem strings, números
e tuplas. Caso seja necessário alterar o valor de um objeto imutável, é
necessário que outro objeto seja criado. Diferentemente de C++, em
Python um string é imutavel como uma tupla.
Na prática, isso implica em que não é possível fazer atribuições à um objeto imutável. Nos exemplos
a seguir veremos como podemos criar listas e tuplas e também como é possível alterar os valores de
uma lista:
lista em Python: tupla em Python:

# criando lista com 5 inteiros # criando tupla 5 constantes inteiras
lista = [1, 2, 6, 9, 10] tupla = (1, 2, 6, 9, 10)
lista[1] = 3 tupla[1] = 3 # resulta em erro
# terá a lista = [1, 3, 6, 9, 10] novatupla = (1, 3, 6, 9, 10)
Embora a tupla seja um tipo imutável, se possuir um valor de um tipo mutável, o mesmo
permanece mutável enquanto dentro da tupla. Por exemplo, se considerarmos uma tupla de listas:
# criando tupla com 2 listas
tupla = ([1, 3], [4, 8]) # note que tuplas usam parênteses e listas usam colchetes tupla[0]
[1] = 5 # resulta em tuplas = ([1, 5], [4, 8])
Existem algumas diferenças entre um array em C++ e uma lista em Python. Um array em C++
é apenas uma sequência de variáveis alocadas de forma contígua em memória, enquanto a lista em

Python é um objeto que possui diversas funcionalidades. No Array todos os elementos necessitam
ser do mesmo tipo. Quanto a listas, existem dois tipos, lista com elementos do mesmo tipo e listas
com elementos de tipos diferentes.
Código Python Resultados do Código

lista = [3, ’A’, “teste”, 8.3] [3, ’A’, “teste”, 8.3]
print(lista) 8.3
print(lista[3]) teste
print(lista[2]) [’A’, “texte”, 8.3]
print(lista[1:3]) B
lista[3] = ’B’; print(lista[3]) obs: o (;) serve para separar comandos
Atenção: se uma lista for criada com elementos do mesmo tipo, está não
acei- tará atribuições de valores de tipos diferentes aos seus elementos já
existentes. Entretanto, é possível acrescentar novos elementos de outros
tipos, e neste caso a lista deixa de ser de elementos do mesmo tipo e passa
a permitir alteração de tipos em todos os outros elementos. Assim, este
tipo de lista deixará de ser um estrutura de dados homogênea.
Acessando Elementos nas Estruturas
os elementos de uma estrutura de dados homogênea, arrays, listas e tuplas são atribuídos
a um único nome de variável, para acessar os elementos individualmente, simplesmente utilize o
nome da variável seguido de um índice entre colchetes [ ].

Elemento em Array, Sintaxe em C++:
Figura 21 – Exemplo em C++ de acesso e alteração de valor em um array.
Elemento em Lista, Sintaxe em Python:
Figura 22 – Exemplo em Python de acesso e alteração de valor em uma lista.
Elemento em Tupla, Sintaxe em Python:

Atençãos: Quando inicializamos uma estrutura é possível inserir todos
os seus elementos de uma só vez. No Python é possível reinicializar as
variáveis no decorrer do programa, mas em C/C++ isto só pode ser feito
na declaração da variável. Note que usamos as chaves para definir os
elemento de um array, colchetes para o caso de listas, e parênteses para
tuplas (o uso dos parênteses é facultativo).
Percorrendo Listas e Arrays usando Laços
É possível percorrer um array ou uma lista elemento por elemento utilizando as estruturas de
repetição. A linguagem Python possui varias maneiras de percorrer listas com for. Duas das principais
maneiras consistem em:
- trazer os elementos da lista através de seus índices usando a função range(). - buscar
diretamente os elementos através do operador in.
A seguir serão apresentadas diversas formas de percorre uma lista em Python. Este exemplos
também podem usados para percorrer tuplas.
Percorrendo Lista, Sintaxe 1 em Python:
Figura 24 – Exemplo usando laço for e função range em Python para percorrer uma lista.

Percorrendo Lista, Sintaxe 2 em Python:
Figura 25 – Exemplo em Python para percorrer uma lista com referencia direta.
No caso do laço for em C++, basta utilzar o contador como índice do array, assim, a cada iteração
será possível acessar posições do array com base no valor do contador. Como o valor do contador será
incrementado ou decrementado, alterando o índice em que será manipulando, logo, todos os elementos
da estrutura de poderão ser manipulados.
Percorrendo Array, Sintaxe em C++:
Figura 26 – Exemplo usando laço for para percorrer um array em C++.
Ainda é possível percorrer e acessar listas e tuplas utilizando a função zip(). Esta função retorna
uma lista de tuplas, onde a i-ésima tupla contém o i-ésimo elemento de cada um dos argumentos.

O exemplo usado na documentação oficial é bem claro:
Percorrendo Listas, Sintaxe 3 em Python:
O que a função faz é: para cada elemento da lista x, juntar o elemento correspondente em posição
da lista y a ele em uma tupla e adicionar a uma lista.
Figura 27 – Exemplo em Python usando a função zip para percorrer listas.
Métodos Associados a uma Lista
Nesta seção estão descritos alguns dos principais métodos (funções específicas que agem sobre
determinado tipo de dado) que podem ser utilizados com as listas.
A tabela 1 mostra um resumo dos métodos de listas mais comuns. Faça testes com esses
métodos para ganhar uma melhor compreensão do que eles fazem.
Tabela 1 – Métodos para manipulação de listas

Saiba Mais: Você poderá encontrar a sintaxe para uso dos métodos de lista no
seguinte link: https://docs.python.org/pt-br/3/tutorial/datastructures.html
Atividade 1: Faça um programa em C++ que preencha dois arrays (vetores)

“va” e “vb” de cinco posições, com números inteiros; Em seguida atribua a
um array “vres” a soma dos dois arrays anteriores elemento a elemento, ou
seja, a primeira posição de “vres” receberá a soma dos valores da primeira
posição de “va” e de “vb”, e assim por diante. Por fim imprima os valores do
array “vres” na tela.
Atividade 2: Faça um programa en C++ que solicite a digitação e armazene

10 números reais e armazene-os em um array. Depois o programa deve ficar
disponível para o usuário digitar o valor de um índice. o programa então
deverá exibir o número armazenado no índice solicitado e deve esperar que
o usuário digite outro índice (usar um Laço while). Para encerrar o programa,
o usuário deve informar um índice inválido (lembre-se de que para um array
de 10 posições os índices válidos são de 0 a 9).
Atividade 3: Faça um programa em C++ que solicite a digitação e armazene

10 números inteiros em um array. Em seguida o programa deve imprimir na
tela primeiro os múltiplos de 2 e depois os multiplos de 5 existentes no array.
Atividade 4: Faça um programa em C++ que solicite a digitação e armazene

10 números reais em um array. Em seguida o programa deve ficar disponível
para o usuário digitar um valor índice e um valor real. O programa deverá
substituir o valor anterior pelo valor real digitado, o programa então deverá
imprimir o vetor modificado e ficar disponível para outra alteração. Para
encerrar o programa, o usuário deve informar um índice inválido. (obs:
construa funções para ler, alterar e imprimir o array).
Atividade 5: Repita as atividades 1, 2, 3 e 4 anteriores usando listas em

Python em lugar de arrays.

Estruturas de Dados Heterogêneas
Todos os tipos de dados compostos que estudamos em detalhes até agora — strings, arrays,
listas e tuplas — são coleções sequenciais. Isto significa que os itens na coleção estão ordenados e
identificados por números inteiros usados como índices para acessar os valores que eles contêm.
As estruturas de dados heterogêneas são aquelas que permitem o agrupamento dados de
tipos diferentes com atribuição a um único nome de variável. Embora uma lista em Python também
possa ser uma estrutura heterogênea, as estruturas que usaremos agora não são identificadas por
índices, mas por nomes de campos ou elementos de dados. Cada linguagem de programação têm
sintaxes diferentes para estes tipos de estruturas. Primeiro veremos como estes tipos de dados
podem ser criados em C++, e posteriormente em Python.
struct em C++
Uma struct caracteriza uma variável especial que contém diversas outras variáveis, normalmente de
tipos diferentes. As variáveis internas contidas na struct são denominadas membros da struct. Podemos
dizer que as structs da linguagem C são o equivalente a um ficha ou um registro, onde podemos
armazenar diversa informações de tipos diferentes sobre algo ou alguém. O nome registro é muito
comum em outras linguagens de programação como Pascal, Fortran e Natural.
A ideia de usar uma struct é permitir que, ao armazenar os dados de uma mesma entidade, isto
possa ser feito com uma única variável. Por exemplo, se for preciso armazenar a altura, o peso e a idade
de uma pessoa, pode-se criar uma struct chamada tp_pessoa e agrupar os dados em um único
tipo de dado. Em seguida poderemos criar uma variável pessoa do tipo struct tp_pessoa, onde
poderemos armazenar os dados de uma pessoa específica. Note que agora tp_pessoa tornou-se
uma palavra reservada que representa um tipo de variável, deste modo poderemos também criar structs
contendo structs criadas anteriormente.
Sintaxe: Exemplo:
struct <identificador> struct tp_pessoa
{ {
<listagem dos tipos e membros>; char nome[50];
}; int idade;
//após declarar o tipo da estrutura, é preciso float altura, peso;
//criar a variável deste tipo. };
struct <identificador> <variavel>; struct tp_pessoa pessoa;

Observe que na declaração da variável pessoa também utilizamos a palavra chave struct antes
do tipo, pois em C é preciso explicitar esta palavra-chave para declarar uma estrutura. Em C++, você
não precisa usar a palavra-chave struct antes do tipo.
Atribuindo e Acessando os Dados em uma Struct
Após a criação ou declaração de um estrutura, será necessário armazenar, ler e imprimir os

valores dos dados contidos na estrutura. Assim, precisamos indicar qual o dado que iremos acessar na
estrutura. Usaremos o exemplo anterior “struct tp_pessoa”. Tendo criado 3 pessoas desse tipo (pessoa1,
pessoa2 e pessoa3), todas elas terão os mesmos elementos internos: nome, idade, altura e peso.
Se os dados internos têm o mesmo nome, como vamos diferenciá-los?
Para atribuir valor a um dado da struct “tp_pessoa”, basta por um ponto após o nome que você
escolheu para a variável. Após isso, podemos acessar normalmente qualquer dado da variável.
Exemplo: Exemplo: Exemplo:

strcpy(pessoa1.nome,”Zé”); strcpy(pessoa2.nome,”Jô”); strcpy(pessoa3nome,”Ju”);
pessoa1.idade = 18; pessoa2.idade = 15; pessoa3.idade = 24;
pessoa1.altura = 1.88; pessoa2.altura = 1.68; pessoa3.altura = 1.74;
pessoa1.peso = 86; pessoa2.peso = 67; pessoa3.peso = 72;
Dados Heterogêneos em Python
Em python a palavra chave struct possui um função diferente da usada em C++, portanto
para dados heterogêneos em Python usaremos outros conceitos. Tanto em C++ quanto em Python,
podemos utilizar orientação a objetos para construir classes de objetos e armazenar coleções de
dados heterogêneos, mas deixaremos orientação a objetos para outra ocasião.

Conjuntos
Python também inclui um tipo de dados para conjuntos de dados heterogêneos, chamado
set. Um conjunto é uma coleção desordenada de elementos, sem elementos repetidos. Usos comuns
para conjuntos incluem a verificação eficiente da existência de objetos e a eliminação de itens
duplicados. Conjuntos também suportam operações matemáticas como união, interseção, diferença
e diferença simétrica.
Chaves ou a função set() podem ser usados para criar conjuntos. Note: para criar um conjunto
vazio você precisa usar set(), nunca {}; este último cria um dicionário vazio, uma estrutura de dados
que discutiremos na próxima seção.
Exemplos:
> > heterogeneos = {’nomes’, 2, 3.5, ’outros’, ’2’, 3.5, “nomes”}
> > print(heterogeneos) # mostrando que duplicatas são removidas
{’outros’, 2, 3.5, ’nomes’, ’2’}
> > ’nomes’ in heterogeneos # teste rápido de existência no conjunto
True
> > > ’3.5’in heterogeneos > > > het1

False {’p’, ’e’, ’i’, ’d’, ’a’, ’r’, ’o’, ’l’}
> > > het1 = set(’paralelepipedo’) > > > het1 - het2
>>> het2 = set(’prisma’) {’e’, ’d’, ’l’, ’o’}
Dicionário de Dados
Outra estrutura de dados muito útil embutida em Python é o dicionário. Dicionários são também
chamados de “memória associativa” ou “vetor associativo” em outras linguagens. Diferente de sequências
que são indexadas por inteiros, dicionários são indexados por chaves (keys), que podem ser de qualquer
tipo imutável (como strings e inteiros). Tuplas também podem ser chaves se contiverem apenas
strings, inteiros ou outras tuplas. Se a tupla contiver, direta ou indiretamente, qualquer valor mutável,
não poderá ser chave. Listas não podem ser usadas como chaves porque podem ser modificadas
internamente pela atribuição em índices ou fatias, e por métodos como append() e extend().
Um bom modelo mental é imaginar um dicionário como um conjunto não-ordenado de pares
chave:valor, onde as chaves são únicas em uma dada instância do dicionário. Dicionários são delimitados

por chaves: , e contém uma lista de pares chave:valor separada por vírgulas. Dessa forma também será
exibido o conteúdo de um dicionário no console do Python. O dicionário vazio é .
As principais operações em um dicionário são armazenar e recuperar valores a partir de
chaves. Também é possível remover um par chave:valor com o comando del. Se você armazenar um valor
utilizando uma chave já presente, o antigo valor será substituído pelo novo. Se tentar recuperar um valor
usando uma chave inexistente, será gerado um erro.
Executar list(d) em um dicionário devolve a lista de todas as chaves presentes no
dicionário, na ordem de inserção (se desejar ordená-las basta usar a função sorted(d)). Para
verificar a existência de uma chave, use o operador in.
Exemplos:
> > > pessoa = {’nome’: ’Jô’, ’idade’: 18, ’altura’: 1.68, ’peso’: 67}
> > > pessoa[’nome’] > > > pessoa[’altura’]
’Jô’ 1.68
> > > pessoa[’idade’] > > > pessoa[’peso’]
18 67
> > > del pessoa[’peso’]

> > > pessoa
{’nome’: ’Jô’, ’idade’: 18, ’altura’: 1.68}
> > > pessoa[’sexo’] = ’F’
> > > pessoa
{’nome’: ’Jô’, ’idade’: 18, ’altura’: 1.68, ’sexo’: ’F’}
Agora vamos utilizar o construtor dict() para produzir dicionários diretamente de sequências
de pares chave-valor.

Exemplos:
> > > dict([(’nome’,’Jô’), (’idade’, 18), (’altura’,1.68), (’peso’, 67)])
{’nome’: ’Jô’, ’idade’: 18, ’altura’: 1.68, ’peso’: 67}
> > > dict(nome = ’Jô’, idade = 18, altura = 1.68, peso = 67, sexo = ’F’)
{’nome’: ’Jô’, ’idade’: 18, ’altura’: 1.68, ’peso’: 67, ’sexo’: ’F’}
Atividade 6: Crie um programa em C++ que permita armazenar o nome, a altura e da

data de nascimento de até 10 pessoas. Cada pessoa deve ser representada por uma
struct dentro de um array.
A data de nascimento também deve ser uma struct.
O nome e a altura de cada pessoa devem ser informados pelo teclado.
A data de nascimento deve ser gerada aleatoriamente através da função abaixo:
void CriaData(Data D)
{ D.Mes = 1 + (rand() % 12);
D.Ano = 1950 + (rand() % 71);
D.Dia = 1 + (rand() % 30); }
O programa deve apresentar na tela de abertura opções para:
inserir um nome;
listar todos os nomes e respectivas alturas;
listar os nomes das pessoas que nasceram antes de uma certa data fornecida.
Cada uma destas opções deve ser implementada em uma função separada.
Atividade 7: Crie um programa semelhante ao da atividade 6, porém, utilize as estruturas

necessárias para que possa ser implementado em Python.
Atividade 8: Elaborar um programa com as seguintes condições:

a) Definir uma estrutura que irá representar filmes. Essa estrutura deve ter o título do
filme, o ano de lançamento, o gênero do filme e o país de origem.
b) Criar uma função para preencher os dados relativos a cinco filmes.
c) Criar uma função que mostre toda a informação relativa aos cinco filmes.
d) Criar uma função que peça ao usuário um número de 1 até 5. Em seguida, o programa
deve exibir informações do filme dessa posição.
e) Criar uma função em que peça ao usuário um gênero de filme e em seguida
mostre os filmes que correspondam a esse gênero.

Persistência
A maioria dos programas que construimos até agora são transitórios, porque são executados
por algum tempo e produzem alguma saída, mas, quando terminam, seus dados desaparecem.
Se executar o programa novamente, ele começa novamente do zero. Outros programas são
persistentes: rodam por muito tempo (ou todo o tempo); mantêm pelo menos alguns dos seus dados
em armazenamento permanente (uma unidade de disco rígido, por exemplo); e quando são finalizados
e reiniciados, continuam de onde pararam.
Uma das formas mais simples para programas manterem seus dados é lendo e escrevendo
arquivos de texto ou arquivos binários. Uma alternativa muito usual é armazenar o estado do
programa em um banco de dados, pois permite uma organização e interrelacionamento dos dados
mais eficiente. Entretanto, neste curso iremos abordar apenas a persistência em arquivos.
Persistência em Arquivos
Arquivos são recursos que o sistema operacional promove e que as linguagens de programação
tem acesso. É uma abstração que simplifica a criação e manipulação de dispositivos de entrada e saída
de dados, não apenas restringindo a arquivos físicos gravados no disco rígido, mas também dispositivos
como o teclado e o monitor.
Quando criamos um arquivo, seja através de uma linguagem de programação ou através da
interface de usuário, na verdade não estamos propriamente criando o arquivo, mas sim delegando
esta tarefa ao Sistema Operacional (Linux, Windows, Mac), que se encarrega de fazer toda a verificação
de permissões do usuário que está executando esta tarefa e atribuindo às descrições do arquivo
informações como: usuário dono, data de criação, tipo, tamanho, data de acesso, modificação,
dentre outras.
Os arquivos são divididos em duas subcategorias:
Texto - São arquivos que contém informações no formato de caracteres, ou seja, se for aberto
em um editor de texto será completamente legível. Eles podem conter caracteres de controle com “fim
de linha”e outros;
Binário - Arquivo cujas informações são consideradas sequências específicas de 0’s e 1’s, que são
interpretadas apenas por programas que conhecem sua estrutura. Programas compilados, bibliotecas
e arquivos de dados binários são exemplos deste tipo de arquivo. Estes arquivos se abertos em um
editor de texto não terão informações legíveis. Portanto mantêm as informações mais seguras.
Para trabalharmos com arquivos são necessários alguns passos:
1) Abrir ou criar o arquivo, associando o nome físico do arquivo ao seu nome lógico.
2) Manipular os dados do arquivo: consulta, inclusão, exclusão, alteração.
3) Fechar o arquivo.

Para a criação de arquivo em C++ é necessário que façamos uma referência à um espaço da
memória. Assim, devemos declarar uma variável do tipo “FILE*”, cujo endereço será associado arquivo a
ser lido ou gravado em um dispositivo de armazenamento. Em Python isto não é necessário.
Sintaxe em C++
FILE* nome_do_arquivo;
As funções open() para Python e fopen() para C++ devolvem um objeto arquivo, e são
frequentemente usadas com dois argumentos: o nome do arquivo e modo de operação a qual será
submetido. Em C++, além de fopen() ainda podemos usar a função fopen_s() e wopen_s(), a principal
diferença é que estas duas últimas, em lugar de retornar uma referência para o arquivo, retornam
um número de erro, identificando se ouve falha na abertura do arquivo ou nos parâmetros passados
na função.
A seguir serão apresentadas algumas funções para manipulação de arquivos tanto em C++
quanto em Python. Para C++, o fprintf() e o fscanf(), funcionam basicamento como printf() e o
scanf(). Para Python temos write() e read(). Vejamos as sintaxes:
Sintaxe em C++
exemplo 1: exemplo 2:
FILE* arquivo; FILE* arquivo;
char* frase; errno_t erro;
// abrindo arquivo para escrita erro = fopen_s(arquivo, “teste.txt”, “w”);
arquivo = fopen(“teste.txt”, “w”); fprintf(arquivo, “Hello World !!!”);
fprintf(arquivo, “Hello World !!!”); fclose(arquivo);
fclose(arquivo);
// abrindo arquivo para leitura
arquivo = fopen(“teste.txt”, “r”);
fscanf(arquivo, “
fclose(arquivo);

Sintaxe em Pyton
exemplo 1: exemplo 2:
# abrindo arquivo para escrita # adicionando a arquivo existente
arquivo = open(’teste.txt’, ’w’) with open(’teste.txt’, ’a’) as arquivo:
arquivo.write(’Hello World !!!’) arquivo.write(’Hello World !!!’)
arquivo.close() # usando o comando textitwith
# abrindo arquivo para leitura #o arquivo é fechado automáticamente
arquivo = open(’teste.txt’, ’r’) with open(’teste.txt’) as arquivo:
frase = arquivo.read() frase = arquivo.read()
arquivo.close()
Observe que um dos argumentos foi ’w’ ou ’r’, eles indicam o modo para o qual o arquivo será
aberto ou criado. A tabela 28 apresenta os modos de abertura dos arquivos, tanto para Python quanto
para C++:
Figura 28 – Tabela de modos de abertura de arquivos.
Lendo e Escrevendo Blocos de Dados em Arquivos
Até aqui vimos como ler e escrever texto em arquivos, ou seja, as funções utilizadas até agora
entendem o conteúdo de um arquivo como uma sequência de caracteres (bytes). Para ler e escrever
tipos de dados maiores que um byte, utilizaremos as funções fread() e fwrite() em C/C++ e dump() e
load() em Python (para estas últimas é necessário instalar o módulo pickle). Essas funções permitem
a leitura e escrita em arquivos de blocos de qualquer tipo de dado. Além disso, escrevendo em arquivos
com estas funções o programador consegue manter os dados ilegíveis quando vistos por um editor
de texto.

Escrita em C++ Escrita em Python
Leitura em C++ Leitura em Python

Saiba Mais: Existem outras funções para manipulação de arquivos que voce
pode encontrar na documentação das linguagens. Veja nos links abaixo:
http://www.cmaismais.com.br
https://docs.python.org/pt-br/3/reference/index.html
Atividade 9: Construa um programa que armazene em um arquivo os dados

de 30 filmes. Esses dados correspondem a título do filme, gênero, duração,
ano de lançamento e o país de origem. Faça primeiro um programa para
gravar os dados como texto, em seguida faça outro programa para gravar os
dados como uma estrutura em arquivo binário.
Atividade 10: Considere um arquivo binário de registros (denominado

“alunos.bin”) onde cada registro armazena as seguintes informações sobre
um aluno qualquer de uma turma de, no máximo, 50 alunos: matrícula (cadeia
de 3 caracteres), nome (cadeia de 30 caracteres) e três notas referentes às
avaliações feitas pelo aluno (valores reais entre 0 e 10). Faça um programa que
leia este arquivo e apresente a matrícula, o nome, a nota média (a soma das
três notas dividida por três).
Atividade 11: Repita a atividade 10, porém considerando que arquivo foi
salvo como texto.

Referências
BANZATO, E. Indústria 4.0. Revista Logística Supply Chain - IMAM, v. 2015, 2015, https://www.imam.
com.br/consultoria/artigo/pdf/industria–4.0.pdf.
BARR, D.; HARRISON, J.; CONERY, L. Computational Thinking: A Digital Age Skill for Everyone. Learning
leading with Technology, v. 38, p. 20–23, 2011.
BORATTI, I. C.; OLIVEIRA Álvaro Borges de. In: . Introdução à programação: algoritmos. 3a.ed.F
lorianópolis − SC : V isualBooks, 2007.ISBN 9788575022153.
BRACKMANN, C. P.; BOUCINHA, R. M.; BARONE, D. A. C.; REICHERT, J. T.
Development of Computational Thinking in Brazilian Schools with Social and Economic Vulnerability:
How to Teach Computer Science without Machines. International Journal for Innovation Education
and Research, v. 4, p. 67, 2019.
BRACKMANN, C. P.; CAETANO, J. S.; SILVA, A. R. Pensamento Computacional Desplugado: Ensino e
Avaliação na Educação Primária Brasileira Renote. Revista Novas Tecnologias na Educação, v. 17, p.
636, 2019.
C++ DEVELOPERS. Documentação C++. 2020. Disponível em: <https://cmaismais.com.br>.
Acesso em: 21/10/2020.
CARVALHO, V. A. de. In: . Lógica de Programação: Curso Técnico de Informática. Colatina -
ES: Ifes - Instituto Federal do ES, 2010.
EC - COUNCIL. IDE Online GDB. 2018. Disponível em: <https://onlinegdb.com/pt-br/>. Acesso em:
18/10/2020.
FREIRE, A. S.; MACHADO, H. A. G.; SOUZA, D. M. de. Indústria 4.0 - Pensamento Computacional na
Educação Básica Brasileira. In: SIMPóSIO DE EXCELêNCIA EM GESTãO E TECNOLOGIA, XXVI. Resende
- RJ, 2019. p. 1–12.
LEE, K. D. In: . Python Programming Fundamentals. London - UK: Springer, 2014. ISBN 978-1-4471-
6642-9.
MENEZES, N. N. C. In: . Introdução à programação com Python. São Paulo - SP: Novatec, 2014. ISBN
9788575222508.
MICROSOFT - VISUAL STUDIO. IDE Visual Studio. 2019. Disponível em:
<https://visualstudio.microsoft.com/pt-br/>. Acesso em: 23/11/2020.
MORTARI, C. A. In: . Introdução à Lógica. São Paulo - SP: UNESP, 2001. ISBN 8571393370.
PAES, R. de B. In: . Introdução à programação com a linguagem C. São Paulo - SP: Novatec, 2016. ISBN
9788575224854.
PYTHON SOFTWARE FOUNDATION. Referência da Linguagem Python. 2020. Disponível em: <https://
visualstudio.microsoft.com/pt-br/>. Acesso em: 27/10/2020.
TANENBAUM, A. S. In: . Organização Estruturada de Computadores. 6a.ed.SãoP aulo − SP : P earson,
2013.ISBN 9788581435398.
WEBER, E. Indústria 4.0 - Efeitos sobre a Economia e o Mercado de Trabalho.
Wirtschaftsdienst, v. 95, 11aed., p.722 − −723, 2018.
WING, J. M. Computational Thinking. Communication of the ACM, v. 49, n 03, p. 33–35, 2006.
89 ••••

Apostila - Pensamento-Computacional

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila - Pensamento-Computacional

Enviado por

Direitos autorais:

Formatos disponíveis

PENSAMENTO

Instituto Federal de Educação, Ciência

Equipe de Design Institucional

©2021 Instituto Federal de Educação, Ciência e

É proibida a reprodução, mesmo que parcial,

Instituto Federal de Educação, Ciência e

Atividades de aprendizagem: apresenta atividades em diferentes níveis de

Faça sua Busca:

Nós acreditamos em você! Desejamos sucesso na sua formação profissional!

LabTef - Ifes - Ministério da Educação.

Capítulo 1. Introdução 9 ••••

Capítulo 1. Introdução 10 ••••

Bons estudos e sucesso!

Capítulo 1. Introdução 11 ••••

Conceituar Pensamento Computacional;

Conceito de Pensamento Computacional

As Características do pensamento computacional Consistem em: realizar a formulação

Pensamento Computacional: pensar nos problemas de forma analítica e

Algoritmos: é uma sequência finita de ações executáveis que visam obter

Assim, o pensamento computacional deve tornar o estudante capaz de reconhecer elementos

Capítulo 2. Pensamento Computacional 12 ••••

Atenção: Pensar computacionamente não está somente relacionado

Mídias: Entenda melhor a partir do vídeo:

Capítulo 2. Pensamento Computacional 13 ••••

Figura 1 – Passos para resolução de problemas.

Capítulo 2. Pensamento Computacional 14 ••••

Sistema de Computadores: consiste num conjunto de dispositivos

Assim, um sistema baseado em computadores é composto por hardware e software. Hardware

Capítulo 2. Pensamento Computacional 15 ••••

O Hardware dos Computadores

Hardware: é a parte física, isto é, todos os elementos concretos do

Unidade Central de Processamento:

Capítulo 2. Pensamento Computacional 16 ••••

Figura 2 – Partes físicas do computador e as vias de intecomunicação.

Como saber, dentre dois processadores diferentes, qual é o mais rápido?

Capítulo 2. Pensamento Computacional 17 ••••

A memória armazena, essencialmente, os bits. A menor unidade de informação em um

Bit: A contração das palavras dígito binário em ingles (binary digit) é o

Byte: As unidades de medida de informação indicam a quantidade de

Mídias: Se preferir ver um vídeo com mais informações sobre o

Capítulo 2. Pensamento Computacional 18 ••••

Dispositivos de armazenamento de massa:

Capítulo 2. Pensamento Computacional 19 ••••

Software: é uma sequência de instruções escritas para serem interpretadas

Podemos classificar os software ou programas de várias formas. A seguir apresentamos uma

• Sistemas ou Ambientes Operacionais - é o grande responsável pelo funcionamento do

• Compiladores e Interpretadores - São os softwares responsáveis por transformar as instruções

Capítulo 2. Pensamento Computacional 20 ••••

Atividade 2: Qual a diferença entre hardware e software?

Capítulo 2. Pensamento Computacional 21 ••••

Saiba Mais: você pode encontrar no link abaixo mais informações

Capítulo 2. Pensamento Computacional 22 ••••

Atenção: O valor da Base de um sistema de numeração indica quantos

Capítulo 2. Pensamento Computacional 23 ••••

* Onde terminam os digitos possíveis em cada sistema de numeração.

Porque os computadores não usam o sistema Decimal?

Capítulo 2. Pensamento Computacional 24 ••••

Conversão entre bases

Bases : 2 (binária), 8 (octal), 10 (decimal) e 16 (hexadecimal).

Atenção: Para indicar a qual base um número pertence vamos adotar o

Capítulo 2. Pensamento Computacional 25 ••••

Exemplo: deseja-se passar o número 1423(8) para decimal:

Como resultado, temos o número decimal 787.

Passagem da base 10 para base B