<!--
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>
<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>
<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 < 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> </td><td style="border-right: solid 1px #000000;"></td><td> </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> </td><td style="border-right: solid 1px #000000;"></td><td> </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> </td><td style="border-right: solid 1px #000000;"></td><td> </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> && </td><td> and </td>
<td> (n1 > 1 && n1 < 10) </td><td> (n1 > 1 and n1 < 10) </td></tr>
<tr><td>disjunção (<tt>ou</tt>)
</td><td> || </td><td> or </td>
<td> (n1 > 1) || (n1 < 10) </td><td> (n1 > 1) or (n1 < 10) </td></tr>
<tr><td>negação (<tt>não</tt>) </td><td> ! </td><td> not </td>
<td> !(n1 > 1 || n1 < 10) </td><td> not(n1 > 1 or n1 < 10) </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<b) { <cyan>// este exemplo nao trata todos os casos...</cyan>
if (b<c) <verm>printf</verm>("O menor e': %d\n", a);
}
else if (b>=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<b) : <cyan># este exemplo nao trata todos os casos...</cyan>
if (b<c) : <verm>print</verm>("O menor e': %d" % a);
elif (b>=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<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>