Issuu

CONHEÇA OUTROS TÍTULOS DE PROGRAMAÇÃO

PYTHON ■ COMPUTAÇÃO ■ PROGRAMAÇÃO ■ SIMULAÇÃO COMPUTACIONAL ■ LINGUAGEM DE PROGRAMAÇÃO

CAETANO

IMERSÃO EM PYTHON

MARCO ANTONIO LEONEL CAETANO

CONTEÚDO Introdução

1. Ambiente de programação 2. Criação e manipulação de dados em listas

Esta obra introduz o leitor ao estudo da computação usando o Python no ambiente de programação Jupyter. O texto parte da premissa de que o leitor não sabe programar e deseja aprender de forma contínua, no seu ritmo de aquisição de conhecimento. Os códigos e bibliotecas utilizadas são simples, com exemplos e exercícios diretos e rápidos, para permitir que o leitor se concentre melhor na formulação e execução dos scripts em Python.

O que você vai encontrar: • Como trabalhar com Python no ambiente Jupyter. • Manipulação de dados em listas. • Conceito e aplicações diretas de array. • Gráficos básicos, estatísticos e avançados. • Bibliotecas de matemática, estatística, Numpy, Pandas e Matplotlib. • Importação e exportação de dados do Python para Excel. • Rastreamento de asteroides com biblioteca da Nasa.

4. A Matemática e o Python 5. Probabilidade e estatística

IMERSÃO EM PYTHON

Prof. Dr. Carlos Henrique C. Ribeiro Divisão de Ciência da Computação Instituto Tecnológico de Aeronáutica (ITA)

MARCO ANTONIO LEONEL CAETANO Matemático pela Universidade Estadual Paulista (Unesp) e mestre e doutor em Engenharia Aeronáutica pelo Instittuto Tecnológico de Aeronáutica (ITA). Foi professor convidado de pós-graduação do ITA de 2004 a 2024. Foi avaliador de curso superior do Ministério da Educação até 2010, diretor-tesoureiro da Sociedade Brasileira de Automática (SBA) e coordenador de projetos e assessor da Fundação de Amparo à Pesquisa do Estado de São Paulo (Fapesp). Em 2023 recebeu do Insper o prêmio Chafi Haddad de Excelência em Ensino em Economia. Autor de outros livros também pela Blucher, sendo Éden dos algoritmos em Python semifinalista do prêmio Jabuti de 2025.

IMERSÃO EM PYTHON

Além das bibliotecas e assuntos básicos abordados, Imersão em Python oferece ainda descrições sobre o uso avançado da programação em assuntos que vão desde a matemática, física, administração e economia até os conceitos sobre banco de dados e estatística.

3. Trabalhando com vetores em array

O autor usa como poucos sua habilidade narrativa e pedagógica para proporcionar uma experiência de aprendizado original, sem perder clareza e objetividade, muito adequada para aqueles que têm interesse em aprender de forma rápida e efetiva.

Lições básicas para iniciantes em programação de computadores

com Python

6. Trabalhando com o Excel 7. Pandas e a estrutura dos dados 8. A Física e o Python 9. Controle de fluxo e iterações Referências bibliográficas Soluções dos exercícios

• Introdução a controle de fluxo, lógica de decisão e iterações.

Saiba mais sobre o livro

Capa_CAETANO - Imersão em Python.indd Todas as páginas

24/08/2026 17:23

Marco Antonio Leonel Caetano

IMERSÃO EM PYTHON

Lições básicas para iniciantes em programação de computadores

CAETANO_ImersaoEmPython.indb 3

10/07/2026 10:32:11

Imersão em Python: lições básicas para iniciantes em programação de computadores © 2026 Marco Antonio Leonel Caetano Editora Edgard Blücher Ltda. Publisher Edgard Blücher Editor Eduardo Blücher Coordenação editorial Rafael Fulanetti Coordenação de produção Ana Cristina Garcia Produção editorial Marcel Iha Preparação de texto Maurício Katayama Diagramação Guilherme Salvador Revisão de texto Alexandra Fonseca Capa Juliana Midori Horie Imagem da capa iStockphoto

Dados Internacionais de Catalogação na Publicação (CIP) Heytor Diniz Teixeira, CRB-8/10570

Rua Pedroso Alvarenga, 1245, 4o andar 04531-934 – São Paulo – SP – Brasil Tel.: 55 11 3078-5366 contato@blucher.com.br www.blucher.com.br

Caetano, Marco Antonio Leonel Imersão em Python : lições básicas para iniciantes em programação de computadores / Marco Antonio Leonel Caetano. – São Paulo : Blucher, 2026. 270 p. : il. Bibliografia

Segundo o Novo Acordo Ortográfico, conforme 6. ed. do Vocabulário Ortográfico da Língua Portuguesa, Academia Brasileira de Letras, julho de 2021.

00_ImersaoEmPython.indd 4

ISBN 978-85-212-3371-8 (Impresso) ISBN 978-85-212-3369-5 (Eletrônico – Epub) ISBN 978-85-212-3368-8 (Eletrônico – PDF) 1. Linguagem de programação – Python. 2. Linguagens de computador. 3. Linguagem de programação – Estudo e ensino. 4. Python – Estudo e ensino. 5. Programação de computadores. I. Título.

CDU 004.43

Índice para catálogo sistemático: 1. Linguagem de programação CDU 004.43

01/09/2026 11:17

PREFÁCIO

