intr_prog/introducao_if.html

<!--
 Introducao `a Programacao - desde 2017 - Prof. Leo^nidas de Oliveira Branda~o
 Introdução ao comando de seleção e às expressões lógicas
 LInE (Laboratory of Informatics in Education) - http://www.usp.br/line
 IME - USP
 Material dida'tico
 Pode usar livrevemente este material para fins nao comerciais, devendo sempre fazer referencia `a autoria.
 Sugestoes/apontamento são bem vindos: leo@ime.usp.br (favor indicar no assunto "Material de introducao 'a programacao")
 Autoria: Prof. Leo^nidas de Oliveira Branda~o
 http://www.ime.usp.br/~leo
 http://line.ime.usp.br
 http://www.matemtica.br
-->

  <meta http-equiv='Content-Type' content='text/html; charset=UTF-8'>
  <meta name='keywords' content='mac0122, material, professores, leonidas de oliveira brandao'>
  <link rel='stylesheet' type='text/css' href='css_img_js_conf/all.css'>
  <link rel='stylesheet' type='text/css' href='css_img_js_conf/line_introducao_programacao.css'>
  <script src="css_img_js_conf/defineLInE.js"></script> <!-- para referencias 'a documentos internos -->
<div class="pagina">

<p class="secao">Introdução ao comando de seleção e às expressões lógicas</p>

<center><p>[
 <a href="#explog" title="Expressão e valor lógico em C">Expressão em C</a> |
 <a href="#exp-py" title="Expressão e valor lógico em Python">Expressão em Python</a> | 
 <a href="#oper" title="Operadores lógicos">Operadores</a> | 
 <a href="#if-else" title="Comando de seleção">Seleção</a> | 
 <a href="#if-else-varios" title="<i>if-else</i> aninhados">Seleções</a> | 
 <a href="#par-impar" title="decidir se par ou ímpar">Exemplo</a> | 
 <a href="#divint" title="por que par">Par ou ímpar</a>
 ]</p>
</center>

&nbsp;<br/>

<p>
<table style="border: 1px solid black;"><tr><td>
<b>Como ler este texto</b>.
Aqui procuro explicar os fundamentos do comando de seleção <tt>if-else</tt> tanto para as linguagens <i>C</i> quanto <i>Python</i>.
Em várias seções apresento os conceitos básicos ilustrando-os em tabelas, com uma coluna ou linha para cada linguagem.
Mas existe uma seção em que apresento o conceito de expressão lógica separandamente, assim, se lhe interessar
apenas uma das linguagens, leia apenas a seção correspondente.
</td></tr></table>
</p>

&nbsp;<br/>

<p>
Na seção sobre 
<a href="#" onclick="trocaPagina('introducao_var.html')" title="examinar introducao as variaveis">variáveis</a>, ressaltamos a importância de
poder variar os valores armazenados em determinada posição de memória, por intermédio das <i>variáveis</i>.
</p>

<p>
Entretanto se não fosse possível executar uma ação específica apenas quando determinada condição ocorrer,
de acordo com o valor de algumas variáveis, não se poderia fazer muito com o computador.
Isso pode ser feito efetuando-se uma conta e verificando se o resultado é nulo ou não, sendo nulo segue-se
determinado "caminho" no código e em caso negativo, segue-se outro (executa outros comando).
</p>

<p>
Mas a explicação acima está quase ao nível do <i>hardware</i>, portanto <b>baixo-nível</b>.
De um ponto de vista mais elevado (<b>alto-nível</b>), as linguagens de programação como <i>C</i> e <i>Python</i>
dispõem de um comando que permite tal <b>seleção</b> de <b>caminho de execução</b> é o comando <b><tt>if-else</tt></b>.
</p>

