<!--
Introdução ao comando de repetição for
-->
<!-- center><p>[
<a href="memoria" title="sobre memoria, bits e bytese">Memória</a> |
<a href="#variaveis" title="variaveis inteiras e reais">Variáveis</a> |
<a href="#expressoes" title="expressoes aritmetics">Expressões</a> |
<a href="#contexto" title="resultado de uma expressao depende do contexto">Contexto</a>
]</p>
</center -->
<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 repetição for</p>
<p>
Nesta seção examinaremos um novo comando de repetição, bastante útil quando o número de
<i>passos</i> (cada repetição de um bloco de comandos)
é conhecido à priori, ou seja, conhecido ao iniciar o laço.
</p>
<p>
Em várias <i>linguagens de programação</i> (com <em>C</em> e em <em>Python</em>) esse comando recebe o nome de
<b><tt class="cmd">for</tt></b> (<i>para</i>).
Além disso ele deve sempre dispor de um <b>enumerador</b> (ou <i>iterador</i>), ou seja, uma
variável que será utilizada para controlar o número de repetições do bloco de comandos subordinado ao <i>for</i>.
Esse <i>enumerador</i> pode ser usado em comandos do bloco.
</p>
<a name="caracteres"><span style="color: #0050A0">Comando <i>for</i> em <em>C</em></span></a>
<p>
Em <em>C</em> a sintaxe do comando é:
<center>
<table class="tbCodeLinCol">
<tr><th>Comando <tt>for</tt></th><th>Equivalente usando <tt>while</tt></th></tr>
<tr valign="top">
<td><pre><tt class="cmd">for</tt> (varint=valorIni, condicao, incremento)
comandoSubordinado;</pre></td>
<td><pre>varint = valorIni;
<tt class="cmd">while</tt> (condicao) {
comandoSubordinado;
incremento; <tt class="com">// geralmente algo como: varint += passo;</tt>
}</pre></td></tr>
</table>
</center>
Note que dentro da definição do comando também deve-se utilizar o separador ponto-e-vírgula (';').
</p>
<p>
Por exemplo, o programa abaixo que imprime a soma dos <tt>n</tt> primeiros naturais,
mas somando-os em ordem invertida, começando com o <tt>n</tt>, depois somando-se <tt>n-1</tt> e, assim por diante,
até o <tt>1</tt>.
<pre><tt class="head">#include <stdio.h></tt>
int main (void) {
int n, i; <tt class="com">// declarando o indexador i do comando for e o tamanho do laco n</tt>
int soma = 0;
<tt class="fnc">scanf</tt>("%d", &n); <tt class="com">// ler a quantia desejada de naturais</tt>
<tt class="cmd">for</tt> (i=n; i>0; i--) {
soma += i; <tt class="com">// acumula o atual natural em i</tt>
<tt class="fnc">printf</tt>("%d : %d\n", i, soma); <tt class="com">// imprime contador e a soma parcial
// apos ultimo comando subordinado ao for, executa-se o incremento do contador (ou seja, i <- i-1, entao
// a execucao retorna ao inicio do for e testa se continua (i<u>></u>0),
// se for repete-se os comandos subordinados, senao finaliza o for</tt>
}
<tt class="fnc">printf</tt>("Soma dos %d primeiros naturais eh igual a %d\n", n, soma);
return 1; <tt class="com">// se foi algum outro programa que invocou este, devolva o valor 1</tt>
}</pre>
</p>
<a name="caracteres"><span style="color: #0050A0">Comando <i>for</i> em <em>Python</em></span></a>
<p>
Em <em>Python</em> é necessário usar um <i>iterador</i>, isso pode ser feito com a função
<tt><tt class="fnc">range</tt>(...)</tt> que pode ter 1, 2 ou 3 parâmetros do tipo número natural.
Se tiver apenas um parâmetro significa que deve gerar os n primeiros naturais.
Se tiver dois parâmetros naturais, neste caso significa os naturais entre ambos, mas
também pode ter três parâmetros e neste caso o último é o tamanho do passo.
Abaixo a forma geral do comando <tt>for</tt>, com um exemplo de <tt>range(...)</tt> usando apenas um parâmetro.
<center><tt><tt class="cmd">for</tt> varint in <tt class="fnc">range</tt>(numeroIteracoes) comandoSubordinado</tt></center>
Nesse exemplo, o <tt>comandoSubordinado</tt> será executado <tt>numeroIteracoes</tt>, na primeira com
<tt>i</tt> valendo <tt>0</tt>, depois <tt>i</tt> valendo <tt>1</tt> e assim por diante, até <tt>i</tt> valendo <tt>numeroIteracoes-1</tt>.
</p>
<p>
Também pode-se fazer o <tt>i</tt> ter outro valor inicial e tamanho de passo diferente, mesmo passos "negativos".
Por exemplo, para imprimir os <tt>n/2</tt> primeiros ímpares pode fazer:
<table>
<tr><td> </td>
<td><tt class="cmd">for i in <tt class="fnc">range</tt>(1, n, 2) : print("%d " % i, end="");</tt></td></tr>
<tr><td></td><td><tt>print();</tt></table>
Se <tt>n=10</tt>, esse código geraria <tt>1 3 5 7 9</tt>, na mesma linha. Ou seja,
o segundo parâmetro do <tt>range(...)</tt> (o controle <tt>n</tt>), é o limite, "repete-se enquanto" <tt>i <u><</u>10</tt>.
</p>
<p>
Por exemplo, o programa abaixo que imprime a soma dos <tt>n</tt> primeiros naturais,
mas somando-os em ordem invertida, começando com o <tt>n</tt>, depois somando-se <tt>n-1</tt> e, assim por diante,
até o <tt>1</tt>.
<pre>def main () :
<tt class="com">#inteiros: n, i; :: usaremos como indexador i para o comando for e o tamanho do laco n</tt>
soma = 0;
n = int(<tt class="fnc">input</tt>()); <tt class="com"># ler a quantia desejada de naturais</tt>
<tt class="cmd">for</tt> i in <tt class="fnc">range</tt>(n, 0, -1) :
soma += i; <tt class="com"># acumula o atual natural em i</tt>
<tt class="fnc">print</tt>("%d : %d" % (i,soma)); <tt class="com"># imprime contador e a soma parcial</tt>
# desse ponto, incrementa-se i (ou seja, i <- i-1, entao a execucao retorna ao inicio do for e se i<u>></u>0,
# repete-se os comandos subordinados ao for
<tt class="fnc">print</tt>("Soma dos %d primeiros naturais eh igual a %d" % (N,soma));
main()</pre>
</p>
<p>
Note que no exemplo acima usamos o marcador <tt><b>%d</b></tt> dentro da função <tt class="fnc">print</tt>,
isso significa que no lugar do primeiro <tt>%d</tt> deverá ser impresso o valor da primeira variável, encontrada
após fechar aspas e após o caractere <tt>%</tt> (i.e., <tt>i</tt>) e no lugar do <tt>%d</tt> deverá ser impresso o valor da
segunda variável (i.e., <tt>soma</tt>).
O <tt>%d</tt> está associado à inteiros, se precisar de caractere deve-se usar o formator <tt>%c</tt>,
se precisar de ponto flutuante deve-se usar o <tt>%f</tt> e se for usar uma variável que guarda caracteres (<i>string</i>),
deve-se usar o formatador <tt>%s</tt>.
<!--
Entretanto, como no exemplo, se existir mais que uma variável/valor, então é obrigatório que esses venham
com a sintaxe de <i>lista</i> e na ordem correspondentes a cada formatador <tt><b>%d</b></tt>, ou seja,
a lista cercada por abre e fecha parênteses.
-->
</p>
<span style="color: #0055AA;font-size:1.em"><b>Exercitando a compreensão: simulando o código</b></span>
<p>
É interessante usar <b>simulações</b> para melhor compreender o desenvolvimento dos algoritmos, mais ainda se você detectar
algum erro em seu código, que portanto precisa ser corrigido.
Adotaremos o seguinte esquema de simulação: usaremos uma tabela com as variáveis do código e registraremos cada alteração
em uma linha, seguindo o <i>fluxo de execução</i> de cima para baixo, de modo que o último valor de uma variável
(em qualquer ponto/linha) será o primeiro valor, na coluna da variável, encontrado "olhando" para "cima".
Indicaremos as atribuições com ":=".
</p>
<!--
3
0 : 0
1 : 1
2 : 3
Soma dos 3 primeiros naturais eh igual a 3
-->
<center><table><tr><td align="left"><pre>
n | soma | i impressoes
---+------+--- ----------
soma := 0 ? | 0 | ?
* leitura para inteiro n 3 | |
i := 0 (primeiro da lista (0,1,2) | | 0
* entra no laco "for" pois 0=i<n=3 | |
soma := 0 (pois: soma recebe soma+i=0+1) | 0 |
* saida: 0 : 0 | | 0 : 0
i := 1 (segundo da lista (0,1,2)) | | 1
* entra no laco "for" pois 1=i<n=3 | |
soma := 1 (pois: soma recebe soma+i=0+1) | 1 |
* saida: 1 : 1 | | 1 : 1
i := 2 (terceiro da lista (0,1,2)) | | 2
* entra no laco "for" pois 2=i<n=3 | |
soma := 3 (pois: soma recebe soma+i=1+2) | 3 |
* saida: 2 : 3 | | 2 : 3
* nao tem elemento na lista (0,1,2) apos o 2 | |
* final do laco "for" (sem mais elementos) | |
* executa primeira instrucao apos laco "for" | |
* saida: Soma dos 3 primeiros naturais eh igual a 3 | | Soma dos 3 primeiros naturais eh igual a 3
</pre></td></tr></table></center>
<!-- img/img_invisivel.png e img/img_visivel.png -->
<img src="img/img_invisivel.png" onClick="fnc_mostrar('mais_range', 'olho');" id="olho"
title="Clique para ver explicacao adicional sobre 'range'" />
<div class="mais" id="mais_range">
<p>
Em relação à função <tt>range(...)</tt> existe uma diferença interessante entre o <em>Python 2</em> e o
<em>Python 3</em>. No 2 ao usar por exemplo, <tt><tt class="fnc">range</tt>(10)</tt> é gerada uma lista com os
10 primeiros naturais, assim imediatamente após invocar a função é necessário alocar espaço de
memória para os 10 elemento.
Já no <em>Python 3</em> os elementos são gerados a medida que se precisa deles.
<p>
<!--a href="." onMouseOver="fnc_mostrar_esconder('mais_range');"-->
<p>
Vejamos como funcionam os parâmetros em <tt class="fnc">range</tt>:
<center>
<table class="tbCodeLinCol">
<tr><th># parâmetros</th><th>função</th><th>resultado</th></tr>
<tr valign="top">
<th>1 parâmetro</th>
<td><pre>lst = <tt class="fnc">range</tt>(10)</pre>
<td>Gera uma lista com os naturais <tt>0,1,2,3,4,5,6,7,8,9<tt></td>
</tr>
<tr valign="top">
<th>2 parâmetros</th>
<td><pre>lst = <tt class="fnc">range</tt>(0,10)</pre>
<td>Gera uma lista com os naturais <tt>0,1,2,3,4,5,6,7,8,9<tt></td>
</tr>
<tr valign="top">
<th>2 parâmetros</th>
<td><pre>lst = <tt class="fnc">range</tt>(1,10)</pre>
<td>Gera uma lista com os naturais <tt>1,2,3,4,5,6,7,8,9,10<tt></td>
</tr>
<tr valign="top">
<th>3 parâmetros</th>
<td><pre>lst = <tt class="fnc">range</tt>(0,10,2)</pre>
<td>Gera uma lista com os naturais <tt>0,2,4,6,8<tt></td>
</tr>
</table>
</center>
</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/08/15: novo formato, pequenas revisões<br/>
2019/07/28: Versão 1.2 (vários acertos)<br/>
2019/03/31: Versão 1.1<br/>
2017/05/03: versão 1.0
</p>
</div>