intr_prog/py_introducao_leituras.html

<!--
Introdução à entrada de dados em Python
m, n = map(int, raw_input().split());
-->

  <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> <!-- referencia documentos internos -->
<div class="pagina">


<!--
declaracao
io_simples
ex_io_simples
io_composto
-->

<a name="declaracao">
<p class="secao">Qual a diferença entre <i>declarar</i> e usar uma variável?</p>
</a>

<p>
  Uma <a href="#" onclick="trocaPagina('introducao_var.html#declaracao')" title="ver explicacao">variável</a> nada mais é que um nome associado à uma posição de <i>memória</i>
  do computador:
  a posição de seu <i>bit</i> inicial e o número de <i>bits</i> usados para representar aquele tipo de variável.
  Como a linguagem <i>Python</i> é interpretada, pode-se em qualquer parte
  <b style="color:#0000aa" title="Reservar espaço na memória e associar esse espaço a um nome">declarar</b> uma variável e
  depois pode-se usá-la, recebendo valores ou em expressões.  
  <pre style="font-size:0.9em"><verm>def</verm> main () :
  i = 3; <cyan># declara variavel inteira 'i' (i sendo iniciada com valor 3)</cyan>
  x = 0.5; <cyan># declara variavel inteira 'x' (iniciada com 0.5)</cyan>
  y = i/2; <cyan># declara variavel inteiro 'y' (pois i e' inteiro =&gt; recebera' 3/2 = 1)</cyan>
  <cyan># %d e' formatador para imprimir inteiro, %f para flutuante - y=%f e' para comprovar que 3/2 = 1</cyan>  
  <verd>print</verd>("i=%d, x=%f, y=%f" % (i, x, y));
  ...
main();</pre>
  <i>Cód. 1. Código ilustrando a declaração de variáveis inteiras e flutuantes.</i>
</p>


<p>
  Outro conceito essencial às variáveis é o de
  <b style="color:#0000aa" title="Alterar o valor guardado pela variável">atribuição</b> de valor.
  Sua sintaxe em <i>Python</i>, e em muitas outras linuguagens, é usar do
  <b style="color:#0000aa" title="lado esquerdo da atribuição">lado esquerdo</b> da atribuição um nome de variável e do
  <b style="color:#0000aa" title="lado direito da atribuição">lado direito</b> da atribuição uma expressão aritméitca válida.
  No código 1, <tt>i=0</tt> e <tt>x=0.5</tt> são atribuições, então funciona no <i>Python</i> como declaração de variável,
  desse modo <i>i</i> será variável inteira e x flutuante.
  tendo como <i>lado esquerdo</i> as variáveis <i>i</i> e <i>x</i>
  e como <i>lado direito</i> as expressões constantes <i>0</i> e <i>0.5</i>.
</p>

<p>
  Ainda usando como estrutura o código 1, outro exemplo de atribuição poderia ser <tt>i = n/2</tt>, que tem como
  <i>lado direito</i> a expressão <i>n/2</i>.
  Como no código 1 a variável <i>n</i> é do tipo inteiro, o mesmo para a constante <i>2</i> (se desejasse <i>flutuante</i> deveria usar <i>2.0</i>),
  então seu resultado é o <b style="color:#00aa00" title="a/b = q &#8658; q é o quociente">quociente da divisão inteira da divisão</b>.
  Mas vale adiantar outra possibilidade de "forçar" o resultado a ser <i>flutuante</i>, usar o coversor de tipo:
  <tt style="color:#00aa00" title="o valor de n é convertido para float, daí o restante da conta usa flutuante">x = (<verm>float</verm>)n/2</tt>.
  <!--
   &#11013; black left arrow
   &#11013; black right arrow
   &#8658;  Rightwards Double Arrow
  -->
</p>

<p>
  A figura 1 ilustra a associação de espaço em memória (<i>RAM</i>) para duas variáveis,
  são associados 16 <i>bits</i> à variável de nome <i>n</i>, para guardar valores inteiros, seguido da associação de
  32 <i>bits</i> para a variável de nome <i>x</i>, que deve guardar valores "reais".
  Nota-se que a variável "real" tem um esquema mais "complicado", ela implementa o conceito
  de <a href=<a href="#" onclick="trocaPagina('line_introducao_float.html')" title="clique aqui para estudar ponto flutuante" targe="_blank">ponto flutuante</a>,
  usando o padrão 
  <a href="https://en.wikipedia.org/wiki/Integer_%28computer_science%29" title="ler a respeito IEEE 754 na WikiPedia" target="_blank">
  IEEE 754</a> (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> é s x m x 10<sup>e</sup>, sendo
  <i>m</i> entre 0 e 1).