<p>
  A figura 1.a e 1.b ilustram o <b style="color:#0000aa;">desvio do fluxo de execução</b> de acordo com o resultado da <b>condição</b>,
  do resultado da <b>condição lógica</b>, se <b style="color:#00aa00;">verdadeiro</b> segue o caminho indicado pela seta com rótulo <b>sim</b> e
  se <b style="color:#00aa00;">falso</b> segue outro.
  Adicionalmente, nota-se que o comando de <i>seleção</i> (ou <i>desvio de fluxo</i>) pode explicitar um caminho para o caso
  da expressão lógica resultar <i>falso</i>, figura 1.b, ou simplesmente apresentar o caminho no caso de <i>verdadeiro</i>, na figura 1.a.
  <center>
    <img src="img/pt_fluxo_se.png" title="Ilustração do desvio de fluxo com comando de seleção sem opção de 'senão'" width="250px"/><!-- 339 x 487 -->
    <img src="img/pt_fluxo_se_senao.png" title="Ilustração do desvio de fluxo com comando de seleção COM opção de 'senão'" width="445px" /><!-- 583 x 422 -->
    <br/>
    <i>Fig. 1. Diagrama de fluxo de execução (a) sem o ramo de <i>senão</i> e (b) com o ramo de <i>senão</i> .</i>.
  </center>
</p>


<p>
<a name="explog"><span class="subsecao">Expressão lógica em <i>C</i></span></a>
</p>

<p><!-- <b>Expressões lógicas em <i>C</i></b>-->
Na linguagem <i>C</i>, qualquer expressão (mesmo que aritmética) dentro de abre e fecha parênteses <tt>(...)</tt> é
interpretado como uma <i>expressão lógica</i>, como nos dois exemplos de comandos abaixo:
<center><table><tr><td>
 <pre>if (a==b) <verm>printf</verm>("%d == %d\n", a, b);
while (i &lt; N) { <verm>printf</verm>("i = %d\n", i); i++; }</pre></td></tr></table>
<i>Cód. 1. Exemplos de expressão lógica em <i>C</i></i>.
</center>
</p>

<p>
Ou seja, o tratamento de expressões é mais um exemplo de que o <i>contexto</i> pode mudar a forma como os dados
são interpretados.
</p>

<p>
Mas vale a pena notar que a linguagem <i>C</i> permite construções cujo processamento é uma pouco mais rápido, mas menos intuitivo,
é permitido usar qualquer expressão aritmética (como <tt>a-b</tt>) dentro do contexto de expressão lógica!
Isso é possível a partir do seguinte "truque":
 calcula-se o resultado da expressão aritmética,
 se o seu resultado for diferente de <i>0</i>, ele é interpretado como sendo o valor lógico <i>verdeiro</i>,
 caso contrário como <i>falso</i>.
Desse modo, no comando seguinte, sempre que a variável inteira <i>N</i> tiver valor não nulo,
será "impresso" <i>OK</i> e se o valor for nulo será "impresso" <i>NAO</i>:
<center>
  <tt>if (N) <verm>printf</verm>("OK\n"); else <verm>printf</verm>("NAO\n");</tt>.
  <br/>
  <i>Cód. 2. Exemplos de expressão aritmética tratada como expressão lógica em <i>C</i></i>.
</center></p>

</p>
<b>Negação em <i>C</i></b>. 
Pode-se usar o operador <tt>!</tt> (exclamação) para <i>negar</i> o resultado da expressão lógica (que esteja à sua direita).
Por exemplo, os seguintes trechos de código são equivalentes em <i>C</i>:<br/>
<center><table><tr><td>
 <table><tr><td>
  <tt><!-- varlog = a == b; // ou: varlog = (a == b)<br/>-->
  if (a==b) <verm>printf</verm>("OK");<br/>
  else <verm>printf</verm>("NAO");</tt></td></tr></table></td>
 <td>&nbsp;&nbsp;</td><td style="border-right: solid 1px #000000;"></td><td>&nbsp; &nbsp;</td>
 <td><table><tr><td>
  <tt><!--varlog = (a - b); // ou: varlog = a - b<br/>-->
  if (!(a-b)) <verm>printf</verm>("OK");<br/>
  else <verm>printf</verm>("NAO");</tt></td></tr></table>
  </td></tr></table>
 <i>Cód. 3. Exemplos de uso de negação em expressão lógica em <i>C</i></i>.
 </center>
</p>