Marco Antonio Leonel Caetano é um profissional que quase dispensa apresentações: autor de nove livros bem-sucedidos e semifinalista do prêmio Jabuti, é matemático de formação, professor há mais de 30 anos em disciplinas de Computação, Estatística, Administração e Finanças no Insper, com mestrado e doutorado pelo ITA. Sempre atuou com rigor e curiosidade científicos, características de um pesquisador e docente que nunca para de buscar a melhor forma de estimular a aquisição de conhecimentos, sendo uma referência para colegas, alunas e alunos que têm ou tiveram o privilégio de trabalhar com ele. E numa feliz combinação de habilidades, é também dotado de criatividade e verve literária, produzindo obras que trazem os conhecimentos técnicos ao encontro de leitores em busca de enriquecimento intelectual e de novos conhecimentos e insights, mas também dispostos a ler boas histórias, sempre muito bem contadas. Temos aqui mais um livro escrito por um ótimo narrador e educador, que sabe como poucos transmitir conhecimentos e motivar seus leitores. O tema é Python, a linguagem computacional que, devido à sua aplicabilidade fundamental em diversos setores e mais especificamente no novo escopo da Inteligência Artificial, tornou-se a lingua franca no mundo da programação. A obra é muito bem-vinda: há de fato muito livros introdutórios sobre o assunto, mas o autor usa como poucos sua habilidade narrativa e pedagógica para proporcionar uma experiência de aprendizado original, sem perder clareza e objetividade, muito adequada para aqueles que têm interesse em aprender de forma rápida e efetiva. Na Introdução deste livro, Marco Caetano deixa explícita sua inquietação e empenho na busca dedicada e metódica da melhor forma de apresentar novos conhecimentos, ou seja: sua disposição para o bom combate de todo grande docente. Assim, mantém uma

00_ImersaoEmPython.indd 7

01/09/2026 11:18

Imersão em Python

tradição importante numa coleção de obras autorais que muito enriquecem a literacia científica brasileira: ótimos livros, feitos com um talento incomum, revelado em uma escrita sempre agradável, sem deixar de ser tecnicamente muito consistente. Prof. Dr. Carlos Henrique C. Ribeiro Instituto Tecnológico de Aeronáutica (ITA) Divisão de Ciência da Computação

CAETANO_ImersaoEmPython.indb 8

10/07/2026 10:32:11

CONTEÚDO

INTRODUÇÃO......................................................................................

1. AMBIENTE DE PROGRAMAÇÃO.....................................................

1.1

Escolhendo o ambiente de programação...............................................

1.2

Ambiente de colaboradores do Google (Colab).....................................

1.3

Ambiente Jupyter Anaconda..................................................................

1.4

Primeiros programas em Jupyter...........................................................

1.5

Alterando e editando células no Jupyter................................................

1.6

Utilização do Kernel................................................................................

1.7

Salvar e download..................................................................................

2. CRIAÇÃO E MANIPULAÇÃO DE DADOS EM LISTAS........................

2.1

Criando uma lista...................................................................................

2.2

Funções da matemática.........................................................................

2.3

Funções estatísticas................................................................................

2.4

Exemplos de operações com listas.........................................................

2.5

Exercícios para retenção de conhecimento............................................

CAETANO_ImersaoEmPython.indb 9

10/07/2026 10:32:11

Imersão em Python

3. TRABALHANDO COM VETORES EM ARRAY...................................

3.1

O que é um array?..................................................................................

3.2

Trabalhando com a Numpy....................................................................

3.3

Gerando sequências de números automáticos na Numpy.....................

3.4

Operações algébricas e estatísticas com array.......................................

3.5

Gráficos com array..................................................................................

3.6

Múltiplos gráficos em subplots..............................................................

3.7

Exercícios para retenção de conhecimento............................................

4. A MATEMÁTICA E O PYTHON.........................................................

4.1

Operações elementares.........................................................................

4.2

Variáveis.................................................................................................

4.3

Tipos de variáveis em Python.................................................................

4.4

Funções matemáticas.............................................................................

4.5

Soluções de sistemas lineares................................................................

4.6

Cálculo de áreas de funções...................................................................

4.7

Exercícios para retenção de conhecimento............................................ 104

5. PROBABILIDADE E ESTATÍSTICA COM PYTHON............................. 109 5.1

Estatística descritiva............................................................................... 109

5.2

Gráficos da estatística em Python.......................................................... 114

5.3

As probabilidades................................................................................... 121 5.3.1 Calculando probabilidade com densidade normal....................... 125 5.3.2 Gerando valores com densidade de probabilidade normal.......... 128

5.4

Exercícios para retenção de conhecimento............................................ 133

6. TRABALHANDO COM O EXCEL....................................................... 137 6.1

Importar arquivos do Excel..................................................................... 137

6.2

Exportar arquivos para o Excel............................................................... 139

6.3

Exercícios para retenção de conhecimento............................................ 140

CAETANO_ImersaoEmPython.indb 10

10/07/2026 10:32:11

Conteúdo

7. PANDAS E A ESTRUTURA DOS DADOS........................................... 143 7.1

Como iniciar tratamento dos dados com a Pandas?.............................. 143

7.2

Configurando um DataFrame................................................................. 143

7.3

Funções rápidas no DataFrame.............................................................. 148

7.4

Funções para cálculos estatísticos.......................................................... 151

7.5

Gráficos na Pandas................................................................................. 153

7.6

Os comandos de lógica para o DataFrame............................................. 159 7.6.1 Intersecção entre filtragens com “E”............................................ 161 7.6.2 Intersecção entre filtragens com “OU”......................................... 162

7.7

Estruturando colunas............................................................................. 163 7.7.1 Colocando uma coluna como índice............................................. 163 7.7.2 Reset o “index” mantendo o anterior como coluna..................... 164 7.7.3 Reset o “index” apagando o anterior............................................ 165 7.7.4 Reset o “index” mantendo a coluna............................................. 165 7.7.5 Renomear uma coluna (“rename”)............................................... 166 7.7.6 Apagando uma coluna (“drop”).................................................... 166

7.8

Operações com colunas do DataFrame.................................................. 167 7.8.1 Função lambda para o DataFrame................................................ 169 7.8.2 Função lambda para diversas colunas.......................................... 170 7.8.3 Função lambda para todo DataFrame com apenas uma regra..... 171

7.9

Localizar informações............................................................................. 172 7.9.1 O comando “loc”........................................................................... 173 7.9.2 O comando “iloc”.......................................................................... 175

7.10 Exercícios para retenção de conhecimento............................................ 177

