<!--
Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
Introdução às variáveis e expressões aritméticas
LInE (Laboratory of Informatics in Education) - http://www.usp.br/line
IME - USP
Material didático
Pode usar livrevemente este material para fins não comerciais, devendo sempre fazer referência à autoria.
Sugestões/apontamento são bem vindos: leo@ime.usp.br (favor indicar no assunto "material de introducao 'a programacao")
Prof. Leônidas de Oliveira Brandã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'>
<div class="pagina">
<center><p>[
<a href="#paraque" title="seguir para para que serve variaveis">Utilidade</a> |
<a href="#memoria" title="seguir para sobre memoria, bits e bytese">Memória</a> |
<a href="#variaveis" title="seguir para variaveis inteiras e reais">Variáveis</a> |
<a href="#expressoes" title="seguir para expressões aritméticas">Expressões</a> |
<a href="#contexto" title="seguir para resultado de uma expressão depende do contexto">Contexto</a>
]</p>
</center>
<p class="secao">Introdução às variáveis e expressões aritméticas</p>
<p>
Nesta seção apresentarei o conceito de variáveis e de expressões aritméticas.
Esses são conceitos essenciais para a construção de algoritmos, sem eles seria inviável produzir
um <b style="color:#0000aa" title="Por exemplo, o oposto seria um algoritmo que sempre dividisse 10 por 3, portanto pouquísso útil!"
>algoritmo flexível</b>, que pudesse ser aplicado sobre dados distintos
(e.g., o algoritmo da soma é flexível no sentido de podermos somar diferentes valores, não apenas 2 valores fixados).
</p>
<a name="oque">
<p class="secao">O que é uma variável?</p>
</a>
<p>
Uma explicação simples, para não especialistas em programação, é que
uma <b>variável</b> é um <i>nome</i> quer pode ser associado à diferentes valores.
Esse nome usualmente começa
com uma letra, sendo composto por letras e números.
</p>
<p>
Usualmente, em qualquer linguagem de programação, sempre que usamos em um código uma variável, significa que deve-se pegar o valor armazenado nesta variável.
Assim, um trecho com <tt>10*b</tt>, implica em pegar o valor corrente armazenado na variável <tt>b</tt> e
multiplicá-lo por <tt>10</tt>.
</p>
<p>
Mas como o nome sugere, deve ser possível <b>alterar o valor armazenado em uma variável</b>, isso é feito por uma instrução de <i>atribuição</i>.
Pode-se <b style="color: #0000aa">atribuir</b> um valor à uma variável, como nos exemplos:
<ul>
<li><codigo1>i = 0</codigo1> significa que a variável de nome <i>i</i> (neste ponto do código) estará guardando o valor inteiro <i>0</i>;</li>
<li><codigo1>fat = i*fat</codigo1> é exemplo mais "sofisticado", significa que a variável de nome <i>fat</i> deve receber o valor que
anteriormente (à este comando) era guardado em <i>fat</i> multiplicado pelo valor guardado na variável <i>i</i>.
</ul>
<center>
<img src="img/img_intr_var_1.png" title="Ilustração de atribuição às variáveis i e fat"/>
<br/>
<i>Fig. 1. Variáveis <i>i</i> e <i>fat</i> recebendo valores (constante e expressão).</i>
<!-- i ⬅ 0 -->
</center>
Note que o símbolo "<i>=</i>" <b style="color: #aa0000">não</b> tem o sentido usual da Matemática, em boa parte das linguagens de programação
"<tt>var = EXPRESSAO</tt>" significa que
<i>deve-se computar o valor da expressão no <b style="color: #0000aa">lado direito da atribuição</b>
e depois atribuir este valor à variável de nome <i>var</i></i>.
Isso fica mais claro no segundo exemplo "<tt>fat = i*fat</tt>".
<br/>
Por isso diz-se que <b style="color: #0000aa">var recebe EXPRESSAO</b>.
</p>
<p>
As linguagens que usam <i>=</i> como atribuição, usam <i>==</i> (dois símbolos de igualdade) para comparar valores.
Um exceção é a linguagem
<a href="https://en.wikipedia.org/wiki/Pascal_%28programming_language%29"
title="ver na WikiPedia - a versão em Portuguès não está bo (em agosto de 2020">Pascal</a>
que usa <i>:=</i> para atribuição e <i>=</i> para comparações.
<!-- https://pt.wikipedia.org/wiki/Pascal_%28linguagem_de_programa%C3%A7%C3%A3o%29 -- texto está ruim... -->
</p>
<a name="maissobre">
<p class="secao">Sabendo um pouco mais sobre o que é uma variável</p>
</a>
<p>
Uma <b>variável</b> um conceito comum na Matemática e presente em todas as linguagens de programação, que de uma forma implementa o conceito.
<b>Variável</b> é a associação de uma posição específica de <i>memória</i> do computador a um nome, que geralmente
<b style="color:#a00;">não</b> pode ser um nome de comando da linguagem (<b>palavra reservada</b>).
</p>
<p>
Existem vários <b>tipos de variáveis</b>, como variável <i>inteira</i> ou <i>flutuante</i>. O que as difere é o
número de <i>bits</i> necessário para representar e como esses <i>bits</i> são interpretados.
Por exemplo, se houver um tipo <i>natural</i> (ou <i>inteiro positivo</i>), que use 16 <i>bits</i>, poderia-se representar
<i>2<sup>16</sup>=65526</i> naturais distintos, ou seja, desde <i>0</i> até <i>65525</i>. Se tentar representar o
valor <i>65526</i> ocorreria um erro e algum número "estranho" apareceria na tela.
</p>
<center><img src="img/var_memoria1.jpg" title="Ilustracao de inteiro de 16 bits e do modelo float IEEE 754 com 32 bits em memoria"/>
<br/>
<i>Fig. 2. Representação da memória com agrupamentos em <i>bytes</i> (8 <i>bits</i>).</i>
</center>
<!--
https://en.wikipedia.org/wiki/Integer_%28computer_science%29
int = -32,768 to 32,767, from -(2^15) to 2^15-1
https://en.wikipedia.org/wiki/Single-precision_floating-point_format
float = 32 bits
IEEE 754 single-precision binary floating-point format: binary32
The IEEE 754 standard specifies a binary32 as having:
Sign bit: 1 bit
Exponent width: 8 bits
Significand precision: 24 bits (23 explicitly stored)
float = 0/1 0.mantissa x 10^e
24 bits 8
-->
<p>
Na figura 2 está ilustrado a associação de 16 <i>bits</i> à uma variável inteira de nome <i>n</i>, seguido de 32 <i>bits</i>
correspondentes à uma variável <i>float</i>, usando o padrão IEEE 754 (o primeiro <i>bit</i> é o sinal <i>s</i>; os 8 <i>bits</i>
seguintes correspondente ao expoente <i>e</i> e os últimos 23 à mantissa <i>m</i> - valor de <i>x</i> é
<i>s * m * 10<sup>e</sup></i>, sendo <i>m</i> entre 0 e 1).
Por exemplo, se <i>x=-102.003</i>, então <i>s=-1</i>, <i>m=102003</i> e <i>e=-3</i>, pois <i>-102.003=-1 * 102003 * 10<sup>-3</sup></i>.
</p>
<a name="paraque">
<p class="secao">Para que serve variáveis</p>
</a>
<p>
Ilustraremos a ideia e necessidade de variáveis a partir de um exemplo simples: como realizar o
cálculo de gastos usando uma calculadora muito elementar.
</p>
<p>
<img src="img/img_calc.png"
style="float: left; margin-right: 1%; margin-bottom: 0.5em;justify-content: center;" title="imagem calculadora"/>
Imagine uma calculadora simples, como ilustrado ao lado, dispondo de apenas um mostrador e apenas 4 operações
(somar, subtrair, multiplicar e dividir).
Se desejamos computar o gasto mensal com a padaria, devemos digitar sequencialmente os valores gastos, um a um,
seguido do operador de soma <tt>+</tt>, sendo que ao final teclamos <tt>=</tt>. <!-- e obtermos na tela o valor total gasto. -->
Vamos supor que os valores dos gastos foram
<tt>5</tt>, <tt>2</tt>, <tt>3</tt>, <tt>5</tt> e <tt>3</tt>.
Mas como foi possível obter a soma de todos os valores? Isso só foi possível por existir um
"acumulador" (<tt>AC</tt>) para armazenar o primeiro valor digitado e depois disso, esse mesmo
"acumulador" teve um novo valor a ele adicionado (ou acumulado):
<tt>AC := <b>5</b></tt>, depois
<tt>AC := 5+<b>2</b> = 7</tt>. depois
<tt>AC := 7+<b>3</b> = 10</tt>. depois
<tt>AC := 10+<b>5</b> = 15</tt> e por último
<tt>AC := 15+<b>3</b> = 18</tt>.
</p>
<p>
<sabermais title="Para quem deseja saber um pouco mais 'como funciona'">
Podemos pensar que calculadora está fazendo o papel da Unidade Lógico Aritmética (<i>Arithmetic logic unit (ALU)</i> em Inglês)
de um computador.
O recurso da calculadora que armazena os valores computados (que denotamos por <tt>AC</tt>) seria o equivalente a um <i>registrador</i>
ou a uma posição de memória em um computador.
Para se ter uma noção da diferença, deve-se notar que um computador moderno dispõe de vários registradores e o que tem sido denominado
<i style="color:#0000aa" title="derivado do primeiro nome, em Inglês, RAM Random Access Memory">memória</i>,
ordens de grandeza maiores que os registradores, hoje compra-se computadores com ao menos <i>2 Gb</i> de memória
<i style="color:#0000aa" title="RAM Random Access Memory, Memória de Acesso aleatório - nome desinformativo, mas tornou-se esse">RAM</i>
(<i>Gb</i> = <i>giga bytes</i> = 1 bilhão de <i>bytes</i>)
</sabermais>
</p>
<p>
Deve-se destacar que o valor armazenado em um registrador ou na memória pode ser alterado, podendo-se dizer
que esses valores <i>variam</i>, vindo dai seu nome de <b style="color: #0000AA">variável</b>.
Para <b>nomear</b> as variáveis, pode-se usar qualquer combinação de letras e números (iniciando por uma letra).
Por exemplo, uma instrução alterando o valor da variável de nome <tt>discriminante</tt> em uma linguagem de programação
qualquer:
<center>
<tt>discriminante = b*b - 4 * a * c</tt>
</center>
<br/>
que significa que a variável de nome <tt>discriminante</tt> recebe o resultado da expressão "o quadrado do
valor armazenado em <tt>b</tt> menos <tt>4</tt> vezes o conteúdo em <tt>a</tt> vezes o conteúdo em <tt>c</tt>".
<!--
No exemplo acima, a calculadora faz o papel de um <i>unidade central de processamento</i> (ou <i>CPU</i> no termo em Inglês)
e o "acumulador" é um <i>registrador</i> que serve para armazenar valores.
Em um computador digital, existe um número razoável de registradores e o restante das informações devem ser armazenadas
na <i>memória</i> do computador, que não é tão rápido quanto um registrador, mas é muito mais barata.
O registrador ou posições de memória podem ter seus valores trocados ao longo da execução do programa (código)
e por isso cada uma dessas posições pode ser entendida como uma <b>variável</b>.
-->
</p>
<p>
Voltando aos <i>tipos de variáveis</i>, existe a necessidade de <b>declarar</b> qual é o tipo da variável,
em uma <i>linguagem de programação</i> como <i>C</i> isso deve ser feito de modo explicito, por exemplo, podemos declarar
e iniciar uma variável inteira e uma <i>flutuante</i> com o valor <i>5</i> da seguinte forma:<br/>
<tt style="color: #0000AA"><verm>int</verm> AC = 5; <verm>float</verm> ac = 5; <cyan>// em C, "AC" NAO e' a mesma coisa que "ac"!</cyan></tt>.
<br/>
Por outro lado, a linguagem <i>Python</i> não dispõe de um mecanismo para indicar o tipo de variável explicitamente,
a primeira atribuição usando um nome funciona como declaração: <br/>
<tt style="color: #0000AA">AC = 5; ac = 5.0; <cyan>#</cyan> em Python, "AC" NAO e' a mesma coisa que "ac"!</tt>.
</p>
<p>
Portanto, <b>variável</b> é essencial para que possamos fazer com que o programa receba algum dado de nosso interesse.
Mesmo em um <i>editor de texto</i> isso ocorre, o texto que digitamos é armazenado (de alguma forma, em variáveis!).
</p>
<p>
Se você estiver interessado em saber um pouco mais sobre o que é o <i>conceito de variável</i>, estude o
restante desse texto.
</p>
<div class="sabermais2" title="Para quem deseja saber um pouco mais 'como funciona'">
<a name="memoria">
<p class="subsecao">Memória, <i>bits</i> e <i>bytes</i></p></a>
<p>
O conceito de variável foi introduzido com o surgimento as <i>linguagens de programação</i>, antes disso era necessário
fazer um acesso direto às posições de memória.
Portanto, variável está associada às linguagens de programação (em um <i>compilador</i>
ou via um <i>interpretador</i>), tendo sido definido para facilitar o armazenamento e recuperação de valores em determinada
posição de memória (para facilitar a <i>programação</i>).
</p>
<p>
Em última análise, os dados presentes na memória do computador são uma sequência de <i>bits</i> e um <i>bit</i>
corresponde a uma posição de memória que pode armazenar o valor <i>0</i> ou o valor <i>1</i>. No início da computação moderna
a menor quantidade de <i>bits</i> que podia ser acessada eram 8 <i>bits</i>, que foi denominado por <i>byte</i>.
</p>
<center><img src="img/var_memoria2.jpg" title="ilustracao de 4 sequencias de 8 bits em memoria"/>
<br/>
<i>Fig. 3. Representação da memória com agrupamentos em <i>bytes</i> (8 <i>bits</i>).</i>
</center>
<p>
Desse modo, toda informação armazenada no computador é uma sequência de <i>bytes</i> e o tratamento de cada
que se dá para cada uma dessas sequências pode variar, por exmeplo, pode considerar a sequência <tt>0010</tt>
com uma letra ou como um inteiro. Ou seja, de acordo com o <b>contexto</b>, se ela estiver associada a uma
variável do tipo inteiro pode-se interpretar a sequência como um número inteiro, se for uma variável do
tipo caractere, como um caractere.
</p>
</div>
<br/>
<div class="sabermais2" title="Para quem deseja saber um pouco mais 'como funciona'">
<a name="variaveis">
<p class="subsecao">Variáveis inteiras e reais</p></a>
<p>
Mas qual a relação entre <i>bytes</i> e variáveis?
<br/>
Primeiro, deve-se saber a priori quanto "espaço" cada tipo de variável ocupará na memória. Esse "tamanho" também determinará
quanto valores distintos tal tipo de variável poderá armazenar.
Por exemplo, suponha que determinado computador (muito, muito antigo) utilize apenas um <i>byte</i> para armazenar inteiros, como em
um <i>byte</i> existem oito (8) <i>bits</i>, então nesse computador poderia existir <i>2<sup>8</sup></i> (ou seja, 256) inteiros
distintos (mas como existem negativos e positivos um deles ficaria com <i>2<sup>7</sup>=128</i> valores e o outro com
<i>2<sup>7</sup>-1=127</i>).
<br/>
Desse modo, nesse computador de inteiros com 8 <i>bits</i>, uma variável inteira na verdade guardaria o endereço inicial
(a posição de seu primeiro <i>bit</i>) e onde tiver referencia a ela, o computador estaria programado para pegar os
8 <i>bits</i> a partir dessa posição e interpretá-lo como um valor inteiro.
<br/>
<b>Exemplos</b>: a sequência de <i>bits</i> <tt>00000101</tt> seria interpretado como <i>5</i> (pois <i>1*2<sup>2</sup>+1*2<sup>0</sup>=5</i>) e
a sequência de <i>bits</i> <tt>00010101</tt> seria interpretado como <i>5</i> (pois <i>1*2<sup>4</sup>+1*2<sup>2</sup>+1*2<sup>0</sup>=21</i>).
</p>
<p>
Existe uma <i>regra para sintática</i> para a construção de nomes de variáveis, por exemplo, em linguagens de programação como
<i>C</i> ou <i>Python</i>, uma variável é uma sequência de letras, dígitos e do caractere "barra baixa" ('<tt>_</tt>'),
devendo começar com letra, mas <b style="color:#aa0000">não</b> pode coincidir com nome de algum comando da linguaguem
(que são denominados <b style="color:#0000aa">palavra reservada</b>).
</p>
<p>
Existem outros <i>tipos de variáveis</i> como os valores "reais", que devido à técnica de implementação (vide figura 2)
é denominado <i>flutuante</i> (<i>float</i>).
</p>
<p>
Do ponto de vista prático, vejamos como se usa variáveis do tipo <i>int</i> e do tipo <i>float</i> nas linguagens
<i>C</i> e <i>Python</i>.
</p>
<center><table>
<tr><td></td><td bgcolor="8aaada"><i>C</i> <td bgcolor="8aaada"><i>Python</i></td></tr>
<tr><td>1</td><td><verm>int</verm> n1,n2; <td><cyan># desnecessário declarar em <i>Python</i></cyan></td></tr>
<tr><td>2</td><td>n1 = 1; <td>n1 = 1 <cyan># primeira atribuicao equivale `a declarar em <i>Python</i></cyan></td></tr>
<tr><td>3</td><td><verd>scanf</verd>("%d", &n2); <td>n2 = int(<verd>input</verd>())</td></tr>
<tr><td>4</td><td><verd>printf</verd>("n1=%d e n2=%d\n", n1, n2); <td><verd>print</verd> "n1=", n1, " e n2=", n2 <cyan>#</cyan> Python 2</td></tr>
<tr><td>5</td><td> <td><verd>print</verd>("n1=", n1, " e n2=", n2) <cyan>#</cyan> Python 3</td></tr>
</table></center>
<p>
Note as diferenças entre <i>C</i> e <i>Python</i>:
<ul>
<li> De modo geral, todo comando em <i>C</i> precisa de ';' como finalizador.
</li>
<li> Na linha 1 percebe-se que em <i>C</i> é obrigatório <b>declarar</b> as variáveis, enquanto que em <i>Python</i> não.
<li> Na linha 3 nota-se que <i>C</i> utiliza a função pré-definida de nome <i><verd>scanf</verd></i> para pegar valores digitados
pelo usuário enquanto <i>Python</i> usa o <i>input</i>. O <i><verd>scanf</verd></i> usa o formatador especial '%d' para forçar
o computador a interpretar os <i>bytes</i> como um inteiro, enquanto o <i>input</i> pega os <i>bytes</i>
digitados e o submete à outra função pré-definida <i>Python</i>, o <i>int(...)</i>, que converte os <i>bytes</i> lidos para um inteiro.
</li>
<li> Na linha 4 nota-se o mesmo tipo de diferença, <i>C</i> utiliza a função <i><verd>printf</verd></i> para imprimir também com
o formatador para inteiro '%d', além de separar em 2 blocos, o primeiro para formatar a saída, que é cercado
por aspas dupla e o segunda, uma lista de variáveis compatíveis com o formatador.
Já em <i>Python</i>, usa-se os caracteres entre aspas e as variáveis misturados, separador por vírgula.
</li>
<li> Vale destacar que a linha 4 apresenta a sintaxe do <i>Python</i> antes da versão 3, enquanto que a linha 5
apresenta o mesmo resultado mas para o <i>Python</i> a partir da sua versão 3.
</li>
</ul>
</p>
</div>
<br/>
<div class="sabermais2" title="Para quem deseja saber um pouco mais 'como funciona'">
<a name="expressoes">
<p class="subsecao">Expressões aritméticas</p>
</a>
<p>
Do mesmo modo que em matemática é essencial efetuarmos operações aritméticas com valores numéricos,
o mesmo ocorre com o computador, na verdade efetuar contas de modo
rápido e "sem erro" (na verdade existem erros numéricos, mas este é
outro assunto) foi a grande motivação para se construir os computadores.
</p>
<p>
Neste, os agrupamentos de valores, variáveis e operadores aritméticos recebem o nome de <i>expressão aritmética</i>.
De modo geral, podemos conceituar uma <i>expressão aritmética</i> <b>EA</b> como:
<ol>
<li>EA := K: uma constante numérica é uma <i>expressão aritmética</i></li>
<li>EA := EA + EA | EA - EA | EA * EA | EA / EA: uma <i>expressão aritmética</i> seguida de um <b>operador binário</b>
(com 2 itens) e seguida por outra <i>expressão aritmética</i> é uma <i>expressão aritmética</i></li>
</ol>
Os <b>operadores artiméticos binários</b>, tanto em <i>C</i> quanto em <i>Python</i> são:
</p>
<center><table>
<tr><td bgcolor="8aaada">Operação</td><td bgcolor="8aaada">Operador <td bgcolor="8aaada">Exemplo</td></tr>
<tr><td>soma </td><td> + <td> 2 + 4 </td></tr>
<tr><td>subtração </td><td> - <td> n1 + 1 </td></tr>
<tr><td>multiplicação</td><td> * <td> 3 * n2 </td></tr>
<tr><td>divisão </td><td> / <td> n1 / n2 </td></tr>
</table></center>
<p>
Note que foi usado espaço em branco entre os operando e operadores, mas isso não é obrigatório.
</p>
</div>
<br/>
<div class="sabermais2" title="Para quem deseja saber um pouco mais 'como funciona'">
<a name="contexto">
<p class="subsecao">O resultado de uma expressão aritmética depende do contexto</p>
</a>
<p>
É importante observar que dependendo do contexto o resultado de uma expressão é um ou outro, quer dizer,
se os valores envolvidos forem todos eles inteiros, o resultado será inteiro, entretanto havendo um valor
real, a resposta final será real.
</p>
<p>
A importância disso fica clara ao examinar dois exemplos simples: <i>3 / 2 * 2</i> e <i>3.0 / 2 * 2</i>.
Em várias linguagens de programação a primeira expressão resulta o valor <i>2</i>, enquanto a segunda <i>3.0</i>.
A razão é que no primeiro caso todos valores são inteiros, então o cômputo é realizado com aritmética de precisão inteira,
ou seja, ao realizar o primeiro cômputo <i>3/2</i>, o resultado é <i>1</i> (e não <i>1.5</i> como no segundo caso), daí
o segundo operador é feito com os valores <i>1 * 2</i> resultando o valor <i>2</i>.
</p>
<p>
Por exemplo, na linguagem <i>C</i>, a sintaxe e o resultado para as expressões acima está indicada no código
abaixo:
<pre><incl1>#include</incl1> <stdio.h>
<verm>void</verm> main (<verm>void</verm>) {
<cyan>// Resultados</cyan>
<verd>printf</verd>("3 / 2 * 2 = %d\n", 3 / 2 * 2); <cyan>// 3 / 2 * 2 = 2</cyan>
<verd>printf</verd>("3.0 / 2 * 2 = %f\n", 3.0 / 2 * 2); <cyan>// 3.0 / 2 * 2 = 3.000000</cyan>
}</pre>
</p>
<p>
Entretanto existe exceção, na versão 3 do <i>Python</i>, ao usar o operador de divisão <tt>/</tt>, ele
automaticamente converte o resultado para número real.
O bloco de comandos abaixo ilustra a diferença entre o <i>Python 2</i> e o <i>Python 3</i>:
<pre><cyan># Resultados em : Python 2</cyan> | <cyan># Python 3/cyan>
<verd>print</verd>("3 / 2 * 2=", 3 / 2 * 2); <cyan># ('3 / 2 * 2=', 2) | 3 / 2 * 2= 3.0/cyan>
<verd>print</verd>("3.0 / 2 * 2=", 3.0 / 2 * 2); <cyan># ('3.0 / 2 * 2=', 3.0) | 3.0 / 2 * 2= 3.0/cyan>
<verd>print</verd>("3 // 2 * 2=", 3 // 2 * 2); <cyan># ('3 // 2 * 2=', 2) | 3 // 2 * 2= 2/cyan>
<verd>print</verd>("3.0 // 2 * 2=", 3.0 // 2 * 2); <cyan># ('3.0 // 2 * 2=', 2.0) | 3.0 // 2 * 2= 2.0/cyan></pre>
</p>
</div>
<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/10/23: acerto vírgulo faltante<br/>
2020/10/16: cor include<br/>
2020/08/15: novo formato, pequenas revisões<br/>
2020/07/06: nova seção inicial (" O que é uma variável?");<br/>
2019/06/05: as seções inicial ("Ideia de variável") e final ("O resultado de uma expressão aritmética depende do contexto") foram estendidas;<br/>
2019/06/04: adicionada nova seção (inicial) "Ideia de variável";<br/>
2017/04/14: adicionados novos itens (como explicação adicional sobre expressões aritméticas).
</p>
</div>