.. Copyright (C) Carlos Hitoshi Morimoto e José Coelho de Pina Jr. É permitida a cópia, distribuição e/ou modificação desde documento sob os termos da Licença de Documentação Livre GNU (GNU Free Documentation License) versão 1.3 ou versão subsequente publicada pela Fundação de Software Livre (Free Software Foundation); com as seções invariantes sendo Prefácio e Lista de Contribuidores, sem texto de capa ou contra-capa. Uma cópia da licença está disponível em: https://www.gnu.org/licenses/licenses.pt-br.html#FDL .. .. |name| replace:: replacement *text* .. |Python| replace:: ``Python`` .. |IPython| replace:: ``IPython`` .. |PythonAnywhere| replace:: `PythonAnywhere `__ .. |RST| replace:: `reST `__ .. |Sphinx| replace:: `Sphinx `__ .. |HTML| replace:: ``HTML`` .. |Trinket| replace:: `Trinket `__ .. |Colab| replace:: `Google Colab `__ .. |Replit| replace:: `Replit `__ .. |Runestone| replace:: `Runestone `__ .. |cscircles| replace:: `cscircles `__ Sobre ... ========= .. raw:: html

"Não é o destino, mas a jornada que importa."

Ralph Waldo Emerson? Lynn H. Hough? Aerosmith? Anônimo?

