4. Pensamentos alternativos#

4.1. Introdução#

" Se correr o bicho pega.
Se ficar o bicho come. "

Ditado popular

O foco do capítulo anterior foi na entrada e na saída dos dados, que permitem que programas se comuniquem em particular com as pessoas. Realçamos a importância da escolha dos tipos para representar cada dado e aprendemos a salvar e manipular dados por meio de variáveis.

O processamento dos dados que realizamos até aqui ficou limitado ao cálculo de expressões, feito de forma linear ou sequencial como no caso da conversão de uma temperatura em Celsius para Fahrenheit. Nesse processamento há uma sequência de instruções em que cada uma é executada, uma após a outra.

Soluções de problemas mais complexos requererem o tratamento de casos alternativos, criando bifurcações no fluxo de execução fazendo que nem toda instrução seja executada. Em forma não linear alguns trechos de código são pulados ou tratados de forma alternativa. Por exemplo, um caminho da bifurcação pode cuidar da conversão de graus Celsius para Fahrenheit, enquanto que um outro caminho alternativo pode fazer a conversão de Fahrenheit para Celsius. Para isso, é necessário instruir o computador para executar certos trechos do programa apenas quando alguma condição é satisfeita: o valor recebido está em graus Celsius e deve ser convertido para Fahrenheit ou está em Fahrenheit e deve ser convertido para Celsius.

A identificação e decomposição de um problema em alternativas, definição das condições e da lógica para aplicação dessas condições é o fundamento do pensamento computacional que vamos treinar nesse capítulo.

4.2. Para onde vamos#

Depois do treinamento neste capítulo você terá aplicado e identificado situações para o emprego:

  • de execução condicional com if;

  • de execução alternativa com if-else;

  • de execução em cadeia com if-elif-else;

  • de condições na forma de expressões relacionais e lógicas; e

  • do operador de resto de divisão %.

4.3. Alternativa simples#

Antes de pensar na solução é necessário ter um profundo entendimento do problema.

Ao pensar no problema muitas alternativas tendem a surgir naturalmente. Problemas muito complexos apresentam um grande número de casos que precisamos considerar. Para tratar problemas complexos assim, precisamos quebrar o problema em subproblemas mais simples, pedaços ou “classes” de problemas e depois quebrar as classes em subclasses, e assim por diante, até que consigamos resolver o subproblema sem precisar decompo-lo.

Para ajudar você a pensar no problema, um primeiro passo portanto é identificar as alternativas ou classes como, por exemplo, escolher se devemos ficar ou correr. A seguir podemos tentar identificar propriedades dos dados que nos permita tomar decisões como, se o bicho for gordo e lento a gente corre, e o bicho for manso a gente fica, e o bicho for forte e rápido… A identificação dessas classes e propriedades fazem parte do modelamento do problema.

Problemas simples tem poucas classes e propriedades. Por exemplo, para saber se uma pessoa tem idade para tirar a carteira de motorista, podemos testar a propriedade “idade” e caso a idade for maior ou igual a 18 anos, então a pessoa pode tirar a carteira. Caso contrário, a pessoa não pode. Essa situação tem portanto apenas 2 classes, que são as das pessoas com 18 ou mais anos e as com menos de 18 anos de idade.

Assim, um problema mais simples de classificação surge quando podemos dividir o problema original em apenas duas classes como, por exemplo, maior ou menor, com ou sem fome, dentro ou fora, alto ou baixo, certo ou errado, verdadeiro ou falso etc.

4.3.1. Estratégia para resolver um problema de classificação#

Uma estratégia para resolver um problema binário de classificação, ou seja, um problema que tem apenas duas classes, é criar uma variável de estado ou indicadora. Essa variável indicará o subproblema que deverá ser tratado. Inicialmente, a variável é deixada arbitrariamente em um dos possíveis estados. Em seguida um teste é realizado para garantir que a variável está no estado correto ou que o seu estado deverá ser alterado.

Considerando o problema anterior de decidir se uma pessoa tem idade para ter uma carteira de motorista, que é de 18 anos, podemos pensar da seguinte forma

  1. Suponha que a pessoa tem menos de 18 anos

  2. Se a idade da pessoa for maior ou igual a 18:
    1. então agora sabemos que a pessoa tem menos de 18