</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. 1. 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
  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
-->
<sabermais title="para saber mais">
  Note que, em <i>Python</i>, sempre que existe uma <i>atribuição</i>, a <i>variável</i> que aparece do
  <b>lado esquerdo</b> da atribuição está sendo (re)definida! Isso corresponde à sua <b>declaração</b>!
  <br/>
  Isso implica que, na <i>declaração</i> é reservado um espaço de tamanho fixo na <i>memória</i> do computador, o "tamanho" desse espaço
  depende do <b>tipo da variável</b>.
</sabermais>


<a name="io_simples">
<span style="font-size:1.2em;color: #0055AA"><b>O que são "entradas de dados" e "saídas de dados"?</b></span>
</a>

<p>
  Um <b>algoritmo</b> é uma sequência finita de passos, que ao ser aplicado à um conjunto de dados (<b>entradas</b>) deve produzir
  sempre as mesmas <b>saídas</b>.
  Por exemplo, o algoritmo da divisão ao ser aplicado sobre valores fixados <i>a</i> e <i>b</i>, deve
  produzir sempre o mesmo valor <i>q</i> (de tal forma que <i>q * b = a</i>).
</p>

<p>
  Por outro lado, um 
  <b style="color:#0000aa" title="um algoritmo implementado em alguma linguagem">programa</b>, em <i>Python</i> ou em qualquer outra linguagem,
  nada mais é que a implementação de um <b>algoritmo</b> na referida linguagem.
  Desse modo, para este programa ser usado, o
  <b style="color:#0000aa" title="quem usa o programa">usuário</b> (aquele que está executando) deve fornecer um conjunto de 
  <b>dados de entrada</b>, na ordem adequada (pois <i>a/b</i> geralmente não é o mesmo que <i>b/a</i>), para que o
  programa possa ser executado e produzir as <b>saídas</b> desejadas.
</p>

<center><img src="img/img_computador_io.png" title="ilustracao processamento entradas x saidas"/>
<br/><i>Fig. 2. Ilustração da existência de um algoritmo que aplicado sobre as entradas produz as respectivas saídas.</i>
</center>


<p>
  Podemos usar o mesmo exemplo da divisão para ilustar a necessidade dos <i>dados de entrada</i> adequados.
  Para que um algoritmo para a divisão de dois números reais seja adequadamente executado,
  devem ser fornecidos os dois valores reais, o primeiro será o
  <b style="color:#0000aa" title="em a/b &#8658; parte de cima é o numerador &#8658; a é o numerador">numerador</b> e o segundo será o
  <b style="color:#0000aa" title="em a/b &#8658; parte de baixo é o denominador &#8658; b é o denominador">denominador</b>.
  Assim, se o <i>usuário</i> digitar apenas um valor, o programa ficará parado até
  <!--  &#8658; = Rightwards Double Arrow -->
  que ele digite o segundo valor.
</p>