<p>
Fica fácil entender a razão dos dois códigos serem equivalente ao observarmos que
<i>a == b</i> é a mesma coisa que <i>a - b == 0</i> e, usando a negação,
<i>a != b</i> é a mesma coisa que <i>a - b != 0</i> e essa última expressão equivale à expressão
<i>!((a - b) == 0)</i> (negar que <i>(a - b) == 0</i>).
</p>

<p>
Portanto, a expressão <tt>a-b</tt> é interpretada como expressão lógica, do seguinte modo:
seu resultado é <i>verdadeiro</i> se, e somente se <tt>a-b!=0</tt> (<tt>a-b</tt> não nulo),
por isso usamos a negação para inverter o resultado, ou seja, <tt>!(a-b)</tt> equivale a negar <tt>a-b</tt>
(e portanto negar <tt>a-b!=0</tt>).
</p>

<p><porque>
  <b>Atenção <i>programadores <i>C</i></i></b>, um <b style="color:#aa0000;">erro bastante comum</b> ao tentar
  usar o operador relacional <tt>==</tt> é acabar <b style="color:#aa0000;">digitando apenas <tt>=</tt></b>.
  Em função da explicação acima, não existe qualquer erro sintático, o código será gerado, mas ao rodar, pode
  ser muito difícil detectar esse <b>erro semântico</b>.
  <br/>
  O resultado de um comando como <tt>if (a=b) <verm>printf</verm>("Sao iguais\n");</tt> é que,
  se <tt>a</tt> estiver com qualquer valor diferente de zero, a mensagem será impressa.
  <br/>
  Para descobrir este tipo de erro uma boa técnica é usar 
  <a href="#" onclick="trocaPagina('introducao_depuracao_codigos.html#bandeiras')" title="Examinar texto sobre depuração de código">bandeiras</a>.
</porque></p>


<p>
<a name="exp-py"><span class="subsecao">Expressão e valor lógicos em <i>Python</i></span></a>
</p>

<p><!-- <b>Expressões lógicas em <i>Python</i></b>-->
Em <i>Python</i> existem um particular tipo de variável que é <i>booleano</i>, sendo que uma
variável boleana pode ter apenas os valores: <i>True</i> e <i>False</i>.
</p>

</p>
Assim, uma expressão lógica em <i>Python</i> deve sempre resultar nos valores lógicos
<i>True</i> ou <i>False</i>. Deste modo os três blocos de comandos abaixo podem ser usados e são
equivalente, entretanto o primeiro (mais à esquerda) é mais eficiente:<br/>
<center><table style="font-size:0.8em;"><tr><td>
 <table><tr><td>
  <tt>varlog = a == b <cyan># ou: varlog = (a == b)</cyan><br/>
  if (varlog) : <verm>print</verm>("OK")<br/>
  else : <verm>print</verm>("NAO")</tt></td></tr></table></td>
 <td>&nbsp;&nbsp;</td><td style="border-right: solid 1px #000000;"></td><td>&nbsp;&nbsp;</td>
 <td><table><tr><td>
  <tt>varlog = (a == b) <cyan># ou: varlog = a == b</cyan><br/>
  if (varlog == True) : <verm>print</verm>("OK")<br/>
  else : <verm>print</verm>("NAO")</tt></td></tr></table>
 <td>&nbsp;&nbsp;</td><td style="border-right: solid 1px #000000;"></td><td>&nbsp;&nbsp;</td>
 <td><table><tr><td>
  <tt>varlog = (a == b) <cyan># ou: varlog = a == b</cyan><br/>
  if (not (varlog == False)) : <verm>print</verm>("OK")<br/>
  else : <verm>print</verm>("NAO")</tt></td></tr></table>
  </td></tr></table>
 <i>Cód. 4. Exemplos de uso de negação em expressão lógica em <i>C</i></i>.
</center>
</p>

<p>
Note que no exemplo acima mais à direita usamos <tt>not (varlog == False)</tt> que equivale a <tt>varlog == True</tt>, que portanto também
equivale a <tt>varlog</tt> (pois está armazenando valore booleanos).
</p>