O Se a idade… é o ponto que, digamos, verificamos a carteira de identidade da pessoa. Após seguir os passos acima saberemos se a pessoa em questão pode ou não tirar sua carta de motorista.

Vamos considerar um outro exemplo. Suponha que uma aluno está aprovado em uma disciplina se sua nota é maior ou igual a 5. Para decidirmos se o aluno está aprovado podemos seguir passos idênticos aos que fizemos acima. Consideraremos duas classes: aprovado e reprovado. Construirmos uma solução supondo que o aluno está em uma classe, digamos na classe dos aprovados. Podemos indicar isso usando uma variável de estado aprovado e atribuir o valor booleano True como aprovado = True. É evidente que essa nossa suposição inicial pode estar incorreta e, para corrigir isso, podemos olhar o histórico escolar e testar “se a nota é menor que 5” e, se for o caso, alteramos a condição do aluno para aprovado fazendo aprovado = False.

Uma outra solução possível seria inicialmente supor que o aluno está reprovado, indicando isso na nossa variável de estado fazendo aprovado = False. Essas duas alternativas de solução estão ilustrados na figura 4.1, na forma de fluxogramas e também de pseudocódigos. Apesar dessas duas estratégias, políticas ou algoritmos serem idênticos, há situações em que a seleção arbitrária do estado inicial pode tornar a solução mais simples ou mais rebuscadas.

Figura 4.1: alternativas para classificar um aluno

Fig. 4.1 Figura 4.1: Fluxogramas e pseudocódigo facilitam o pensamento.#

Um fluxograma é uma forma gráfica para visualizarmos fluxo de execução em que os dados são processados.

Passemos a examinar mais atentamente fluxograma da esquerda. O “Início” indica o primeiro bloco de instruções a serem executados. Nesse bloco a nota é lida e a variável de estado situação recebe um valor é inicial supondo que o aluno está “aprovado”.

Depois deste bloco o processamento segue para o losango que contém teste que será feito. O resultado deste teste ou condição pode ser verdadeiro (True) ou falso (False). A partir do losango, o fluxo de execução seguirá o caminho indicado pela seta com rótulo correspondente ao resultado da condição. Observe que há um desvio do fluxo quando a condição nota < 5.0 no losango é satisfeita e o seu resultado é True. Nesse caso a classe do aluno indicada por situação será modificada de “aprovado” para “reprovado”. Após a execução condicional desse bloco o processamento volta ao seu curso normal, imprimindo o valor “aprovado” ou “reprovado” de situação. No caso da condição da condição nota < 5.0 ser False o processamento segue direto para o bloco que imprime o valor de situação.

No fluxograma da direita mostra que alternativamente podemos inicializar situação no estado “reprovado”. Nesse casso é necessário também modificar a condição no losango para nota >= 5.0 e alterar o estado de situação de “reprovado” para “aprovado” se essa nova condição for True.

Uma outra forma de pensar é usar pseudocódigo, como ilustrado na parte inferior da figura 4.1. Note a tabulação da quarta linha no pseudocódigo. Essa tabulação indica que a instrução da linha está subordinada ao resultado da condição; ela só será executada se a condição for True.

A diferença entre os dois pseudocódigos apresentados está em uma decisão de projeto. No pseudocódigo da esquerda optamos por escrever situação = "aprovado" declarando assim que o estado inicial, ou default, do aluno é “aprovado”. No restante do código procuramos certificar essa decisão inicial. Após verificar a nota, se necessário, modificando o estado fazendo situação = "reprovado". O pseudocódigo da direita corresponde ao estado default de “reprovado”.

Fluxogramas e pseudocódigos são usados para escrevermos soluções ou esboços de solução de uma forma mais solta sem nos preocuparmos prematuramente com detalhes da linguagem de programação. Isso permite que tenhamos mais liberdade para concentrar o nosso pensamento no projeto da solução.

A seguir veremos como transformar soluções na forma de fluxograma ou pseudocódigo para um script na linguagem Python.