<sabermais title="para saber um pouco mais">
  Vale observar que, usando uma linguagem como <i>Python</i>, não existe a necessidade de implementar algo tão básico (a <i>divisão</i>, pois
  isso é feito por um algoritmo implementado no processador do computador.
  Na verdade, desde a proposta inicial do matemática
  <a href="https://en.wikipedia.org/wiki/John_von_Neumann" target="_blank" title="Examinar a página sobre John von Neumann na WikiPedia em Inglês"
  >John von Neumann</a>, existe uma
  <a href="https://en.wikipedia.org/wiki/Arithmetic_logic_unit" target="_blank" title="Examinar a página ULA na WikiPedia em Inglês"
  ><b style="color:#0000aa">unidade lógico/aritmética</b></a> especialmente projetada para realizar as
  operações lógicas e aritméticas.
  Embora, o modelo inicialmente proposto por <i>von Neumann</i> preconizase o uso de
  <i>ponto fixo</i>, não o <i>flutuante</i>.
</sabermais>
<br/>


<a name="ex_io_simples">
<span style="font-size:1.2em;color: #0055AA"><b>Entrada de dados simples: inteiro, real e texto em <i>Python 2</i></b></span>
</a>
<!-- ./introducao/codigos/testes/teste_input.py -->

<p>
  Na versão 2 do <i>Python</i> a <i>prioridade</i> das entradas são os <i>valores numéricos</i> e a função para disparar
  o processo de "coleta" de dados é <b><tt>input()</tt></b>.
  Assim, usando o código da tabela 1, pode-se digitar um (único) valor inteiro e o programa imprime o valor e o dobro dele,
  em seguida o <i>usuário</i> deve digitar um (único) valor "real" e novamente é impresso o valor e seu dobro.
</p>

<p>
  Em <i>Python</i> é possível fazer impressões mais sofisticadas utilizando um formatador (<tt>%</tt>) com o um caractere indicando o
  tipo da variável ser impressa: <tt>d</tt> =&gt; "inteiro"; <tt>f</tt> =&gt; "float"; <tt>c</tt> =&gt; "caractere"; <tt>s</tt> =&gt; "string".
  Por exemplo, pode-se usar os comandos <br/>
  <tt>
  &nbsp;&nbsp;&nbsp; m = 2; f = 2.3; c = 'A';<br/>
  &nbsp;&nbsp;&nbsp; <verd>print</verd>("m=%d, f=%f, c=%c" % (m, f, c)); <cyan># imprime m, f e c</tt></cyan> <br/>
  </tt>
  para imprimir inteiro, "float" e caractere (respectivamente).<br/>
  Ainda pode-se usar um natural para indicar ajuste à direita e assim construir tabelas.
  Experimente: <tt><verd>print</verd>("m=%3d, f=%8.3f, c=%2c" % (m, f, c));</tt>
</p>

<p>
  Na tabela abaixo ilustra-se o uso da função/comando <tt><b>input()</b></tt> para entrada de dados no <i>Python 2</i>.
</p>

<p>
<center><i>Tab. 1. Exemplo de códigos para entrada e saída de inteiros e "reais" para o Python 2</i><br/>
<table class="tableCode thBg">
 <tr>
   <td></td><th bgcolor="8aaada"><i>Python 2</i>: impressão com formatador</th>
   <th bgcolor="8aaada"><i>Python 2</i>: com impressão simples</th></tr>
  <tr><td><pre style="font-size: 0.8em;"> 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
18
20</pre></td><!-- codigo/ -->
<td><pre style="font-size: 0.8em;"><cyan># Python 2 (Py2): funciona digitar 2 ou 2.4</cyan>
<cyan># * O Py2 automaticamente transforma no tipo adequado</cyan>
<cyan># * Mas o Python 3 (Py3) nao faz isso! Ele le^ tudo como</cyan>
<cyan>#   texto, entao precisa converter explicitamente para</cyan>
<cyan>#   para o que interssa, e.g. int(input())</cyan>
<cyan>#   Se usar, 'leitura1_Py2()' com Py3, resultara' no erro:</cyan>
<cyan>#     <verd>print</verd>("%d %s" % (n,n));</cyan>
<cyan># TypeError: %d format: a number is required, not str</cyan>
<verm>def</verm> leitura1_Py2 () :
  <verd>print</verd>("Digitar inteiro");
  <cyan># Suponha que digite 2</cyan>
  n = <b><verd>input</verd>()</b>; <cyan># ATENCAO: aqui define o tipo como "int"</cyan>
  m = 3*n;     <cyan># como recebe inteiro => tambem sera' "int"</cyan>
  <cyan># Imprime 2 e 6: Py2 automaticamente interpreta como numero</cyan>
  <verd>print</verd>("n=%d 3*n=%d" % (n,m));
  n = 4.7; <cyan># Nova atribuicao => redeclara, agora float</cyan>
  m = 3*n; <cyan># idem, m passa a ser "float"</cyan>
  <cyan># Imprime 2 e 3*4: %f por agora ser "float"</cyan>
  <verd>print</verd>("n=%f 3*n=%f" % (n,m)); <cyan></cyan>
leitura1_Py2()</pre></td>
  <td><pre style="font-size: 0.8em;"><cyan># Python 2 (Py2): funciona digitar 2 ou 2.4</cyan>
<cyan># * O Py2 automaticamente transforma no tipo adequado</cyan>
<cyan># * Mas o Python 3 (Py3) nao faz isso! Ele le^ tudo como</cyan>
<cyan>#   texto, entao precisa converter explicitamente para</cyan>
<cyan>#   para o que interssa, e.g. int(input())</cyan>
<cyan>#   Se usar, 'leitura2_Py2()' com Py3, resultara' no erro:</cyan>
<cyan>#     <verd>print</verd>("%d %s" % (n,n));</cyan>
<cyan># TypeError: %d format: a number is required, not str</cyan>
<verm>def</verm> leitura2_Py2 () :
  <verd>print</verd>("Digitar inteiro");
  <cyan># Suponha que digite 2</cyan>
  n = <b><verd>input</verd>()</b>; <cyan># ATENCAO: declara "n" como "int"</cyan>
  m = 3*n;     <cyan># declara "m" como "int"</cyan>
  <cyan># Imprime 2 e 6</cyan>
  <verd>print</verd>(n,m);
  n = 4.7; <cyan># Nova atribuicao => redeclara, agora float</cyan>
  m = 3*n; <cyan># idem, m passa a ser "float"</cyan>
  <cyan># Imprime 2 e 3*4: %f por agora ser "float"</cyan>  
  <verd>print</verd>(n,m); <cyan></cyan>
leitura2_Py2()</pre></td>
</table></center>
</p>

<p>  
  Se o <i>usuário</i>
  desejar inserir outra coisa (em geral uma <i>cadeia de caracteres</i> - "<i>string</i>")
  deve-se usar uma função especial (vide <tt>raw_input</tt> a seguir).
</p>


<a name="io_composto">
<span style="font-size:1.2em;color: #0055AA"><b>Entrada de dados: vários valores em uma só linha no <i>Python 2</i></b></span>
</a>
<!-- ./introducao/codigos/testes/teste_input.py -->

<p>
  Como citado acima, a versão 2 do <i>Python</i> dá <i>prioridade</i> às entradas serem <i>valores numéricos</i>, assim
  usando apenas <tt>input()</tt> automaticamente tenta-se interpretar o que foi digitado como número.
  Se forem digitados vários valores ou alguma palavra ocorre erro (<tt>File "<string>", line 1</tt>).
</p>

<p>
  Assim, se for necessário entrar vários valores de uma só vez deve-se usar um comando especial: <tt><b>raw_input()</b></tt>
  (que não mais existe no <i>Python 3</i>!).
  Entretanto, depois é preciso rodar um algoritmo para converter os dados, mas o <i>Python</i> já tem algumas funções/métodos
  pré-definidos para fazer isso como o <tt>split()</tt> que aplicado sobre uma "string" a quebra pegando cada um de seus elementos
  e a função <tt>map(<i>tipo</i>, <i>lista</i>)</tt> que pega uma lista de "strings" e gera uma
  lista de <i>tipos</i>.
</p>

<p>
  Por exemplo, para digitar as dimensões de uma matriz e seu maior e menor valor em um único <tt>ENTER</tt>, pode-se usar o comando:<br/>
  &nbsp;&nbsp;&nbsp; <tt>m, n = map(int, <verd>raw_input</verd>().split()); <cyan># raw_input pega a "string" digitada "2 4"</cyan></tt>
  <br/>
  É uma sequência de passos:<br/>
  1. <tt><verd>raw_input</verd>()</tt> pegar a "string" digitada (e.g. supor ter sido digitado <tt>2 4 ENTER</tt>;<br/>
  2. <tt>split()</tt> quebra a "string", gerando uma lista (e.g. <tt>["2", "4"]</tt>)<br/>
  3. <tt>map</tt> com parâmetro <tt>int</tt> aplica um algoritmo de conversão em cada item tornando-os inteiro (e.g. <tt>[2, 4]</tt>)<br/>
  4. <tt><verd>print</verd>("m=%d, n=%d" % (m, n, min, max));</tt><br/>
</p>

<p>
  Mas com a conversão é uniforme na função <tt>map</tt>, se tiver misturas de valores seria necessário algum "truque".
  Por exemplo, suponha que precise ser digitado 2 inteiros seguindos de 2 "floats" (em um único <tt>ENTER</tt>), pode-se usar o 
  conversor para o tipo de "maior tamanho" ("float" no caso) e depois fazer mais uma conversão:
  <pre>
   m, n, x, y = map(int, <verd>raw_input</verd>().split()); <cyan># raw_input pega a "string" digitada "2 4 3.1 6.1"</cyan>
   m, n = map(int, [m, n]); <cyan># gere uma lista [m,n] e a converta para inteiro</cyan></pre>
  É uma sequência de passos:<br/>
  1. <tt><verd>raw_input</verd>()</tt> pegar a "string" digitada (e.g. supor ter sido digitado <tt>2 4 3.1 6.1 ENTER</tt>;<br/>
  2. <tt>split()</tt> quebra a "string", gerando uma lista (e.g. <tt>("2", "4", "3.1", "6.1")</tt>)<br/>
  3. <tt>map</tt> com parâmetro <tt>float</tt> aplica um algoritmo de conversão em cada item tornando-os "float" (e.g. <tt>(2.0, 4.0, 3.1, 6.1)</tt>)<br/>
  4. <tt>map</tt> com parâmetro <tt>int</tt> aplica um algoritmo de conversão em cada item tornando-os "int" (e.g. <tt>(2, 4)</tt>)<br/>
  5. <tt><verd>print</verd>("m=%d, n=%d, x=%f, y=%f" % (m, n, x, y));</tt><br/>
</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/14: novo formato, pequenas revisões<br/>
  2020/07/06: Segunda, 06 Julho 2020, 23:30
</p>

</div>