.. Seja bem-vinda e bem-vindo! Se você chegou até aqui, deve ter interesse, ou necessidade, em estudar um pouco de computação. É difícil imaginar hoje um ramo da atividade humana que não tenha se beneficiado diretamente dos avanços da computação. Seus impactos são tão notáveis que não precisamos ir longe para perceber seus efeitos. A começar talvez pelos dispositivos móveis como os telefones celulares rodando inúmeros aplicativos que, para o bem ou para o mal, vem transformando comportamentos pessoais, sociais e até criando alguns novos comportamentos. Esse exemplo de computação móvel mostra que um dispositivo "comum" como um telefone, ao se tornar digital e conectado à Internet, pode se tornar coisas bem diferentes. Por ser programável, a flexibilidade e utilidade desses dispositivos aumenta a cada nova aplicação que instalamos nessa "coisa", ou seja, a coisa telefone vira outra coisa, como agenda, tv, ou vídeo game. Assim, à medida que mais coisas se tornam digitais, conectadas à Internet e programáveis, abrem-se infinitas novas oportunidades de uso, tanto de coisas agindo individualmente, quanto coisas agindo em conjunto com outras coisas. Você provavelmente já faz uso de muitas dessas coisas. Aprender um pouco de computação pode até ajudar você a usar essas coisas de forma mais eficaz, mas o principal objetivo desse livro é que você será capaz de construir suas próprias soluções computacionais (coisas) para problemas simples. Para isso vamos orientar você na aquisição de conhecimentos e desenvolvimento de habilidades que vamos chamar de **pensamento computacional**. Tradicionalmente, cursos de introdução a computação tem grande foco no aprendizado de uma linguagem de programação. Nosso curso vai ser um pouco diferente no sentido de usar apenas recursos básicos da linguagem para resolver problemas computacionais inicialmente simples e que irão se tornando cada vez mais complexos. Nosso propósito é remover recursos "mágicos" oferecidos pelas linguagens modernas de programação para exercitar e desenvolver sua habilidade de resolver problemas usando o seu próprio raciocínio, ao invés, por exemplo, de buscar uma solução "pronta" na Internet. Para isso nos concentraremos no desenvolvimento do `pensamento computacional `_, que é um certo raciocínio aplicado na formulação e resolução de problemas computacionais. A descrição da resolução de problemas depende de uma linguagem de programação. Como nosso foco não é na linguagem em si, poderíamos a princípio adotar qualquer linguagem para desenvolver o pensamento, mas adotamos a linguagem Python por ser moderna, portável, fácil de instalar, de sintaxe simples e ainda poderosa para lhe ser útil na resolução de seus próprios problemas computacionais. Hoje é difícil imaginar alguma atividade humana que não tenha sido impactada pelos avanços em computação. Seus impactos são tão notáveis que não precisamos ir longe para perceber seus efeitos, que para o bem ou para o mal, vem transformando comportamentos pessoais, sociais e criando novos comportamentos. A começar talvez pelos dispositivos móveis como os telefones celulares |:mobile_phone:| com seus inúmeros programas, atualmente chamados de aplicativos. Esse exemplo de computação móvel mostra que um dispositivo atualmente *comum*, como um telefone, ao se tornar digital e conectado à Internet, se transforma em vários aparelhos. Por ser programável, a flexibilidade e utilidade desses dispositivos aumenta a cada nova aplicação que instalamos nessa *coisa*, ou seja, a coisa original, o telefone |:mobile_phone:|, se transforma em uma agenda |:calendar:|, em uma tv |:tv:|, em um vídeo game |:video_game:|, em um tradutor, dentre várias outras coisas. .. Para melhor ou pior, a computação vêm transformando nossa sociedade, redefinindo como fazemos certas atividades e introduzindo várias outras atividades. .. index IoT Uma outra tecnologia que começa a ser notada a nível pessoal é a Internet das Coisas ou IoT (do inglês *Internet of Things*). A IoT vem permitindo que *coisas* se tornem mais *inteligentes*, desde uma lâmpada que pode ser controlada remotamente pela Internet, até a integração de "coisas" em toda uma cidade. Dessa forma, as cidades inteligentes |:cityscape:| poderão otimizar melhor seus recursos, como por exemplo melhoria no trânsito, maior conservação de energia e redução de poluentes. À medida que mais coisas, aparelhos ou dispositivos se tornam digitais, `conectadas à Internet e programáveis `__, abrem-se um grande número de novas oportunidades de uso, tanto de coisas agindo individualmente, quanto coisas agindo em conjunto com outras coisas. Você provavelmente já faz uso de muitas dessas coisas. |:astonished:| Essas transformações são possíveis pois a computação nos ajuda a resolver de maneira extremamente rápida certos tipos de problemas que vamos chamar de *problemas computacionais*. Com tamanho impacto sobre nossas vidas |:girl_tone4:| |:adult_medium_skin_tone:| |:child_light_skin_tone:| |:girl_tone1:| |:child_dark_skin_tone:| |:adult:| |:adult_dark_skin_tone:| |:child:|, fazer todo esforço possível para entender um pouco do que trata computação com seus programas e os seus tão famosos algoritmos poderá lhe ser útil, tanto profissionalmente como também para desenvolver seu pensamento crítico, questionando qualquer coisa e todas as coisas. Alias, o `pensamento crítico `__ |:thinking:| é imprescindível para absolutamente tudo |:first_place:|! Um possível primeiro passo para se aprender computação é praticar a programação. Este texto apresenta alguns possíveis roteiros de passeios pelo *reino da* programação. Na metáfora de *Passeios por programação*, os pontos turísticos a serem visitados serão os problemas propostos ao longo de nossas andanças. Há uma variedade muito grande de possíveis caminhos que podem ser seguidos até chegar a uma solução. Ao longo de cada caminho veremos paisagens diferentes e interessantes. A escolha dos caminhos a serem visitados em cada passeio e a ordem dos destinos turísticos foi feita baseada na experiência das várias pessoas que, ao longo de muitos anos, foram as *culpadas* pelo oferecimento das disciplinas de *Introdução a Computação* e de *Princípios de Desenvolvimento de Algoritmos* do `DCC-IME-USP `__. Como em todo passeio, os destinos nos indicam as direções a serem seguidas. Cada passeio é apenas uma forma possível de chegarmos ao destino. Em geral, há vários passeios que nos levam ao mesmo destino. Por exemplo, há passeios que são mais bonitos, outros mais árduos e alguns com atalhos que podem nos levar ao destino mais rapidamente. Neste texto os destinos serão os problemas propostos e os passeios serão possíveis maneiras de resolvermos os problemas. Ao longo da construção das soluções as paisagens que veremos são as ideias ou técnicas desenvolvidas, o que faz com que o caminho seja tão relevante ou até muitas vezes mais relevante que o próprio destino. .. index:: programa .. index:: liguagem de programação O ato de programar consiste em prepararmos uma redação que descreve um passo a passo de como um problema pode ser resolvido por um computador. Essas redações são os **programas** e a linguagens utilizadas são as **linguagens de programação**. Enxergamos a linguagem de programação apenas como uma ferramenta didática e, apesar de ser um bônus concreto de aprendizagem que esperamos lhe seja muito útil, o objetivo central é que você desenvolva um `raciocínio aplicado na formulação e resolução de problemas computacionais `__. Neste texto os programas serão escritos na linguagem de programação `Python `__. Como outras linguagens modernas, a linguagem Python oferece várias ferramentas prontas, as funções nativas e módulos, que a tornam muito efetiva para escrevermos programas compactos. Apesar do domínio da linguagem e dessas ferramentas ser fundamental para um programador efetivo, nesse texto, ao menos em um primeiro momento, utilizaremos apenas um subconjunto bem limitado dos recursos de Python. Tudo isso com o objetivo de nos concentrarmos no desenvolvimento do raciocínio aplicado na formulação e resolução de problemas. Se você já sabe programar e o seu interesse é Python sugerimos que você consulte a própria `documentação do Python `__. Nessa página há um `Guia para Iniciantes `__, inclusive informações em `português `__. A abordagem adotada para desenvolver sua habilidade de resolver problemas computacionais será uma forte base conceitual e experiência com problemas inicialmente simples e cada vez mais complexos. A resolução de um problema passa pelo seu entendimento e conceituação, estruturação do problema em problemas menores e mais simples de serem tratados, busca de alternativas de solução que considerem aspectos de desempenho, definição de formas adequadas para a representação das informações, definição de casos de teste etc., até chegarmos, idealmente, em um programa correto, eficaz e bem documentado. Cada novo problema traz novos desafios que, para serem transpostos, nos levarão a novas ideias e novas práticas de programação. Ao longo da disciplina, frequentemente veremos que algumas soluções já foram implementadas em Python, as vezes na forma de um comando nativo ou integrante de algum módulo, outras vezes disponíveis na Internet e que podem ser facilmente encontradas usado algum `mecanismo de busca `__ ou ainda consultando um `chatbot `__ de inteligência artificial. Para que esses problemas e exercícios sejam efetivos no desenvolvimento de seu raciocínio, sugerimos que você primeiro procure chegar a uma solução por si mesma ou por si mesmo. Procure por ajuda ou uma solução pronta somente depois de **pensar individualmente**. Afinal, não se trata de chegar a uma resposta, o importante é o que aprendemos no caminho, inclusive, ou principalmente, com nossos erros. Como dizem, *a jornada pode ser mais relevante que o destino*. Hmm, |:thinking:| a bem da verdade, ao longo dos anos não convencemos muitas pessoas sobre esse ponto de vista... |:tired_face:| Também por esse motivo, idealmente, as suas soluções devem procurar utilizar apenas os recursos elementares que estão sendo trabalhos no momento, justamente para treinar o uso desses conceitos. Sem essa restrição, muitas e muitos estudantes gastam mais tempo procurando um *comando mágico* que resolva o problema em vez de focar no problema. Escute o que o problema tem a dizer, pense, e procure desenvolver sua própria solução. Depois de vários passeios, gostaríamos que você adquirisse uma certa habilidade para resolver problemas computacionais utilizando recursos simples do Python, mas disponíveis na maioria das linguagens de programação, como C, C++, Java etc. Esperemos que, desta forma, resolver problemas utilizando outras linguagens seja uma tarefa mais simples, mais natural. Perdoe-nos por insistir... |:face_with_rolling_eyes:| Esse não é um texto sobre Python. Nosso objetivo é mais fundamental e muito mais ambicioso. Desejamos que você adquira a capacidade de resolver problemas computacionais, independente da linguagem usada para programar suas soluções. A programação junto com a capacidade de executarmos nossos programas em uma máquina se torna uma poderosa ferramenta de exploração pois, quando expressamos nossas ideias como programas, nós as tornamos testáveis. |:thinking:| Quando procuramos e corrigimos os erros nos nossos programas, estamos procurando e corrigindo erros nos nossos pensamentos. |:pensive:| Em tempo... a ciência da computação vai além da programação. |:open_mouth:| Como ciência, ela estuda os fundamentos teóricos da informação, dos dados, da transformação dos dados e as considerações práticas para aplicar essa teoria em sistemas computacionais. Por exemplo, estudar formas para representar diferentes tipos de dados e algoritmos eficazes para manipular esses dados. O estudo dessas estruturas e algoritmos é uma excelente forma de desenvolvermos um raciocínio computacional, algo parecido com estudarmos partidas entre grandes mestres de xadrez para aprendermos a ser uma melhor jogadora de xadrez. .. **Rascunho**: Neste texto passearemos por programação ... Desejamos que ao final Esta disciplina também é um ponto de partida para o seus estudos posteriores em ciências ou engenharia. A abordagem de programação (computational thinking) e as ferramentas que você aprendeu devem auxiliá-la(o) a resolver vários problemas computacionais que serão encontrados no restante de seu curso e na vida profissional. Pensamentos ----------- .. raw:: html