4.3.2. Comando if#

O pseudocódigo ilustrado na figura 4.1 está em português, mas adota uma estrutura muito semelhante com Python. Se trocarmos “leia a nota” pela função input(), e traduzirmos a “se” para if estaremos muito próximos de um trecho de código válido em Python, como o CodeLens abaixo pode atestar. Execute esse programa passo-a-passo com valores diferentes de nota, como 4.5, 5.0 e 6.2, para monitorar quando a variável situacao muda de valor. Como nomes de variáveis nos códigos em Python não usaremos acentuação como em éãüàê ou símbolos gráfico como ç.

Como funciona esse trecho?

Inicialmente, na linha 1, o programa lê um valor e associa a variável nota a este valor. Assim, nota passa a ser uma referência ou apelido para o valor lido. Em seguida, na linha 2 é criada a variável de estado situacao associada a um valor arbitrário com um valor apropriado, o programa testa se a nota é menor que 5.0 na linha 3. Se o resultado da condição for True, o programa altera situacao de 'aprovado' para 'reprovado'. Se o resultado da condição for False, a variável situacao fica inalterada pois nossa hipotése inicial se confirmou.

Veja que nesse exemplo a situação do aluno é definida por uma string 'aprovado' ou 'reprovado'. Isso permite que o resultado seja impresso diretamente na linha 5. Entretanto, a variável de estado poderia armazenar qualquer coisa para indicar a situação, como um valor booleano True ou False.

Em português if significa se. O comando if permite que uma parte do programa seja executada apenas quando uma certa condição é True. A sintaxe do comando if é a seguinte:

if condição_do_if:
    # bloco executado se a condição for verdadeira
    comando_1
    comando_2
    ...
    comando_m       # último comando do bloco

comando_após_if

Apenas se condição_do_if for True, o bloco contendo os comandos comando_1 a comando_m é executado. Em caso contrário, se condição_do_if for False, esse bloco não é executado, ele é “pulado”, e a execução do programa continua com o comando comando_após_if. Observe com muita atenção os dois pontos : e a tabulação das linhas seguintes. Essa tabulação é absolutamente fundamental para indicar indica o bloco ou lista de comandos que serão executados se condição_do_if é True. Veremos isto várias outras vezes, mas ajuda a nos habituarmos e notarmos que em Python os dois pontos : indicam que estamos prestes a definir uma lista de comando que serão executados como uma unidade, um bloco.

Como testar o seu programa

Quanto mais complexo um algoritmo, mais fácil é esquecer de tratar alguma classe. Uma forma de melhorar a qualidade e correção dos seus programas é testá-los. Testes não asseguram que um programa está correto, mas são úteis para encontrarmos erro.

Para testar o seu programa, para cada categoria escolha valores representativos. No caso do exemplo do exercício para verificar se um aluno está aprovado ou reprovado, não deixe de testar o programa com valores limites de cada categoria tais como 0.0, 4.9, 5.0, e 10.0.

Testar se a entrada de um programa é válida não é uma tarefa fácil. Consistência de dados é um exercício a parte. Para nos concentrarmos em um exercício por vez, supermos que a entrada é sempre válida a não ser que seja explicitamente pedido para que se teste consitência. Desta forma, no exercício das notas, você pode supor que os valores fornecidos ao programa são valores float entre 0 e 10. Portanto, não se preocupe se o valor fornecido ao programa é um float entre 0 e 10 ou se é uma string como ‘a’ ou se é qualquer outra valor.

4.4. Alternativas mutuamente exclusivas#

Em muitas ocasiões temos que decidir entre duas ou mais possibilidades de ação. Ir ao cinema ou estudar computação? Dificilmente faríamos as duas coisas simultaneamente: ir ao cinema estudar computação. Frequentemente há mais do que duas possibilidades, entretanto no momento nos concentraremos em apenas duas possibilidades.