8. A FÍSICA E O PYTHON..................................................................... 185 8.1

Revisitando a física básica da cinemática............................................... 185

8.2

Quadratura numérica............................................................................. 192

8.3

Equações diferenciais............................................................................. 194

CAETANO_ImersaoEmPython.indb 11

10/07/2026 10:32:11

Imersão em Python

8.4

Funções (functions) no Python............................................................... 197

8.5

Modelos com equações diferenciais no Python..................................... 198

8.6

Sistemas de equações diferenciais......................................................... 200

8.7

Cosmologia quântica – Universos paralelos........................................... 205

8.8

Mecânica orbital – Viagem Terra-Marte................................................. 208

8.9

Rastreando asteroides com a Nasa........................................................ 213 8.9.1 Preparando a base de dados dos asteroides................................ 213 8.9.2 Estatística das descobertas de asteroide...................................... 216 8.9.3 Relação distância e diâmetro de asteroides................................. 218

8.10 Exercícios para retenção de conhecimento............................................ 220

9. CONTROLE DE FLUXO E ITERAÇÕES............................................... 225 9.1

Entrada e saída de dados....................................................................... 225

9.2

A utilização do if/else/elif....................................................................... 226

9.3

Controle de Iterações............................................................................. 231 9.3.1 Iteração com while........................................................................ 231 9.3.2 Iteração com for-range................................................................. 234

9.4

Exercícios para retenção de conhecimento............................................ 237

REFERÊNCIAS BIBLIOGRÁFICAS......................................................... 241 SOLUÇÕES DOS EXERCÍCIOS............................................................... 243

CAETANO_ImersaoEmPython.indb 12

10/07/2026 10:32:11

INTRODUÇÃO

“Eu não consigo entender seus livros.” Foi assim que nasceu a ideia de escrever este livro. Numa tarde de quarta-feira, por volta das 14 horas, tomávamos um café na faculdade eu e um amigo de longa data, uma amizade que começou ainda em 2010, quando eu tinha o site “Mudanças Abruptas”, que abordava temas relacionados ao mercado financeiro. Eu fiquei com aquela conversa na cabeça, pois o intuito de um professor é fazer-se ouvir, explicar o que conhece de maneira clara para um bom entendimento das pessoas. Um professor deve professar ideias, não apenas dar aulas, passar conhecimento metódico e calculado. Isso me fez refletir que, de repente, eu estava atendendo apenas a uma parcela do público e, principalmente, quem já sabe um pouco de programação por causa dos meus outros livros sobre esse assunto. Meus outros livros são bem divulgados, muitos alunos já tiveram acesso, pessoas comuns me escrevem sempre sobre eles, mas hoje percebo que tudo o que eu conheço de computação ainda não chegou às pessoas que ainda são ávidas por aprender sobre o tema. Toda linguagem tem sua “moda”, tem seu ápice de se tornar a “melhor” de todas. Eu mesmo já vivenciei isso doze vezes na minha vida. Por doze vezes as linguagens que aprendi eram a tal “melhor linguagem de programação do mundo”. Mas depois decaíram. E agora é a vez do Python, sobretudo depois que a inteligência artificial virou a “queridinha” das pessoas que não são da área de computação. Trabalhei com a ideia deste livro de maneira intensa e fui reunindo todo o material de que já dispunha, mudando um pouco a linguagem da apresentação, tentando ser mais claro e esmiuçando os assuntos mais no sentido de “pé no chão”, como a gente diz sobre

CAETANO_ImersaoEmPython.indb 13

10/07/2026 10:32:11

Imersão em Python

assuntos básicos. Para começar, eu mudei o ambiente de programação para o Jupyter, um pouco mais didático e interativo do que o Spyder da Anaconda no ensino do Python. Nos meus outros livros, sempre iniciei com os comandos de fluxos, como “While” e “For”, mas neste texto resolvi começar apenas com listas simples e bibliotecas e suas funções. Usando as bibliotecas mais básicas, percebi que poderia, pelo menos momentaneamente, deixar de lado os controles de fluxo. O uso de funções prontas das bibliotecas para resolver problemas simples nas células do Jupyter é mais didático, e o passo a passo da execução ajuda o leitor a entender melhor um algoritmo, ou pelo menos um grande algoritmo em pequenas partes. E, dois meses após o início, cá estou eu com ele pronto e escrevendo este prefácio para você, caro leitor, numa noite agradável, quase comemorando que terminei o assunto e minha ideia está pronta. A programação de um código não é fácil e merece tratamento especial. Merece uma dedicação muito intensa para a retenção dos assuntos e domínio integral do raciocínio. Não são poucas as vezes que ouço meus alunos me abordarem e dizerem “sonhei com algoritmo”, “tive pesadelo com o algoritmo da aula”, “sonhei que o algoritmo estava correndo atrás de mim”. Pode parecer piada, mas é verdade: a intensa luta para a compreensão do funcionamento correto do algoritmo nos leva a um ritmo frenético de estudo. Também não foram poucas as vezes que vi, durante uma avaliação, um aluno comemorando, dando murros silenciosos no ar quando seu algoritmo funcionou durante a prova. É uma satisfação viciante, um sentimento de poder sobre a máquina que todos deveriam presenciar. Quem já domina a ciência da computação, e principalmente quem já domina o Python, perceberá que este livro é uma forma mais didática e simples de apresentar a mesma coisa: resolver algoritmos por meio do Python. O Capítulo 1 aborda apenas os diversos tipos de ambiente de programação e apresenta o Jupyter da Anaconda, que é utilizado em todos os outros capítulos, nos exemplos e exercícios propostos. A programação começa no Capítulo 2, no qual a formatação de listas de nomes e números é apresentada, bem como sua relação com as bibliotecas de matemática e estatística do Python. São apresentadas formas muito simples de abordagem, com soluções que lembram mais uma resolução por calculadora do que por computador. O Jupyter e suas células são explorados para facilitar a visualização dos resultados das operações com listas. Ao final de cada capítulo, coloquei uma página com as funções e as partes de bibliotecas que foram apresentadas no texto. Isso, penso eu, pode ajudar o leitor a reter conhecimento sobre os diversos nomes e inúmeras funções existentes no Python. E o Capítulo 3 se inicia mostrando que as listas são restritas e não foram construídas para a execução de cálculos complexos. É nesse capítulo que a biblioteca Numpy desponta para ajudar no entendimento sobre a noção de array. A Numpy é uma biblioteca clássica e o pilar de todas as bibliotecas mais contemporâneas do Python.