<a name="oper">
  <p class="secao">Operadores lógicos em <i>C</i> e em <i>Python</i></p>
</a>

<p>
Os operadores lógicos e relacionais básicos são os mesmo tanto em <i>C</i> quanto em <i>Python</i>.
Os <b>operadores relacionais</b> (<i>relações entre expressões aritméticas</i>) são:
</p>

<center>
 <i>Tab. 1. Tabela dos operadores relacionais.</i> 
  <table class="tdR">
  <tr><th style="background-color:#8aaada;">Operação</th><th style="background-color:#8aaada;">Operador <th style="background-color:#8aaada;">Exemplo</th></tr>
  <tr><td>iguais        </td><td> ==          <td> n1 == 4                        </td></tr>
  <tr><td>diferentes    </td><td> !=          <td> n1 != 4                        </td></tr>
  <tr><td>maior         </td><td> >           <td> n1 > n2                        </td></tr>
  <tr><td>menor         </td><td> <           <td> n2 < n1                        </td></tr>
  <tr><td>maior ou igual</td><td> >=          <td> n1 >= 3                        </td></tr>
  <tr><td>menor ou igual</td><td> <=          <td> n1 <= 33                       </td></tr>
</table>
</center>
<br/>


<p>
Os <b>operadores lógicos</b> principais em <i>C</i> e em  <i>Python</i> são
<center>
  <i>Tab. 2. Tabela dos operadores lógicos em <i>C</i> e em <i>Python</i>.</i>
  <table class="tdR" style="border: 1px solid black;">
  <tr><th style="background-color:#8aaada;border-right: 1px solid black;">Operação </th>
    <th style="background-color:#8aaada;border-right: 1px solid black;" colspan="2">Operador </th>
    <th style="background-color:#8aaada;" colspan="2">Exemplo</th></tr>
  <tr><th style="background-color:#8aaada;border-right: 1px solid black;"></th>
    <th style="background-color:#8aaada;align:center;">C</th>
    <th style="background-color:#8aaada;align:center;border-right: 1px solid black;">Python</th>
    <th style="background-color:#8aaada;align:center;">C</th>
    <th style="background-color:#8aaada;align:center;">Python</th></tr>
  <tr><td>conjunção (<tt>e</tt>)         </td><td> &nbsp; &nbsp; && &nbsp; &nbsp;              </td><td>&nbsp; &nbsp;and &nbsp; &nbsp; </td>
      <td> &nbsp; (n1 &gt; 1 && n1 &lt; 10) &nbsp;   </td><td> &nbsp; (n1 &gt; 1 and n1 &lt; 10) &nbsp;    </td></tr>
  <tr><td>disjunção (<tt>ou</tt>)   &nbsp; &nbsp;
                                                     </td><td> &nbsp; &nbsp; || &nbsp; &nbsp;              </td><td>&nbsp; &nbsp; or &nbsp; &nbsp; </td>
     <td> &nbsp; (n1 &gt; 1) || (n1 &lt; 10)  &nbsp; </td><td> &nbsp; (n1 &gt; 1) or (n1 &lt; 10) &nbsp;   </td></tr>
  <tr><td>negação (<tt>não</tt>)         </td><td> &nbsp; &nbsp; !  &nbsp; &nbsp;              </td><td>&nbsp; &nbsp; not &nbsp; &nbsp; </td>
     <td> &nbsp; !(n1 &gt; 1 || n1 &lt; 10) &nbsp;   </td><td> &nbsp; not(n1 &gt; 1 or n1 &lt; 10)  &nbsp; </td></tr>
  </table>
</center>
</p>


<a name="if-else">
  <p class="secao">Comando de seleção <tt>if-else</tt> em <i>C</i> e em <i>Python</i></p>
</a>