Do ponto de vista de programação, em várias ocasiões é necessário executar blocos de forma mutuamente exclusiva. A execução de um exclui a execução da outra e vice-versa. Essa situação corresponde a uma bifurcação no caminho do fluxo de execução do programa. Exatamente igual a uma bifurcação em uma estrada. Para aqueles e aquelas familiares com o mapa do estado de São Paulo esse bifurcação é semelhante a ir de São Paulo a Campinas pela Rodovia Anhanguera ou pela Rodovia Bandeirantes. A origem e o destino são fixos, entretendo o caminho que nos leva de um ponto a outro é diferente.

O problema de classificação binária pode também ser entendido como um problema de execução “mutuamente exclusiva”, como ilustra o fluxograma e o código fonte na figura 4.2.

Figura 4.2: Exemplo de alternativa com execução mutuamente exclusiva para classificar um aluno

Fig. 4.2 Figura 4.2: Fluxogramas e pseudocódigo do exemplo anterior mas com execução mutuamente exclusiva.#

Na figura, o losango com a condição nota >= 5 é um ponto de bifurcação. Se nota >= 5.0 é False o fluxo segue pelo caminho da esquerda e situação passa a ser reprovada, em caso contrário o fluxo segue o caminho da direita é situação será aprovada.

4.4.1. Comando if-else#

Para escrever a execução mutuamente exclusiva em Python podemos utilizar o comando if-else (que significa se-senão em português), cuja sintaxe é a seguinte:

.. Sintaxe do comando if-else
if condição:
    # bloco contendo comandos a serem executados
    dentro_do_if_1
    dentro_do_if_2
    ...
    dentro_do_if_m
else:
    dentro_do_else_1
    dentro_do_else_2
    ...
    dentro_do_else_n

comando_após_if

Apenas caso a condição for verdadeira, o bloco contendo os comandos dentro_do_if_1 a dentro_do_if_m é executado. Caso contrário, esse bloco dentro_do_if é pulado e o programa executa os comandos dentro_do_else_1 a dentro_do_else_n. Ao final do bloco, a execução do programa continua com o comando comando_após_if.

O fluxograma da figura 4.2 ilustra que, ao invés de iniciar uma variável de estado com a aluna em situação de aprovada como mostrado na figura 4.1, podemos usar essa construção com execução mutuamente exclusiva, como ilustrado pelo seguinte trecho de código em Python (novamente, muito parecido com o pseudocódigo, mas em inglês):

Como funciona esse trecho?

Logo após ler a nota na linha 1), a nota é testada na linha 2 e, caso seja maior ou igual 5.0, a situação da aluna é marcada como aprovada. Caso contrário, o programa executa o bloco da cláusula else na linha 5, marcando a situação como reprovada. A última linha imprime a situação da aluna.

Embora essa solução seja bastante clara e elegante para aplicar o if-else, para situações que dependam de uma variável de estado, recomendamos o uso da versão sem o else. Além de ser mais curto escrever apenas o if, esse tipo de solução força o pensamento a começar em algum estado (inicialização da variável de estado) e isso pode ajudar a estruturar melhor a solução.

Mas então, quando devemos usar o ``else``?

A resposta (ao menos por enquanto) é usar o if-else para evitar a execução de computações desnecessárias e caras. Por exemplo, imagine que o Cebolinha dependa da resposta da Mônica para pintar a casa de vermelho ou de verde. O Cebolinha pode arriscar e primeiro pintar a casa de verde e, dependendo da resposta da Mônica, ter de repintar a casa depois de vermelho. Em pseudo código, isso poderia ser escrito como:

  • pinte a casa de verde

  • leia a cor preferida da Mônica

  • se a cor preferida for vermelho
    • pinte a casa de vermelho

Veja que há um risco grande do Cebolinha ter de gastar muita tinta seguindo esse algoritmo. Nesse caso, seria mais ecológico seguir os seguintes passos:

  • leia a cor preferida da Mônica

  • se a cor preferida for vermelho
    • pinte a casa de vermelho

  • senão:
    • pinte a casa de verde

Veja que desse jeito a gente consegue ajudar o Cebolinha a economizar muita tinta e tempo!