CAETANO_ImersaoEmPython.indb 14

10/07/2026 10:32:11

CAPÍTULO 1 AMBIENTE DE PROGRAMAÇÃO

1.1 ESCOLHENDO O AMBIENTE DE PROGRAMAÇÃO Ao iniciar o estudo de uma linguagem de programação, nós temos que escolher, nos dias atuais, um local para editar e rodar nossos programas. Nos anos primordiais da programação de computadores, essa escolha não existia, visto que a linguagem era única e a diferença entre as linhas de programação se dava na dependência do tipo de computador adquirido. O que se fazia era programar um código, por exemplo, em Fortran, usando um editor tipo bloco de notas, e depois, em separado, rodava-se um programa apenas para compilar e descobrir possíveis erros, e outro programa chamado de “linkador” para construir as bibliotecas necessárias para a execução correta. Quando surgiram os primeiros microcomputadores, as duas primeiras empresas dominaram esse nicho esquecido pelas grandes corporações, e duas linhas diferentes para programação surgiram para os pequenos usuários: ou se programava em computadores com sistema da Apple, ou se programava em computadores com sistema da Microsoft. Atualmente existem centenas de linguagens de programação, e para cada uma existem algumas dezenas de empresas que disponibilizam softwares específicos que facilitam a edição e a execução dos códigos. Na linguagem de programação Python existem diversos ambientes, e, neles, embora a linguagem seja gratuita e “open source”, as empresas disputam o interesse dos programadores para formar um nicho ligado aos seus produtos. Assim, uma vez formada uma grande comunidade em torno do ambiente de programação, a empresa começa a oferecer produtos customizados para outras empresas que são dependentes da linguagem. Em suma, quanto maior o número de programadores ligados a um ambiente de programação, mais fácil e barata será a mão de obra para se contratar programadores e desenvolvedores de software.

CAETANO_ImersaoEmPython.indb 17

10/07/2026 10:32:12

Imersão em Python

Especificamente para o Python, temos três interessantes ambientes de programação, formados pelos colaboradores do Google (“Colab”), pelos produtos da Anaconda e, finalmente, pelo ambiente da Microsoft, conhecido como VSCode ou Visual Studio Code. Dentro desses ambientes ainda existem diferentes editores. Um editor bastante comum entre eles é conhecido como Jupyter, no qual a programação acontece no formato de células, cada qual podendo ser independente do restante da programação. No caso da Anaconda existem outros, como o Spyder, um editor de programação nos moldes dos antigos editores tipo “bloco de notas”, em que, após escrever o código, necessita-se rodar o programa para observar os resultados. O importante da linguagem, no entanto, não é o ambiente, mas sim a forma lógica de raciocinar para se construir um bom programa, que execute de modo ótimo a tarefa proposta e que obtenha resultados rápidos.

1.2 AMBIENTE DE COLABORADORES DO GOOGLE (COLAB) Esse é um ambiente que utiliza o editor estilo Jupyter para programar códigos em linguagem Python. Uma grande vantagem é não precisar instalar o programa, visto que está vinculado à sua conta no Google. Qualquer pessoa que possua uma conta no Google poderá entrar no ambiente do Colab e imediatamente iniciar o uso do editor para programar seu script.

Figura 1.1 – Página principal do Google Colaboratory. Fonte: https://colab.google/

Entrando com sua conta no Google Colab, a página principal (no período da elaboração deste livro) tinha o formato da Figura 1.2. Essa página mostra os conteúdos de seu Google Drive em que estão salvos os programas em Python e um botão que levará a um novo notebook. Um programa em ambiente Jupyter tem o nome de notebook, com extensão *.ipynb.

CAETANO_ImersaoEmPython.indb 18

10/07/2026 10:32:12

CAPÍTULO 2 CRIAÇÃO E MANIPULAÇÃO DE DADOS EM LISTAS

2.1 CRIANDO UMA LISTA O banco de dados é uma das ferramentas mais poderosas da computação. Saber manipular e extrair informações de banco de dados oferece uma oportunidade única de reconhecimento de padrões nos dados, seja por meio de ferramentas clássicas de estatística, seja por meio dos mais recentes métodos em inteligência artificial, como machine learning ou deep learning. Lista no Python é uma sequência ordenada na qual os elementos são sempre associados a um índice. Uma lista é mais simples e de fácil manipulação com dados numéricos ou strings (letras). O uso de uma lista é bastante intuitivo no Python, como se poderá perceber no decorrer nas linhas seguintes. Por exemplo, podemos denominar uma lista como uma sequência de nomes de pessoas, números, cidades, cores, tipos de alimentos a serem comprados num mercado; enfim, tudo o que desejarmos armazenar para nos lembrar de algum fato poderá ser colocado no formato de lista. Para acessar os elementos dessa lista que salvamos, no entanto, precisaremos indicar sua localização. Essa localização na linguagem de programação se dá de maneira bem rápida quando associamos o elemento à sua posição dentro da lista. Por exemplo, vamos observar a lista da Figura 2.1. É uma lista com nomes de algumas cidades importantes do Brasil, e chamamos o nome nessa lista de “cidade”. Os elementos da lista devem ser colocados após os [ ] e, no caso do Python, quando tivermos nomes (string), devemos usar aspas ou apóstrofes.

CAETANO_ImersaoEmPython.indb 33

10/07/2026 10:32:12

Imersão em Python

Figura 2.1 – Página principal do Google Colaboratory.