<p>
  O <b>comando de seleção</b> é essencial para qualquer <i>software</i>, é ele que permite que o programa desvie seu fluxo de execução de acordo com
  os valores dos dados (as já citadas <i>variáveis</i>).
  Ele está presente em qualquer linguagem de programação e está baseado no cômputo de uma <i>expressão lógica</i> (<b>EXPLOG</b>),
  se o resultado dela for <i>verdadeiro</i>, o fluxo segue por um "caminho",
  senão segue por outro.
  Essa estrutura está ilustrada na figura abaixo:
  <center>
    <img src="img/comando_selecao_expr_logica.jpg" title="imagem ilustrando fluxo de execucao com comando de selecao" width="400" height="325"/>
    <br/>
    <i>Fig. 2. Diagrama de fluxo de execucação do comando de seleção.</i>    
  </center>
</p>

<p>
  Existem outras duas características de comando de seleção (em qualquer linguagem) que são:
  <ol>
    <li>permitir a execução de comandos mutuamente exclusivo, ou seja, se a expressão lógica resultar verdadeira executa-se determinado comando,
      senão executa-se outro comando ("comando alternativo") - mas a existência do "senão" é opcional;</li>
    <li>possível subordinar mais de uma instrução ao comando "se" ou ao comando "senão", 
      mas cada linguagem tem a sua sintaxe particular para isso (marcadores '{' e '}' em <i>C</i> e alinhamento em <i>Python</i>).</li>
  </ol>
</p>

<p>
  Tanto a linguagem <i>C</i> quanto na linguagem <i>Python</i>, usam as masmas <i>palavras reservadas</i> (palavras que <i>não</i>
  podem ser usados como nomes para variáveis): as palavras <tt>if</tt> e o <tt>else</tt>. A sintaxe de ambas é ilustrada na
  tabela abaixo.
</p>

<p>
  Além disso, as linguagens <i>C</i> e <i>Python</i> permitem que vários comandos (<b>bloco de comandos</b>) sejam subordinados à
  uma seleção.
  Em <i>C</i> deve-se usar abre e fecha chaves (<tt>{...}</tt>) para delimitar os blocos,
  enquanto que na linguagem <i>Python</i> isso é feito com o deslocamento horizontal de linhas, ou seja, com "<b>indentação</b>".
</p>

<p>
  A tabela a seguir ilustra a sintaxe do comando de seleção tanto em <i>C</i> quanto em <i>Python</i>:
</p>


<center>
  <i>Tab. 3. Comandos de seleção em <i>C</i> e em <i>Python</i>.</i>
  <table >
  <tr><th style="background-color:#8aaada;border: solid 1px #000000;">Linguagem </th>
    <th style="background-color:#8aaada;border: solid 1px #000000;">Apenas 1 comando </th>
    <th style="background-color:#8aaada;border: solid 1px #000000;">Vários comandos</th></tr>
  <tr><td style="border: solid 1px #000000;">C<br/><br/><br/><br/>     </td>
    <td style="border: solid 1px #000000;"><pre> if (EXPR) comando1;<br/> else comando2;<br/><br/><br/></pre></td>
    <td style="border: solid 1px #000000;"><pre> if (EXPR) { comando1;<br/>   comando2; }<br/> else { comando3;<br/>   comando4; }</pre></td></tr>
  <tr style="border-top:1px solid black;">
    <td style="border: solid 1px #000000;">Python<br/><br/><br/><br/><br/><br/></td>
    <td style="border: solid 1px #000000;"><pre> if (EXPR) : comando1;<br/> else : comando2;<br/><br/><br/><br/><br/></pre></td>
    <td style="border: solid 1px #000000;"><pre> if (EXPR) :<br/>   comando1;<br/>   comando2;<br/> else :<br/>   comando3;<br/>   comando4;</pre></td></tr>
</table></center>
<br/>

<p>
  Vale destacar que o comando <tt>else</tt> é opcional (como já citado), ou seja, não existindo ação a ser executada caso
  a condição seja falsa, não é necessário usar um <tt>else</tt> com algum comando.
  Assim é correto em <i>C</i> escrever <tt>if (1==1) <verm>printf</verm>("ok");</tt> e
  escrever <tt>if (1==1) : <verm>print</verm>("ok")</tt> em <i>Python</i>. 
</p>