Assim como é bom para o Cebolinha economizar tinta nesse exemplo, ao escrever programas, procure evitar computações desnecessárias. O else pode ser muito útil para isso. No caso da variável de estado, o custo computacional é irrelevante e podemos ganhar na qualidade da solução com uma estratégia mais clara de começar em um estado e ir decompondo o problema em subalternativas.

4.4.2. Prefira if-else a if-if#

Muitos programadores novatos tendem a limitar o pensamento a casos específicos, ou seja, tentam tratar um caso de cada vez por meio de vários if``s. Esse padrão ``if-if é desaconselhável pois torna o programa mais difícil de ler, o que também dificulta corrigir e fazer a manutenção do código. Como exemplo, considere o seguinte trecho de código para determinar se um número é par ou ímpar:

Como funciona esse trecho?

Após n receber um número, o programa testa, na linha 3, se n é múltiplo de 2 usando o operador aritmético %. Esse operador determina o resto da divisão de n por 2. Caso a condição seja verdadeira (= True), o programa armazena na variável estado que o número é par.

Na linha 5 o programa recalcula o resto da divisão de n por 2 e verifica se o resto é diferente de zero, ou seja, se o número não é múltiplo de 2 e, nesse caso, armazena na variável estado que o número é ímpar.

Observe que a condição dos ifs nas linhas 3 e 5 foram executadas, mesmo quando na linha 3 o número já foi identificado como par, o teste da linha 5 é realizado.

4.4.3. Pare e pense um instante#

Procure pensar em como evitar o if-if nesse caso, modificando o código acima para (edite no próprio ActiveCode) para:

  • Solução alternativa 1: usar if-else ao invés de if-if: altere o if na linha 5 para usar um else. Observe que essa solução é mais eficiente pois evita a computação de “n não é múltiplo de 2”, e também é mais elegante e clara pois o uso do else indica que o processamento é feito de forma mutualmente exclusiva;

  • Solução alternativa 2: usar um só if ao invés de if-if: simplesmente assumindo que o valor inicial de estado = "ímpar" antes do primeiro if; e

  • Outros múltiplos: modifique a condição do if para verificar se um número é múltiplo de 3 ou não. Experimente outros números também para entender o operador %.

Embora a solução if-if produza resultados corretos, o uso do comando if-else ou apenas o if torna o programa bem mais elegante e seguro.

Variável de estado

Pense agora na variável estado. Você já deve ter pensando que essa variável é inútil e que podemos eliminá-la e colocar prints nas linhas 4 e 6, com as mensagens adequadas.

Se você pensou assim, com relação ao funcionamento do programa, você tem razão.

Por outro lado, gostaríamos que você procure usar esse padrão de pensamento:

  1. carregar os dados e definir os estados iniciais;

  2. processar os dados e ir evoluindo os estados até que, só ao final,

  3. terminar o programa exibindo o resultado.

Seguiremos esse padrão ao longo desse livro pois facilita a leitura, o entendimento e a manutenção do código.

4.5. Alternativas múltiplas#

Tipicamente, quando um programa aumenta de complexidade, o número de alternativas cresce. Por exemplo, além de aprovado ou reprovado, considere que um aluno pode também ficar de recuperação se sua nota estiver entre 3.0 e 5.0. Há várias formas de resolver esse problema. Vamos discutir por hora apenas a forma usando if-else aninhados para ilustrar outro recurso do Python para tornar a notação desses casos mais compacta e, portanto, mais simples de ler e manter.

Figura 4.3: Exemplo de uso de if-else aninhados para classificar um aluno

Fig. 4.3 Figura 4.3: Fluxogramas e pseudocódigo para classificar a situação de um aluno entre aprovado, reprovado e de recuperação.#

A figura 4.3 exibe um fluxograma e um pseudocódigo equivalente para classificar a situação de uma aluna como aprovada, reprovada ou de recuperação. Uma solução aninhando comandos if-else seria:

Como funciona esse trecho?

Observe com atenção a tabulação desse programa, que mostra um if-else na mesma coluna da linha 1 e, dentro do primeiro else, vemos um outro comando if-else. Por esse deslocamento sabemos que o segundo if só será testado caso a condição do primeiro if (da linha 3) seja falsa.