Criamos a lista “cidade” logo na primeira linha do Jupyter e, usando Shift+Enter, fazemos o Python rodar o programa e armazenar o comando com o nome da lista, e juntamente foram salvos as componentes dessa lista de cidades. Os colchetes que aparecem ao lado do nome de nossa lista marcam a posição do elemento em questão. No caso, o primeiro elemento de uma lista em Python sempre iniciará com zero. O leitor deverá sempre se lembrar que a primeira posição é zero, a segunda é 1, a terceira é 2, e assim por diante. Logo, se tivermos “n” elementos numa lista em Python, sua localização terá como número o índice [n-1]. Primeiro elemento da lista O primeiro elemento da lista “cidade” é cidade[0]. Para ver esse elemento, pode-se observar nas linhas do Jupyter que cidade[0] teve como resultado após Shift+Enter o nome de ‘rio de janeiro’. Índice que marca a posição do elemento na lista

Figura 2.2 – Índice do primeiro elemento na lista.

Último elemento da lista Para ver o último elemento, basta usar -1 dentro do nome da variável lista. Índice que marca a posição do elemento na lista

Figura 2.3 – Índice do último elemento na lista.

CAETANO_ImersaoEmPython.indb 34

10/07/2026 10:32:12

CAPÍTULO 3 TRABALHANDO COM VETORES EM ARRAY

3.1 O QUE É UM ARRAY? Vimos no capítulo anterior que uma maneira de salvar dados no Python é por meio da utilização das estruturas conhecidas como listas. Elas são bem úteis, mas servem apenas para salvar dados ou, no máximo, procurar padrões específicos por meio de seus fatiamentos. Diversas vezes, no entanto, desejamos fazer operações matemáticas mais complexas com nossos dados. Por exemplo, vamos supor que tenhamos a seguinte lista com números e desejamos elevar cada valor ao quadrado.

Figura 3.1 – Limitação de uma lista em operações matemáticas.

Como se pode notar na mensagem de erro do Python, a lista não suporta a operação de potência elemento a elemento de uma só vez. Para elevar ao quadrado (uma operação simples) teríamos que tomar cada um dos elementos e separadamente elevar ao quadrado. Isso é obviamente inviável. Então devemos converter essa lista em algo que permita qualquer tipo de operação com seus elementos. Esses erros ocorrem porque uma lista precisa das vírgulas para separar os seus elementos:

CAETANO_ImersaoEmPython.indb 57

10/07/2026 10:32:13

Imersão em Python

Esse formato impede que as operações matemáticas sejam realizadas e por isso esse formato precisa ser modificado para um outro, no caso, o formato de array. Um array unidimensional chama-se vetor, relacionando-o com a nomenclatura de vetor em matemática. Já um array bidimensional chamamos de matriz, fazendo uso da mesma noção de posições indicando linhas e colunas de uma matriz. A biblioteca responsável pela manipulação matemática dos elementos de um array é a Numpy (Numerical Python).

3.2 TRABALHANDO COM A NUMPY Para importar a biblioteca Numpy, usamos o mesmo comando “import” já utilizado na biblioteca de matemática. Podemos usar um apelido para a biblioteca de forma a simplificar o uso das funções. Um apelido bastante comum para a biblioteca é “np”.

Figura 3.2 – Função “array” para transformar lista em array.

Após importar a biblioteca, transformamos uma lista em array usando a função “array”, como na entrada [3] da Figura 3.2. A variável “x” toma os valores originalmente constituídos de uma lista para um array. O valor dentro da função np.array é uma lista, pois está com a representação de colchetes e com números separados por vírgulas. Na linha [5] deixamos o nome da variável “x” e com Shift+Enter vemos o resultado na memória do Python. Uma primeira diferença é a palavra “array” na frente do conjunto de dados. A segunda diferença aparece quando colocamos a função “print”. O resultado na linha [7] é um array. O leitor poderá pensar que ainda se constitui de uma lista, mas, ao observar melhor, vemos que as vírgulas desapareceram do conjunto de dados, e isso torna então a variável “x” um array.

CAETANO_ImersaoEmPython.indb 58

10/07/2026 10:32:13

CAPÍTULO 4 A MATEMÁTICA E O PYTHON

4.1 OPERAÇÕES ELEMENTARES Após serem apresentados aspectos funcionais da linguagem Python nos capítulos anteriores, com suas estruturas dominantes e importantes, como listas e arrays, podemos aprofundar em nossas aplicações para o cotidiano. Uma primeira compreensão importante deve passar pela utilização correta do Python quando estamos diante de operações matemáticas e resolução de problemas, mesmo que estes sejam bem simples. As operações básicas no Jupyter, como uma simples soma, são realizadas da mesma forma que escrevemos nas antigas e surradas calculadoras. Por exemplo, para somar 120 + 17 na célula, basta colocar a operação usando o sinal de “+” e apertar as teclas Shift e a tecla Enter ao mesmo tempo, ou, como usamos em notação computacional, Shift+Enter.

O mesmo é válido para as outras operações básicas, como subtração, multiplicação e divisão.

CAETANO_ImersaoEmPython.indb 77

10/07/2026 10:32:14

Imersão em Python

No caso da multiplicação, como em toda linguagem de programação, usamos “*” em vez de “x” para o produto entre as parcelas. A potenciação, por exemplo, 24, deve ser feita no Python com dois asteriscos no número, ou seja,

Na operação de divisão, um importante resultado nem sempre é o valor obtido entre 10/3 = 3.333, mas o resto entre divisor e dividendo. Por exemplo, para números inteiros o resultado da divisão de 10 por 3 será 3, e teremos como resto o valor 1. O valor de 3.333 só é válido caso a operação seja para uma variável que admita dados reais e com casas decimais. Mas, em muitos problemas de computação, o resto define outras propriedades. Por exemplo, a transformação de números do sistema decimal para binário passará pela avaliação sobre os valores dos restos das divisões entre números, formando um padrão de código de barra ou QR-code como 100110101, por exemplo.