<p>
  Em <i>Python</i> os parênteses não são obrigatórios em expressões, quer dizer é válido redigir o comando
  <tt>if n1==n2 : comando1</tt> (assim como <tt>if (n1==n2) : comando1</tt>).
  Deste modo para o interpretador <i>Python</i> conseguir traduzir corretamente o comando, lançou-se mão dos dois pontos para indicar final
  de expressão (<tt>if EXPR :</tt>) e no <tt>else</tt>, e por uniformidade, os <tt>:</tt> também é obrigatório no <tt>else :</tt>.
</p>

<p>
  Outro item em que <i>C</i> e <i>Python</i> diferem é no modo como indicam a existência de um bloco de comandos
  subordinados a outro comando. Em <i>C</i> utiliza-se abre e fecha chaves, enquanto em <i>Python</i> usa-se a "indentação".
  Experimente em <i>Python</i> eliminar o deslocamento horizontal e deixe, e.g., o <tt>comando1</tt> alinhado com o <tt>if</tt>
  e tente rodar o programa. Você receberá uma mensagem de erro.
</p>


<a name="if-else-varios">
  <p class="secao">Comandos de seleção <tt>if-else</tt> aninhados em <i>C</i> e em <i>Python</i></p>
</a>

<p>
  Em geral, toda linguagem de programação de alto-nível permite que os comandos <tt>if-else</tt> sejam utilizados
  de modo aninhado, ou seja, qualquer dos <tt>comando1</tt> acima podem ser um novo <tt>if-else</tt>. Por exemplo:
  <center>
    <i>Tab. 4. Comandos de seleção aninhados em <i>C</i> e em <i>Python</i>.</i>    
    <table class="tdR">
   <tr><th style="background-color:#8aaada;">Linguagem</th><th style="background-color:#8aaada;">if aninhado</th></tr>
   <tr><td>C<br/><br/><br/><br/><br/>     </td><td>
<pre>if (a&lt;b) { <cyan>// este exemplo nao trata todos os casos...</cyan>
  if (b&lt;c) <verm>printf</verm>("O menor e': %d\n", a);
  }
else if (b&gt;=c)
  <verm>printf</verm>("O maior e': %d\n", a);</pre></td></tr>
   <tr style="border-top:1px solid black;">
      <td>Python<br/><br/><br/><br/> </td> <td>
<pre>if (a&lt;b) : <cyan># este exemplo nao trata todos os casos...</cyan>
  if (b&lt;c) : <verm>print</verm>("O menor e': %d" % a);
elif (b&gt;=c) : <cyan># usar "elif" para economizar "indentacao"</cyan>
  <verm>print</verm>("O maior e': %d" % a);</pre></td></tr>
 </table></center>
<br/>

  
</p>

<p>
  Note que a regra para associar um "else" a um "if" é por proximidade (o "else" é associado ao "if" mais próximo),
  e em caso que precisamos que o "else" seja associado a um "if" mais longe, somos obrigados a usar os blocos de comandos.
  Isso está ilustrado nos exemplos acima, o primeiro "else" está associado ao <tt>if (a&lt;b)</tt> e não ao mais "próximo".
</p>


<a name="par-impar">
  <p class="subsecao">Um exemplo para decidir se uma variável inteira armazena um valor par ou ímpar</p>
</a>