Vamos simular esse trecho usando 3 testes: nota 2 (que deve resultar em reprovado), nota 4 (que deve resultar em recuperação) e nota 7 que deve resultar em aprovado. Lembre-se de cobrir todas as alternativas ao definir seus testes.

Quando a nota é 7, a condição do primeiro if é verdadeira e assim o programa guarda que a situação do aluno é “aprovado”. Quando a condição do if é verdadeira o else correspondente não é executado, e o programa termina imprimindo “aprovado”, que é o valor associado à situação.

Quando a nota é 4, a condição do primeiro if é falsa e o bloco dentro do else correspondente (que está na mesma coluna desse if) é executado, ou seja, o segundo if-else é executado. Para isso a condição do if na linha 6 é testada, resultando em verdadeiro. O programa guarda que a situação do aluno é então de “recuperação”, o else correspondente não é executado e o programa termina imprimindo “recuperação”, que é o valor associado à situação.

Finalmente quando a nota é 2, a condição dos dois ifs é falsa e, nesse caso, o bloco dentro do segundo else (linha 8) é executado, associando o valor “reprovado” à variável situação. O programa passa para o final, imprimindo o resultado em situação.

4.5.1. Comando if-elif-else#

Para simplificar ainda mais o código de programas com if-else aninhados, o Python oferece o comando if-elif-else, cuja sintaxe é a seguinte.

if condição:
    # bloco contendo comandos a serem executados
    dentro_do_if_1
    dentro_do_if_2
    ...
    dentro_do_if_p

elif condição elif1:
    dentro_do_elif1_1
    dentro_do_elif1_2
    ...
    dentro_do_elif1_m1

elif condição elif2:
    dentro_do_elif2_1
    dentro_do_elif2_2
    ...
    dentro_do_elif2_m2

# outros possíveis blocos de elif, cada um com a sua condição

elif condição elifk:
    dentro_do_elifk_1
    dentro_do_elifk_2
    ...
    dentro_do_elifk_mk

else:                   # o else é opcional
    dentro_do_else_1
    dentro_do_else_2
    ...
    dentro_do_else_q

comando_apos_if

Ou seja, o if-elif-else pode ter um ou mais blocos com elif, cada um com a sua condição específica. Cada bloco (condição) é testado um de cada vez, até que uma condição seja satisfeita e apenas os comandos dentro desse bloco são executados. Quando nenhuma condição é satisfeita, os comandos dentro do else são executados. Assim, não é necessário que haja um else no final.

A figura 4.4 ilustra mostra como a contração de else-if como efif (em pseudocódigo estamos usando “senão-se”) pode tornar o código mais legível e portanto mais fácil de ler e entender. Como o Python desloca cada bloco de um tab, após vários tabs pode se tornar difícil ler o código que fica espremido no canto direito da página. O pseudocódigo também ilustra esse benefício de formatação e simplificação da leitura do código ao comparar o uso de else (senão) seguido de if (se) e de elif (senão-se junto).

Figura 4.4: Exemplo de uso de if-elif-else para classificar um aluno

Fig. 4.4 Figura 4.4: Fluxogramas e pseudocódigo para classificar a situação de um aluno entre aprovado, reprovado e de recuperação usando a contração “senão-se” (elif).#

Usando elif poderíamos escrever o algoritmo da figura 4.4 da seguinte forma:

O elif portanto é apenas uma contração do else if que torna mais claro o tratamento das várias alternativas, encadeando as condições. Blocos de elif podem ser repetidos várias vezes. Suponha por exemplo que gostaríamos de conhecer os alunos aprovados com louvor, ou seja, com nota superior a 9.0. Nesse caso, uma outra solução seria:

Faça os seus próprios experimentos com o trecho de código a seguir.

4.6. Exercícios#

Nessa seção de exercícios, procure desenhar sua solução usando fluxogramas antes de escrever o código em Python. Desenhar a solução e conseguir ver um mapa do fluxo da informação é uma ferramenta poderosa tanto para aprendizes, para desenvolver a habilidade de identificar e organizar essas estruturas, quanto para programadores avançados trabalhando em problemas complexos.