No Python, para descobrirmos o resto da divisão entre 2 números usamos o símbolo de “%”, que não devemos confundir como porcentagem de um resultado, mas como uma função que retorna o valor do resto. Assim, no caso do resto da divisão entre 10 e 3, faremos da seguinte forma:

Muitos alunos, quando estão iniciando a usar calculadoras, planilha Excel ou programando seus primeiros scripts em linguagens de programação, se confundem sobre como e em que local usar parêntesis. Existe uma ordem de prioridades nas operações matemáticas entre soma, subtração, multiplicação, divisão e potenciação.

Figura 4.1 – Ordem de prioridades nas operações matemáticas.

CAETANO_ImersaoEmPython.indb 78

10/07/2026 10:32:14

CAPÍTULO 5 PROBABILIDADE E ESTATÍSTICA COM PYTHON

5.1 ESTATÍSTICA DESCRITIVA Como o próprio nome informa, a estatística descritiva tem o poder apenas de retratar o momento em que os dados foram coletados. É impossível fazer inferências sobre essas medidas, ou mesmo previsões sobre acontecimentos. As medidas de posição são definidas de modo a apresentar o valor em torno do qual os dados se distribuem. Essas medidas são também conhecidas como medidas de tendência central, pois estabelecem uma indicação do elemento central da amostragem realizada (Fonseca; Martins, 1996; Neto, 1977). As principais medidas são a média, mediana e moda. Sejam x1; x2; ...; xn valores da variável x. A média aritmética para os dados brutos coletados em um experimento será: n

i 1

Já foi apresentada nos capítulos anteriores essa medida, e relatamos a diferença = = 2 que existe entre dados usados no formato de lista e no formato de array. Se estivermos = = 1 a biblioteca de Statistics, pois usando dados no formato de lista, precisaremos importar ela contém as medidas descritivas já programadas. = =No 0 caso do valor médio, usamos a função mean( ): = =

= CAETANO_ImersaoEmPython.indb 109

(

= (

) )

10/07/2026 10:32:17

110

Imersão em Python

Mas se os dados estiverem no formato de array, devemos usar a biblioteca Numpy, que é responsável pelas funções matemáticas e estatísticas para esse formato. No caso do valor médio, o código da célula anterior do Jupyter seria diferente, da forma:

Com o formato de array temos uma outra possibilidade de cálculo da média por meio de x.mean( ).

Um valor é dito mediano quando ele divide o conjunto de dados do experimento depois de sua ordenação, separando-o em dois subconjuntos com igual número de elementos. Sua notação em geral é . Por exemplo, vamos considerar os dados 5 7 8 10 14 A mediana é = 8 5 7 8 10 14 15 A mediana é = 9 Assim, uma maneira de se encontrar a mediana de um conjunto composto por dados brutos seria da seguinte forma. Se o número de dados “n” é ímpar, a mediana é o elemento central (n+1)/2 da amostra ordenada, caso contrário, a mediana será a média dos elementos centrais dessa amostra ordenada formada por [ n/2 , (n/2)+1]. Para a forma de lista usamos a biblioteca Statistics e para a forma de array usamos a biblioteca Numpy. A função median( ) é a mesma, mas sua forma de ativação é diferente dependendo da biblioteca, como pode ser visto a seguir.

Quando a variável é discreta, a medida de moda representa o elemento mais frequente na amostragem, ou seja, aquele que mais se repete. No entanto, para o caso em que a variável é contínua, essa definição deixa de valer e passamos a adotar uma medida de densidade.

CAETANO_ImersaoEmPython.indb 110

10/07/2026 10:32:17

CAPÍTULO 6 TRABALHANDO COM O EXCEL

6.1 IMPORTAR ARQUIVOS DO EXCEL Muitas empresas, muitos dados científicos, e ainda muitos sites trabalham com Excel, e esse formato deverá permanecer ativo por muito tempo. O Python possibilita também essa facilidade em importar ou exportar os dados no formato do Excel. Neste capítulo, vamos apresentar como importar e exportar dados do Python para o Excel usando uma biblioteca muito importante. A biblioteca Pandas é uma das melhores bibliotecas do Python, especializada na manipulação de dados em tabelas. Não vamos nos aprofundar nela neste capítulo, pois detalhes sobre a Pandas serão apresentados no capítulo seguinte. Um primeiro detalhe importante é que o arquivo em Excel, seja ele em *.xlsx ou do tipo texto, em *.csv, deve estar na mesma pasta do programa em Python que importará os dados. Se o caminho (path) for diferente, o usuário deve copiar o arquivo para a mesma pasta ou então colocar um comando de path indicando o local em que o Python deverá fazer o upload dos dados. Vamos supor que a seguinte tabela está num arquivo chamado “arquivo.xlsx” na mesma pasta do programa em Python, ou na raiz do Jupyter.

CAETANO_ImersaoEmPython.indb 137

10/07/2026 10:32:18

138

Imersão em Python

Queremos que nosso programa em Python consiga visualizar esses dados dentro das células do Jupyter.

Importamos a biblioteca Pandas com o apelido de “pd” e criamos a variável “tabela”, que receberá os dados do arquivo do Excel. O comando para importar os dados é “read_excel” e colocamos entre aspas ou apóstrofos o nome completo do arquivo e sua extensão. O problema é que esse formato importado não é array, mas o formato da biblioteca Pandas. O leitor poderá observar no comando anterior que apareceu uma coluna com os números 0, 1, 2 e 3, que indica as linhas do Excel. Para termos essa tabela como um array, colocamos o nome da tabela na biblioteca Pandas, mas com extensão “values”.

Outro fato importante é que precisamos colocar o nome da coluna. Sempre que importamos do Excel, é importante que cada coluna de dados tenha seu título para depois podermos manipular facilmente com a Pandas. Ao colocar que x receberá os dados da coluna com o nome “.values”, a variável será um array como visto acima e poderemos fazer todas as manipulações com outras bibliotecas e gráficos já vistos nos capítulos anteriores.