"O pensamento crítico é ter o desejo de buscar, a paciência para duvidar,
o empenho para meditar, a lentidão para afirmar, a disposição para considerar,
o cuidado para ordenar e o ódio por qualquer tipo de impostura."

Francis Bacon

Frequentemente, em um ou outro passeio no texto, apelaremos para alguns dos assuntos e ideias apresentadas aqui. No momento, o que está escrito aqui pode parecer *viajar na maionese* |:man_facepalming_medium_dark_skin_tone:| |:woman_facepalming_tone2:| Com o tempo, a medida que você ganhar experiência, perceberá que faz sentido. Pelo menos é nisso que acreditamos. Vamos em frente. |:arrow_forward:| A construção das habilidades cada vez mais complexas só se tornam sólidas quando apoiadas em outras habilidades sólidas e já bem fundamentadas. Por isso muitos exercícios que você verá nesse curso são para desenvolver ferramentas e recursos antes de aplicá-las, para exercitar as ideias, mesmo quando alguns desses recursos já estejam "prontos" e disponíveis na linguagem. Ao exercitar o pensamento para remover a mágica |:mage_dark_skin_tone:| |:mage_tone2:| desses recursos, você aprofunda seu conhecimento e amplia sua competência. .. index:: algoritmo Nosso objetivo principal é desenvolver um certo `pensamento ou raciocínio aplicado na formulação e resolução de problemas computacionais `__. Frequentemente é possível identificar alguns dos seguintes componentes nesse raciocínio |:thinking:|: * **decomposição**: quebrar um problema complexo em subproblemas que sejam idealmente mais simples; * **reconhecimento de padrões**: buscar similaridades entre os subproblemas que permitam que estes sejam resolvidos de formas semelhantes; * **representação dos dados**: determinar as características do problema necessárias para sua solução; e * **algoritmos**: roteiro ou sequência de passos para resolver o problema. Em particular, quebrar um problema em subproblemas mais simples e a procura de similaridades não são estratégias somente utilizadas em programação. Essas são rotinas aplicadas por todas e todos na solução diária de problemas de diversas origens. A criatividade de cada uma e cada um nos leva muitas vezes a soluções muito engenhosas. .. index:: script Não se trata de acertar ou errar |:anguished:|. Se trata de nos tornarmos melhores pensadores. Para treinar nosso pensamento |:thinking:| começaremos sempre da análise e compreensão de um problema. Passaremos à construção de um roteiro para sua solução. Esse roteiro ou **script** é o nosso programa que, ao ser executado em um computador, nos leva a uma solução. .. colocar figura? ``` +-----------+ +------------+ +----------+ | | | | | | | Problema | -----------> | Computador | ----------> | Solução | | | | | | | +-----------+ +------------+ +----------+ ^ | | programa/roteiro/script ^ | | raciocício ^ | | nóis programa = sequência de passos/ordens Ato de programar é uma ferramenta útil ``` Tipicamente, as melhores soluções de um problemas são resultado de um profundo conhecimento do problema e de uma certa experiência com as ferramentas usadas para construir as soluções, além, é claro, de um pouco de criatividade. Veremos que, em muitos casos, nossas soluções são incorretas |:neutral_face:| por falta de conhecimento do problema ou uso incorreto das ferramentas. Para quem nunca programou, perceber certos detalhes não é fácil. Muitas vezes diferenciar o que é relevante do que é irrelevante nós impede de entender um problema, ou enxergar uma solução, ou ainda ver um erro na nossa tentativa de solução. Por isso, desde já, pedimos sua atenção e paciência para que possamos estender sua habilidade de leitura de textos para a de leitura de programas. Um dos primeiros fundamentos que vamos treinar é procurar entender o que está escrito, como **leitores** *pensando* se o que está escrito resolve o problema, para que, em seguida, possamos passar ao papel de **escritores** ou criadores de soluções. Frequentemente escrevemos *blá*, quando queríamos escrever *blá-blá* e deveríamos ter escrito *blá-blá-blá*. Confuso |:face_with_spiral_eyes:|?! Vejamos um exemplo. .. index:: precedência Considere as palavras ``"casa"``, ``"CASA"``, ``"cASa"`` e ``"CasA"``. Essas quatro palavras não são exatamente as mesmas, apesar de representarem a mesma ideia |:house:|. Cada uma delas tem uma combinação diferente de letras maiúsculas e minúsculas e por essa razão são consideradas *diferentes* em programação; pelo menos frequentemente. Considere agora o problema de colocar essas palavras em ordem alfabética crescente. Nessa ordem as letras maiúsculas têm **precedência**, devem vir antes, das letras minúsculas. Isso significa que, por exemplo, palavras que se iniciam com ``"A"`` devem vir antes de palavras que se iniciam com ``"a"``. De maneira semelhante, palavras em que a primeira letra é ``"B"`` devem preceder aquelas que iniciam com ``"b"``. ``"C"`` deve aparecer antes de ``"c"``, ... Portanto, em uma lista de palavras ordenadas alfabeticamente, uma **palavra** ou sequência de letras, como ``"aBa"`` deve aparecer antes de uma palavra como ``"aba"``. Em qual das opções a seguir as palavras ``"casa"``, ``"CASA"``, ``"cASa"`` e ``"CasA"`` estão em ordem crescente? * ``"casa"``, ``"CASA"``, ``"cASa"``, ``"CasA"`` * ``"casa"``, ``"cASa"``, ``"Casa"``, ``"CASA"`` * ``"CASA"``, ``"Casa"``, ``"casa"``, ``"casa"`` * ``"CASA"``, ``"casa"``, ``"Casa"``, ``"casa"`` Em uma próxima oportunidade veremos como utilizar a linguagem Python para determinar essa ordenação. .. figure:: ./imgs/Le_Penseur.jpg :width: 330 :height: 498 :scale: 50 :alt: This work is licensed under a Creative Commons Attribution-NonCommercial 2.5 License. :align: center :target: https://en.wikipedia.org/wiki/The_Thinker#/media/File:Mus%C3%A9e_Rodin_1.jpg `Wikipedia `__: O Pensador no Jardim do Museu Rodin, Paris. .. .. mchoice:: ordene_as_``"casa"``s :answer_a: ``"casa"``, ``"CASA"``, ``"casa"``, ``"Casa"`` :answer_b: ``"casa"``, ``"casa"``, ``"Casa"``, ``"CASA"`` :answer_c: ``"CASA"``, ``"Casa"``, ``"casa"``, ``"casa"`` :answer_d: ``"CASA"``, ``"casa"``, ``"Casa"``, ``"casa"`` :correct: c :feedback_a: lembre-se que 'C' maiúscula tem precedência sobre 'c' minúscula :feedback_b: lembre-se que 'C' maiúscula tem precedência sobre 'c' minúscula :feedback_c: parabéns, correto! :feedback_d: lembre-se que 'C' maiúscula tem precedência sobre 'c' minúscula .. Na próxima seção vamos introduzir outros conceitos sobre computadores e computação para que possamos entender melhor a natureza dos problemas computacionais e das suas soluções. Aprender a resolver problemas programar novos usos de essas coisas é certamente um desafio que, quem sabe, você mesmo vai ajudar a resolver usando algumas das habilidades que esse livro pode ajudar você a desenvolver. Mas não precisamos ser tão ambiciosos. Para alunos e alunas de engenharia e ciências exatas por exemplo, as ferramentas computacionais cobertas nesse livro podem ajudar a entender conceitos de cálculo e estatística, visualizar dados multidimensionais e simular modelos. Alunas e alunos das áreas humanas e biológicas também podem utilizar as habilidades de pensamento computacional desenvolvidas nesse livro para começar a explorar seus dados e testar seus próprios modelos. Mas seja qual for a sua área de interesse, desenvolver um raciocínio computacional vai ajudar você a desenvolver melhores programas assim como pode ajudar você a utilizar programas existentes de forma mais eficaz. Design ------ .. index:: design A palavra design é usada (abusada?) por diferentes áreas do conhecimento. Neste texto, vamos usar **design** para indicar o processo que envolve um pouco de arte, de ciência, de técnica, de experiência, de criatividade, de exploração de alternativas etc., na busca de uma solução algorítmica para um problema computacional. O processo de design se inicia pelo entendimento do problema. Muitos dos problemas que veremos possuem uma entrada e saída bem definidos. Isso facilita o design pois nos permite focar em processos que transformam os dados de entrada na saída, solução almejada. Como, em geral, há vários processos distintos possíveis que levam ao resultado correto, trabalharemos com o conceito de eficiência computacional para medir o uso de recursos, como tempo e memória, necessários para executar cada algoritmo e, assim, poder comparar soluções distintas. A escolha e definição do algoritmo a ser implementado, codificado usando Python, é o objetivo do design. Usaremos a palavra **algoritmo** para indicar uma sequência lógica das etapas que conduzem ao resultado correto. Os algoritmos são tipicamente hierárquicos, cada etapa pode ser descrita com um nível de detalhes diferente. Uma forma comum para desenvolver um algoritmo é conhecido como *top-down*, de cima para baixo, do mais complexo ao mais simples. Para pensar de forma top-down começamos desenhando a solução usando "módulos grandes" e vamos decompondo cada "módulo" até ficar claro que sabemos codificar aquele módulo. Algumas vezes é possível chegar na solução de forma *bottom-up*, de baixo para cima, do mais simples ao mais complexo. Costumamos pensar desse jeito quando sabemos resolver certos pedaços e queremos usar esses pedaços na solução. Ao usar essa forma de pensamento, tome muito cuidado para que esse desejo não se torne obsessão pois, muitas vezes, forçar o uso de algum pedaço pode conduzi-lo a um caminho errado |:face_with_head_bandage:|. Procure manter a mente |:brain:| e olhos |:eye:| abertos a novas alternativas |:thumbup_tone4:|. Um outro problema comum que encontramos em programadores menos experientes, mas que acontece com programadores experientes também é a empolgação por um certo design que foge do problema. Talvez porque algumas vezes a gente se apaixona por certas ideias, seja pela beleza, elegância, criatividade etc, que torna difícil abandoná-las. Por isso os testes são fundamentais para nos manter com os pés no chão e no caminho correto. Para você que é programador iniciante no entanto, o maior desafio está na codificação, transformação de uma ideia ou algoritmo em código. Para vencer esse desafio vamos codificar bastante para que a sintaxe da linguagem |Python| se torne natural, e vamos também fazer exercícios usando as ferramentas de programação como o editor, o terminal, o depurador etc, que constituem o IDE. Python ------ Há várias razões para termos escolhido um veículo como a linguagem Python para fazermos os nossos passeios. .. index:: Google Colab .. index:: Replit .. index:: Trinket Python pode ser instalado facilmente em várias plataformas como Linux, Window, Mac OS e Android. Mesmo aquelas e aqueles que não gostam de uma aventura nova como a de instalar um ambiente de programação pode utilizar Python pela Internet utilizando ferramentas como `Google Colab `__, `Replit `__, ou `Trinket `__. Em particular, neste texto vamos utilizar o |Trinket| para executar programas, mas isto fica para daqui a pouco. .. index:: IPython Outra razão para a escolha de Python foi a disponibilidade de consoles. Esses consoles são ambientes interativo que nos permite conversar em Python diretamente com o computador, como o **IPython Shell**. Testemunharemos ao longo dos passeios que essas conversas são extremamente convenientes e úteis para o aprendizado de programação. Por exemplo você pode pedir para executar trechos pequenos de código para testar algumas ideias e sanar, rapidamente, dúvidas sobre o comportamento de algum comando ou o resultado de algum cálculo. Há ainda visualizadores muitos bacanas para Python que nos permite ver o programa sendo executado passo a passo e o resultado produzido. Python tem uma sintaxe relativamente simples e que força a escrita de programas estruturados de forma a facilitar a visualização da solução, identificação de nossos erros e suas correções. A linguagem oferece também uma ampla variedade de módulos que a tornam muito poderosa, facilitando o desenvolvimento de software para várias áreas do conhecimento como matemática, estatística, processamento de sinais, aprendizagem de máquina e inteligência artificial, entre outras. .. No que diz respeito à programação em Python, trabalharemos com, entre outras possíveis ferramentas: - funções de entrada e saída: ``input()`` e ``print()``; - tipos nativos de variáveis: ``int``, ``float``, ``str``, e ``bool``; - funções de conversão de tipos: ``int()`` e ``float()`` ; - operadores aritméticos: ``+``, ``-``, ``*``, ``/``, ``//``, ``%``,...; - operadores relacionais: ``<``, ``>``, ``<=``, ``>=``, ``==`` e ``!=``; - operadores lógicos ou booleanos: ``and``, ``or`` e ``not``; - expressões aritméticas, relacionais e lógicas; - execução condicional, alternativa e em cadeia: ``if``, ``if-else``, ``if-elif-else``; - comando de repetição: ``while``, ``for``; - indicadores de passagem (*flags*); - funções; - listas; - strings; e - noções de algoritmos. Interatividade -------------- Conversemos um pouco sobre os chamados recursos interativos neste texto. .. index:: Runestone Há alguns anos colaboramos na tradução do inglês para o português dos livros interativos `Como Pensar como um Cientista da Computação - Aprendendo com Python `__ e `Resolução de Problemas com Algoritmos e Estruturas de Dados usando Python `__. Por interatividade entenda-se que é possível executar trechos de programas ou mesmo executar programas diretamente no navegador, dentro do próprio texto. Esses livros foram concebidos no projeto `Runestone `__. Dessa experiência, surgiu a ideia de produzirmos textos interativos em português seguindo o espírito das disciplinas *Introdução à Computação* e *Princípios de Desenvolvimento de Algoritmos* do `DCC-IME-USP `__. A interatividade neste texto é totalmente inspirada no projeto `Runestone `__ e é devida ao uso de várias ferramentas que passamos a descrever. Esperamos que a interatividade contribua de forma mais efetiva para o desenvolvimento de seu raciocínio computacional pois combinam, em um mesmo lugar, trechos breves de teoria e prática que acompanham e reforçam os conceitos e ideias trabalhadas. .. index: reST .. index: Sphinx O **texto foi escrito** no formato `reStructured Text `__ (|RST|) e transformado para |HTML| pelo `Sphinx `__. A seguir vamos mostrar a interatividade oferecida pelos consoles de execução de programas usados nesse livro. Tudo que está até o final desta seção é apenas um aperitivo do que veremos em todo o texto, não se preocupe que os detalhes, a menos quando dissermos que é para se preocupar com o detalhes |:slightly_smiling_face:|. Console ~~~~~~~ .. index:: IPython .. index:: console Chamamos de **console** ou de **shell** uma janela em que podemos inserir comandos, um por vez, e visualizar os seus resultados. Funciona de maneira semelhante a uma calculadora. Este texto usa o console `IPython `__ que você acessa diretamente em seu próprio navegador. Veja a seguir um exemplo do IPython sendo usado para determinar a soma de ``3`` e ``5`` e a diferença de ``2`` e ``7``. Depois de ``In [x]:`` colocamos o nosso comando e seguindo ``Out[x]:`` o console nos mostra o resultado do comando, em que ``x`` é um número inteiro que indica o número de comandos executados até aquele momento. .. code:: python Python 3.9.13 (main, Aug 25 2022, 23:26:10) Type 'copyright', 'credits' or 'license' for more information IPython 7.31.1 -- An enhanced Interactive Python. Type '?' for help. In [1]: 3 + 5 Out[1]: 8 In [2]: 2 - 7 Out[2]: -5 O |IPython| usado neste texto é proveniente do `PythonAnywhere `__, que é um ambiente *online* de desenvolvimento integrado hospedado na Web. Prove esse recurso interativamente no seu navegador realizando alguns cálculos na janela abaixo. Antes de mais nada, clique na janela. Por exemplo, para somar ``3`` e ``5`` digite ``3 + 5`` e em seguida tecle ``Enter``. O ``Enter`` ao final indica que terminamos o comando e que passamos a bola para que o IPython execute o comando e exiba o resultado. .. raw:: html Execução ~~~~~~~~ Para **executar os programas** em Python no navegador usaremos o `Trinket.io `__, que por sua vez se apoia no `Skulpt `__. O Trinket permite que você desenvolva e execute os programas no próprio navegador. Por exemplo, para executar o programa que está na janela abaixo clique no botão com rótulo ``Run`` com a figura, ou ícone, de um triângulo com uma ponta para a direita. Assim que o programa começar a ser executado você verá que, onde aparecia ``Run``, agora você vê ``Stop`` depois do ícone de um quadrado |:black_large_square:| Se você desejar parar a execução do programa clique no botão ``Stop``. Quando o programa chegar ao seu final, termina de ser executado, o botão com o ícone de um triângulo que representa uma tecla ``Play`` voltará a aparecer. .. raw:: html Uma coisa muito bacana com ferramentas como o |Trinket| é que podemos alterar o programa na janela, ou mesmo escrever um novo programa nessa janela, e executá-lo. Só por diversão, clique na janela e dirija o seu cursor até o número ``90`` na linha ``6``. Troque o número ``90`` por ``180`` e execute o programa novamente. Você nota alguma diferença no resultado? |:thinking:| .. _umPassoPorVez: Um passo por vez ~~~~~~~~~~~~~~~~ Nossa opinião é suspeita, mas ... outra característica muito bacana da interatividade do texto é que nos ajudará a seguir os passos do interpretador Python durante o seu passeio pelo nosso programa. Poderemos ver as *pegadas*, os efeitos, deixadas por cada passo. .. index:: visualizador .. index:: Python Tutor Veremos os programas sendo **executados um passo por vez** graças ao visualizador do `Computer Science Circle `__ (cscircle). Esse visualizador faz seu serviço utilizando o `Python Tutor `__ que implementa um ideia muita legal. Provaremos um pouco desse visualizador na janela logo a seguir. A maneira que devemos entender a visualização é a seguinte. O visualizador sempre ilumina a linha do programa que está prestes a ser executada. O que estamos chamando de iluminação é o efeito parecido com o produzido ao passarmos um marcador de textos amarelo na linha. Para tentar deixar as ideias mais claras, vamos nos concentrar no programa na janela abaixo. .. raw:: html Na janela, inicialmente, a ``linha 1`` que contém um ``print("Um")`` será a primeira a ser executada. Por essa razão ela está iluminada. Para que a instrução na linha iluminado seja executada, clique no botão ``Forward >``. Esse ``Forward >>`` significa algo como *vá para frente* ou *dê um passo* ou *anda logo* ou *execute a instrução*. Clique nesse botão é verifique que o efeito produzido será: * a ``linha 2`` passará a ser a iluminada, já que ela passará a ser a *bola da vez*; e * na janela com rótulo ``Program output``, *saída do programa*, veremos ``Um`` escrito. Clicando mais uma vez no botão ``Forward >`` a execução do programa dará mais uma passo, executando a instrução na ``linha 2``. O vizualizador: * iluminará a próxima linha a ser executada; e * escrevará a palavra ``passo`` na janela ``Program output``. Clicando mais algumas vezes em ``Forward >`` chegaremos ao final do programa. Se desejarmos que a execução de um *passo para trás* basta clicarmos no botão ``< Back``. Se quisermos ir direto para o final da execução do programa clicamos em ``Last >>``. Finalmente, para voltarmos a execução para o seu início, clicamos em ``<< First``. Brinque um pouco clicando nesses botões e observe os resultados até entender o comportamento geral deles. Mais uma funcionalidade muito útil do visualizador é que, se desejarmos, podemos alterar o programa sendo visualizado. Para isso basta clicarmos em ``Edit code``, *edite o código*, e passaremos a ver o programa na janela: .. raw:: html Agora podemos alterar o programa e assistir a execução desse programa alterado clicando no botão ``Vizualize Execution``. Dá hora, né?! |:thumbsup_tone5:| |:thumbsup_tone1:| |:thumbsup_tone3:| Outros roteiros --------------- Para aquelas e aqueles que preferem acompanhar vídeos, dentre os vários excelentes cursos que há pela internet, não podemos deixar de mencionar pelos menos dois cursos em português: * `Fernando Masanori Ashikaga `__, que é professor da `Fatec de São José dos Campos `__, é um tremendo entusiasta pelo ensino de programação, especialmente com Python. Ele preparou o curso `Python para Zumbis `__, que tem todos os seus vídeos no YouTube. * `Fabio Kon `__, que é professor do `DCC-IME-USP `__, preparou os curso `Introdução à Ciência da Computação com Python Parte 1 `__ e `Introdução à Ciência da Computação com Python Parte 2 `__, que estão no Coursera. Há vários ótimos livros de introdução à programação. Alguns exemplos dos quais buscamos constante inspiração são: * `Como Pensar Como um Cientista da Computação `__ de Brad Miller e David Ranum; * `Resolução de Problemas com Algoritmos e Estruturas de Dados `__ usando Python de Brad Miller e David Ranum; e * `Introduction to Programming in Python `__ de Robert Sedgewick, Kevin Wayne e Robert Dondero. Há muito mais material disponível, tanto impresso quanto *online*. Mas assim como é improvável aprender a andar de bicicleta apenas estudando livros, desenvolver um raciocínio computacional exige muita prática na resolução de exercícios. Sabemos que, para alguns alunos e algumas alunas, esse processo pode ser longo e cheio de desafios. Esse material foi desenvolvido com esses alunos e alunas em mente e esperamos que lhes possa ajudar na superação desses desafios. O que é... ---------- Aqui vai um lista de termos que usamos nesse capítulo e os seus significados. .. glossary:: acrônimo Acrônimo é uma palavra formada pela inicial ou por mais de uma letra de cada um dos segmentos sucessivos de uma locução. Por exemplo, IoT é um acrônimo de *Internet of Things*. algoritmo algoritmo é uma estratégia, roteiro ou sequência de passos para resolver um problema design design é o processo que envolve arte, ciência, técnica, experiência, criatividade, de exploração de alternativas etc, na busca de uma solução algorítmica para um problema computacional Google Colab Colab é um ambiente de programação em que pode utilizar Python através navegador. IoT IoT é um acrônimo para Internet das Coisas, do inglês *Internet of Things* IPython |IPython| é um console ou shell onde podemos executar comandos e ver seu resultados. linguagem de programação Linguagem de programa é a linguagem usada para escrever programas precedência Precedência indica uma ordem dos elementos um conjunto. O conjunto pode ser de instruções em uma expressão. programa Programa é um roteiro escrito em linguagem de programação que descreve as operações que um computador ou outra máquina deve realizar para solucionar um problema. Python |Python| é a linguagem de programação que é usada neste texto. PythonAnywhere |PythonAnywhere| é o ambiente online usado neste texto para exibir janelas do |IPython| Python Tutor `Python Tutor `__ ferramenta utilizada para visualizar a execução de scripts em Python Replit |Replit| um ambiente de programação em que podemos utilizar Python através do navegador. Runestone |Runestone| é um projeto que tem como objetivo democratizar os livros didáticos para o século XXI. script Script é o mesmo que programa. Normalmente chamamos de scripts os programas escritos em uma linguagem interpretada como Python. Trinket |Trinket| um ambiente de programação pode utilizar Python através do seu navegador. Este texto usa este ambiente. visualizador Visualizador é a ferramenta que permite que acompanhemos a execução de um script em Python passo a passo, instrução a instrução, linha a linha. .. raw:: html

"A última coisa que se descobre ao escrever um texto é o que colocar primeiro."

Thomas Stearns Eliot