4.6.1. Exercício 1#

Escreva um programa que leia dois números inteiros e determina a soma dos pares. Por exemplo, para os números 6 e 7, como apenas o 6 é par, a soma deve ser 6. Para os número 1 e 3, o resultado deve ser zero e para 4 e 12, o resultado deve ser 16.

Dica: para resolver esse exercício utilize o operador “%”, que retorna o resto da divisão. Assim:

.. Exemplos de operações com %
1 % 3 é 1
2 % 3 é 2
3 % 3 é 0
4 % 3 é 1

4.6.2. Exercício 2#

Escreva um programa que leia 3 números inteiros e determinar quantos números da sequência são pares e quantos são ímpares. Por exemplo, para os números 1, 2 e 3, o resultado deve ser 1 par e 2 ímpares.

4.6.3. Exercício 3#

Escreva um programa que leia três números naturais e verifica se eles formam os lados de um triângulo retângulo. DICA Os números não precisam estar ordenados. Por exemplo, para os número 3, 5 e 4, a resposta deve ser sim, e para 8, 1, 6 a resposta deve ser não.

4.6.4. Exercício 4#

Escreva um programa que leia três números inteiros e os imprima em ordem crescente. Por exemplo, para os número 13, 7 e 4, a resposta deve ser 4, 7 e 13 e para 8, 9, 10 a resposta deve ser 8, 9 e 10.

4.7. Laboratório: perdendo o medo do Spyder#

O último laboratório introduziu o Spyder, o ambiente de desenvolvimento integrado (IDE) que adotamos nesse curso por ser aberto (Open Source), grátis e fácil de instalar. Ele na verdade vem junto com o Anaconda, um pacote que reúne, além do Sypder, vários módulos que facilitam o desenvolvimento de programas científicos em Python. Nesse laboratório vamos reforçar o uso do Spyder e aproveitar para ganhar ilustrar como linhas distintas de pensamento podem ser exploradas para criar várias soluções para um mesmo problema.

Se pudermos comparar “aprender a resolver problemas” com “aprender a andar de bicicleta”, muitas vezes o foco é na bicleta que vamos usar. Nessa metáfora, vamos considerar o ambiente de programação como a roupa que a gente precisa “vestir” para poder andar melhor de bicicleta, que ajudam nos ajudam a nos sentir confortáveis e seguros.

Assim como um roupa nova pode parecer justa ou apertada, como pode ser difícil de ajustar o cinto, ou como o capacete pode parecer um pouco pesado e desconfortável, toda ferramenta nova também cria um certo desconforto mas, depois que a gente consegue se acostumar e a roupa se ajusta na gente, o desconforto some, a confiança aumenta e permite que a gente se esqueça do traje e consiga focar em pedalar e, quem sabe, pensar e apreciar a paisagem.

Por isso, sugerimos que você use o Spyder para criar, digitar e executar vários programas nesse laboratório. Todos esses programas usam algoritmos distintos mas que produzem o mesmo resultado. Gostaríamos que vocês consigam ficar confortáveis o suficiente com o uso do Spyder para conseguirem pensar e apreciar todos os cheiros, cores e texturas de cada alternativa.

Mas para atingir esse estágio a gente vai precisar pedalar bastante. Nesse laboratório, procure digitar caractere a caractere os programas abaixo, ou seja, não use CTRL-C para copiar e CTRL-V para colar o programa no editor.

O Spyder é uma ferramenta bastante sofisticada que pode ajudar você de várias maneiras. Mesmo que você saiba digitar bem rápido, ao digitar várias programas você vai começar a entender e descobrir os recursos que o editor do Spyder lhe oferece. Aprenda a usar as teclas de aceleração como F5 para executar e CTRL-S para salvar o arquivo (embora algumas combinações dependam do seu sistema operacional), observe que o Python muda a cor de algumas palavras, procure entender o que cada cor significa, procure entender o que o Spyder tenta comunicar sobre o seu programa enquanto você está digitando. Aprenda a configurar o Spyder, modificando a cor de fundo, ou o tamanho da fonte, ou usando um tema diferente para todo o ambiente.