Caso a planilha importada não tenha título no Excel, ao importar os dados a Pandas deixará a coluna com título vazio no Python. Se isso ocorrer, será necessário renomear a coluna para que ela tenha um título. Veremos isso no próximo capítulo.

CAETANO_ImersaoEmPython.indb 138

10/07/2026 10:32:18

CAPÍTULO 7 PANDAS E A ESTRUTURA DOS DADOS

7.1 COMO INICIAR TRATAMENTO DOS DADOS COM A PANDAS? Trabalhar com dados sempre nos remete a elaborar tabelas e manipular suas colunas, linhas e valores de forma a obter algum tipo de configuração final para descrever algo ou fato escondido nos dados. Pandas vem do termo “dados de painel” em inglês, um conceito da Economia para trabalhar com métodos que tratam de conjuntos de dados complexos multidimensionais. Duas estruturas básicas importantes são as Séries e os DataFrames. Em termos de usuários da biblioteca, em 2017 só o Stack Overflow, um site para programadores em Python, atingiu o recorde de 5 milhões de visitas procurando informações sobre a Pandas. O que torna a Pandas tão diferente? Pandas é uma biblioteca versátil e que economiza dezenas de linhas de programação para manipular grandes bancos de dados. É versátil e dinâmica, no mesmo sentido do recurso conhecido como “Tabela Dinâmica” ou “Pivot Table” do Excel. E ela apresenta ainda recursos bem melhores do que o antigo banco de dados que compõe o Excel, no qual usávamos as funções BD, mas que, dependendo da quantidade de linhas e colunas, demorava muito ou apresentava uma série de erros.

7.2 CONFIGURANDO UM DATAFRAME Vamos começar a estudar aqui alguns comandos da biblioteca Pandas pelo mais básico de seus recursos contido no que se chama de DataFrame. Um DataFrame é uma tabela composta por dados, com uma dinâmica própria e agilidade bem diferenciada em relação a outros softwares que manipulam dados. Por exemplo, a biblioteca Pandas

CAETANO_ImersaoEmPython.indb 143

10/07/2026 10:32:18

144

Imersão em Python

não apenas filtra dados como o antigo Access ou o Excel, mas compõe todas as fórmulas de todas as outras bibliotecas como parte de suas funções. Ao contrário de uma tabela, o DataFrame dá a possibilidade de, na mesma coluna ou em colunas diferentes, usar letras, números e símbolos, permitindo que as buscas aconteçam de forma natural e sem erro. É possível na Pandas fazer gráficos, elaborar estatísticas e preparar estudos de tendências sem a necessidade de usar as bibliotecas vistas nos capítulos anteriores, como a Matplolib, Math, Numpy, Statistics, enfim, sem usar as principais funções dessas outras bibliotecas, pois todas encontram-se programadas na biblioteca Pandas. Vamos supor que desejamos ter uma tabela com nomes de frutas e quantidades de cada uma nas prateleiras de um mercado. A Tabela 7.1 apresenta 4 linhas, incluindo o título, com duas colunas. Essa formatação precisa ser mantida na biblioteca Pandas, usando a estrutura DataFrame. Tabela 7.1 – Tabela de frutas Fruta

Quantidade

laranja

banana

uva

melão

No Python, o primeiro passo é a importação da Pandas por meio do comando “import”, como sempre fizemos com as outras bibliotecas em todos os capítulos anteriores. Nós precisamos em primeiro lugar entrar com os dados e criar a estrutura básica do DataFrame no Jupyter, como pode ser visto na Figura 7.1. Os parêntesis são externos, pois DataFrame é uma função e, como todas as funções no Python, deve ter parâmetros e variáveis no interior deles. As chaves { } indicam tabelas e seus elementos. Os títulos das colunas devem ser strings e por isso são colocados ou com apóstrofos ou com aspas, e em seguida dois pontos preparam a coluna para receber valores. Esses valores formam uma lista (se o leitor não lembrar, retorne ao capítulo sobre formação de listas) e por isso usamos colchetes [ ], colocando em seu interior palavras, símbolos ou números. Cada nova coluna vem depois de uma vírgula, novamente colocando-se o título da coluna, dois pontos e a lista com números ou palavras. No caso a seguir, da Figura 7.1, vemos que a segunda linha, “quantidade”, tem dois pontos separando a lista de valores indicada na tabela anterior [5, 7, 6, 4]. O parêntesis final indica que a função de criação do DataFrame terminou e, na memória do Python, a Tabela 7.1 está pronta para ser usada.

CAETANO_ImersaoEmPython.indb 144

10/07/2026 10:32:18

CAPÍTULO 8 A FÍSICA E O PYTHON

8.1 REVISITANDO A FÍSICA BÁSICA DA CINEMÁTICA É interessante quando estamos viajando de automóvel numa estrada, num dia de chuva, e pensando nos perigos de uma frenagem muito próxima a outro carro logo à nossa frente. Lembrar de nossas aulas de Física no Ensino Médio nos faz pensar que a frenagem demora um certo tempo até realmente parar o carro. Temos o atrito do solo, a água para deixar escorregar os pneus, enfim, a física é realmente fascinante, pois nos traduz o que vemos na natureza. Vamos começar com o tradicional exemplo de cinemática para o lançamento de um projétil, bola, ou qualquer outro artefato com velocidade inicial V0 e altitude inicial y0. Da segunda de lei de Newton do movimento, pode-se ajustar o modelo para encontrar a posição do projétil, digamos y, a cada instante variante t segundo a fórmula: ( )=

na qual g é a aceleração gravitacional. Supondo que a altitude do lançamento começa ( ) (= ) = + do solo e é y(0) = y0 = 0 para o instante de tempo 2 t = 0,2a equação se transforma em ( )= 2

2 = CAETANO_ImersaoEmPython.indb 185

+ 2

+ = =

= 02 (8.1)

=0 =0

2 =0

2( 2 )

2 2

10/07/2026 10:32:20

186

Imersão em Python

Figura 8.1 – Lançamento de projétil com velocidade inicial V0.