<p>
Utilizando a divisão inteira (quer dizer <tt>7/2</tt> resultando <tt>3</tt>) pode-se conseguir determinar se um inteiro
é ou não par. Nos códigos abaixo ilustramos este método, mas note que existe uma diferença sensível entre as versões
<i>Python 2</i> e <i>Python 3</i>, este último obriga o uso de "duas barras" (<tt>//</tt>) para indicar divisão inteira.
Vejamos os códigos abaixo:
</p>

<center>
  <i>Tab. 5. Exemplo de expressão aritmética em expressão lógica para decidir se valor é par em <i>C</i> e em <i>Python</i>.</i>      
  <table class="tdR">
  <tr><th style="background-color:#8aaada;"><i>C</i></th>
  <th style="background-color:#8aaada;"><i>Python 2</i></th>
  <th style="background-color:#8aaada;"><i>Python 3</i></th></tr>
  <tr>
    <td><pre>if (n1/2*2==n1)
  <verm>printf</verm>("%d eh par\n", n1);
else
  <verm>printf</verm>("%d eh impar\n", n1);</pre></td>
    <td><pre>if (n1/2*2==n1) :
   <verm>print</verm>(n1, " eh par\n")
else :
   <verm>print</verm>(n1, " eh impar\n")</pre></td>
    <td><pre>if (n1//2*2==n1) :
   <verm>print</verm>(n1, " eh par\n")
else :
   <verm>print</verm>(n1, " eh impar\n")</pre>
</td></tr></table></center>
<br/>

<p>
Mas pode-se obter o mesmo resultado utilizando o operador binário <tt>%</tt> que é "resto da divisão inteira".
Este operador devolve o resto da divisão, por exemplo, <tt>7%2</tt> resulta <tt>1</tt> (o quociente é 
<tt>3</tt>: <tt>3 * 2 + 1 = 7</tt>).
Assim o código fica:
</p>

<center>
  <i>Tab. 6. Exemplos de comandos para decidir se valor é ímpar ou par em <i>C</i> e em <i>Python</i>.</i>      
  <table class="tdR">
  <tr><th style="background-color:#8aaada;"><i>C</i></th>
  <th style="background-color:#8aaada;"><i>Python</i></th></tr>
  <tr>
    <td><pre>if (n1%2==0)
   <verm>printf</verm>("%d eh par\n", n1);
else
   <verm>printf</verm>("%d eh impar\n", n1);</pre></td>
    <td><pre>if (n1%2==0) :
   <verm>print</verm>(n1, " eh par\n")
else :
   <verm>print</verm>(n1, " eh impar\n")</pre>
</td></tr></table></center>
<br/>


<a name="divint">
<p class="subsecao">Mas por que razão "n1/2*2==n1" é suficiente para decidir se n1 é ou não par?</p>
</a>

<p>
Bem, isso é um <i>truque computacional</i> baseado em como o computador interpreta e trata os valores numéricos
de acordo com seu tipo. Quanto todos os valores (variáveis) são inteiros, é utilizada uma aritmética de precisão inteira,
como examinamos ao final da seção sobre
<a href="#" onclick="trocaPagina('introducao_var.html')" title="seguir para o texto sobre variáveis">variáveis e expressões</a>.
</p>

<p>
Lembre-se que em <i>C</i> sempre que fizer divisão entre inteiros o resultado é inteiro (ou seja, <tt>7/2</tt> resulta <tt>3</tt>) e
em <i>Python</i> é análogo, entretanto no <i>Python 3</i> é preciso usar o operador <tt>//</tt> (<tt>7/2</tt> resulta erro, deve-se
usar <tt>7//2</tt>) e no <i>Python 2</i> pode-se usar <tt>7/2</tt> (resultando <tt>3</tt>).
</p>

<p>
Novamente é o contexto determinando o resultado.
</p>

  <p class="autoria">
    <a href="https://www.ime.usp.br/~leo" target="_blank" title="seguir para a pagina do prof. Leônidas">Leônidas de Oliveira Brandão</a><br/>
    <a href="http://www.ime.usp.br/~leo" target="_blank" title="seguir para a página do LInE">http://line.ime.usp.br</a>
  </p>

<p class="rodape">
<b>Alterações</b>:<br/>
  2020/08/20: revisado formato, pequenas correções;<br/>
  2020/08/10: novo formato, pequenas correções;<br/>
  2019/06/06: vários pequenos acertos;<br/>
  2019/01/13: pequenas melhorias de frases e mudanca no CSS<br/>
  2018/04/16: pequenos acertos<br/>
  2018/03/28: melhorado quadro de operadores lógicos <i>C</i> e <i>Python</i>, reescrita a seção "Comandos de seleção ao if-else aninhados em C e em Python"<br/>
  2017/04/14: adicionados novos itens (como <tt>True/False</tt> e <tt>//</tt> do <i>Python</i> e <tt>%</tt> <i>C</i> e <i>Python</i>)
</p>

</div>