É natural ter um pouco de medo de usar algo complexo e sofisticado, mas quanto mais você usar, mais você vai se sentir confortável e leve usando o Spyder e, quem sabe, até se divertir um pouco!).

4.7.1. Exercício: classifique um ponto como dentro ou fora#

Esse exercício foi baseado na questão 1 da Prova 1 de 2014 da disciplina MAC2166, criada pelo [Prof. Arnaldo Mandel](https://www.ime.usp.br/~am).

Use o Spyder para escrever um programa que lê as coordenadas cartesianas (x, y) de um ponto, ambas do tipo float e imprime dentro se esse ponto está na região, e fora caso contrário. A região sombreada não inclui as bordas, ou seja, pontos nas bordas de uma região estão fora.

Note que o eixo y cai bem no meio da figura, e usamos o lado do quadrado para indicar as ordenadas correspondentes.

Figura 4.5: exercício pra classificar os pontos da região sombreada.

Fig. 4.5 Figura 4.5: exercício pra classificar os pontos da região sombreada. Pontos sobre as bordas deem ser considerados fora.#

Para a sua conveniência, você pode executar cada solução abaixo usando o CodeLens. Mesmo assim, digite cada solução no seu computador para “perder o medo” do Spyder.

4.7.2. Solução 0#

Essa solução começa supondo que está dentro e realiza testes para verificar se o ponto está fora. A variável dentro é uma variável de estado do tipo bool, também chamada de bandeira (flag).

4.7.3. Solução 1#

Essa solução começa supondo que está fora e depois… A variável dentro é uma variável de estado do tipo bool, também chamada de bandeira (flag).

4.7.4. Solução 2#

explora a simetria da figura em relação ao eixo y. A variável x_pos pode ser trocada por x. A variável dentro é uma variável de estado do tipo bool, também chamada de bandeira (flag).

4.7.5. Solução 3#

Essa solução é idêntica a anterior, explora a simetria da figura em relação ao eixo y e utiliza um string para a armazenar resposta. A variável x_pos pode ser trocada por x. A variável dentro é uma variável de estado do tipo str.

4.7.6. Solução 4#

Essa solução utiliza uma variável bool para indicar em qual parte da face está o ponto: face, boca olho direito, olho esquerdo, íris do olho direito, íris do olho esquerdo. A condição para decidir se o ponto está ou não na região sombreada pode parecer complicada, mas é bem elegante e é um excelente exercício para treinar expressões lógicas.

4.7.7. Solução 5#

Essa solução é idêntica a anterior, mas explora a simetria como na solução 3.

4.8. Onde chegamos e para onde vamos?#

Nesse capítulo introduzimos os comandos if if-else que são usados para controlar o fluxo da computação, permitindo que certos trechos de código sejam executados condicionalmente. As condições devem ser o resultado de uma expressão lógica ou relacional.

O entendimento de problemas tipicamente exige um modelamento que organiza os dados em classes, como dentro ou fora, alto ou baixo, aprovado, reprovado ou de recuperação, etc. Ao longo do curso vamos resolver mais exercícios para desenvolver essa habilidade de reconhecer padrões que facilitam o desenolvimento de soluções.

Como primeira estratégia para começar a pensar nos algoritmos, vimos que começar assumindo um estado inicial traz benefícios e facilita nosso pensando a focar nas condições que devem ocorrer para que o programa calcule o estado correto. No laboratório, vimos uma solução (algoritmo) pode ser mais ou menos complexa dependendo desse estado inicial. Portanto, antes de você se decidir por escrever um programa que implementa algum algoritmo, é sempre bom considerar outros algoritmos. Uma forma simples é trocar a condição inicial (como assumir que o ponto está dentro ou fora) e explorando as implicações dessas condições e alternativas.

O grande poder da computação, no entanto, vem de sua capacidade de executar as mesmas instruções milhares e milhares de vezes, rapidamente, repetidamente, sem se cansar e sempre com a mesma qualidade. Esse poder é expresso pelos comandos de repetição que permitem executar um bloco de comandos de novo, e de novo, e de novo…

O próximo capítulo introduz outro fundamento que revela