intr_prog/introducao_for.html

<!--
Introdução ao comando de repetição for
-->

<!-- center><p>[
  <a href="memoria" title="sobre memoria, bits e bytese">Memória</a> &nbsp; | &nbsp;
  <a href="#variaveis" title="variaveis inteiras e reais">Variáveis</a> &nbsp; | &nbsp;
  <a href="#expressoes" title="expressoes aritmetics">Expressões</a> &nbsp; | &nbsp;
  <a href="#contexto" title="resultado de uma expressao depende do contexto">Contexto</a> &nbsp; &nbsp;
 ]</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 &lt;stdio.h&gt;</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&gt;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 &lt;- i-1, entao
    // a execucao retorna ao inicio do for e testa se continua (i<u>&gt;</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>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</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>&lt;</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 &lt;- i-1, entao a execucao retorna ao inicio do for e se i<u>&gt;</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&lt;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&lt;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&lt;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>