Se admitirmos que g = 9.81 m/s2, nosso lançamento tem V0 = 5 m/s e desejamos saber o valor no instante t = 0.6 s, podemos programar a célula no Jupyter da seguinte maneira:

Mas podemos melhorar a saída, deixando a impressão no print( ) com mais informações sobre os resultados, escolhendo as casas decimais de y com representação %0.2f. Essa notação na impressão força o Python a imprimir em ponto flutuante (por isso a letra f) com duas casas decimais (por isso %0.2). Se quiséssemos 4 casas decimais, usaríamos %0.4f, com 5 casas decimais, %0.5f, e assim por diante. No entanto, para essa nomenclatura na impressão, colocamos as variáveis separadas no final, em parêntesis e com o símbolo % para fechar a parte de texto, como pode ser visto a seguir.

Podemos ainda inverter o problema e, uma vez fornecida a altitude y, pedir para o Python dizer qual é o tempo em que isso ocorre. EXEMPLO 8.1 Qual é o tempo após o lançamento em que o projétil atinge a altitude y = 0.2? Solução: Nesse caso, dado que y(t) = yc= 0.2,

CAETANO_ImersaoEmPython.indb 186

10/07/2026 10:32:20

CAPÍTULO 9 CONTROLE DE FLUXO E ITERAÇÕES

9.1 ENTRADA E SAÍDA DE DADOS O que vimos até o momento, nos capítulos anteriores, foram formas de programação voltadas para as células do Jupyter. Não são programas, mas linhas de código para execução de uma tarefa rápida e muito específica. Podemos controlar fluxos decisórios nos programas inteiros sem a necessidade de realizar tarefas célula a célula. Não é o escopo deste texto aprofundar esse tipo de técnica, mas é importante apresentá-la para que o iniciante em Python tenha conhecimento de controle e iterações nos processos. Para uma entrada de dados, podemos usar a função de “input” do Python. Ao ler o número ou informações por esse comando, o Python armazena na memória e passa a utilizá-lo sempre que for necessário. Ao escrever “input” na célula, precisamos antes definir o tipo de número que será lido. Usa-se “int” para números inteiros, “float” para números reais com casas decimais e, quando não colocamos nada antes da palavra “input”, significa que o computador terá que ler “string”, letras ou símbolos.

Quando ativamos com Shift+Enter, aparece uma caixa de entrada esperando a inserção de um número, como visto anteriormente. Ao colocarmos qualquer número, digamos 3, o valor x adota esse valor em sua memória. Logo, se quisermos usar “x” para somar ou realizar qualquer operação, basta somente colocá-lo nas operações. Por exemplo, para y = x + 1, quando entramos com 3 na caixa “input”, o resultado é 4.

CAETANO_ImersaoEmPython.indb 225

10/07/2026 10:32:25

226

Imersão em Python

Para ponto flutuante (número real), a entrada é:

Para a saída de dados é só usar, como já vimos em todos os capítulos anteriores, a função “print”.

9.2 A UTILIZAÇÃO DO IF/ELSE/ELIF Para diversos comandos da biblioteca Pandas, fazemos a escolha lógica dos caminhos apenas com o uso dos sinais de >, >=, <, <=, mas podemos ampliar todas as decisões com buscas mais complexas usando a função “if ” no Python. Toda linguagem de programação possui a estrutura conhecida como SE( ), uma lógica condicional que desvia o caminho seguido pelo computador para uma regra colocada pelo programador. Na imaginação popular, diz-se que o computador está tomando a decisão sobre a finalização de um evento, mas na realidade o computador está seguindo um algoritmo colocado por um humano, dizendo a ele que caminho deverá seguir se uma determinada regra for verdade, ou que outros caminhos deverá seguir se essa regra for falsa. No Python, como em todas as linguagens de programação, a estrutura lógica é definida pelo comando conhecido como “if ”. O “if ” necessita de uma condição e verifica se essa condição é verdadeira (True) ou falsa (False). if < condição > : Comando-1 Comando-2 Comando-3 ................... Comando-n else : Comando-1 Comando-2

CAETANO_ImersaoEmPython.indb 226

10/07/2026 10:32:25

SOLUÇÕES DOS EXERCÍCIOS

A seguir são apresentadas as soluções para os exercícios propostos neste livro. É fundamental repetir os programas e estudar cada solução de forma construtiva e detalhada. Não basta apenas copiar a solução para o editor do Python.

CAPÍTULO 2 1. 2. 3. 4. 5. 6. 7.

Comando de linha: x.remove(20) Comando de linha: min(x) Comando: x.sort( ) Comando: ‘aracaju’ in cidade Comando: cidade[2:4] Comando: cidade.index(‘curitiba’) Comando: x.append(3750)

CAETANO_ImersaoEmPython.indb 243

10/07/2026 10:32:25

CONHEÇA OUTROS TÍTULOS DE PROGRAMAÇÃO

PYTHON ■ COMPUTAÇÃO ■ PROGRAMAÇÃO ■ SIMULAÇÃO COMPUTACIONAL ■ LINGUAGEM DE PROGRAMAÇÃO

CAETANO

IMERSÃO EM PYTHON

MARCO ANTONIO LEONEL CAETANO

CONTEÚDO Introdução

1. Ambiente de programação 2. Criação e manipulação de dados em listas

4. A Matemática e o Python 5. Probabilidade e estatística

IMERSÃO EM PYTHON

Prof. Dr. Carlos Henrique C. Ribeiro Divisão de Ciência da Computação Instituto Tecnológico de Aeronáutica (ITA)

IMERSÃO EM PYTHON

3. Trabalhando com vetores em array

Lições básicas para iniciantes em programação de computadores

com Python

6. Trabalhando com o Excel 7. Pandas e a estrutura dos dados 8. A Física e o Python 9. Controle de fluxo e iterações Referências bibliográficas Soluções dos exercícios

• Introdução a controle de fluxo, lógica de decisão e iterações.

Saiba mais sobre o livro

Capa_CAETANO - Imersão em Python.indd Todas as páginas

24/08/2026 17:23