<!--
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 => 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 ⇒ 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>.
<!--
⬅ black left arrow
⬅ black right arrow
⇒ 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 ⇒ parte de cima é o numerador ⇒ a é o numerador">numerador</b> e o segundo será o
<b style="color:#0000aa" title="em a/b ⇒ parte de baixo é o denominador ⇒ b é o denominador">denominador</b>.
Assim, se o <i>usuário</i> digitar apenas um valor, o programa ficará parado até
<!-- ⇒ = 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> => "inteiro"; <tt>f</tt> => "float"; <tt>c</tt> => "caractere"; <tt>s</tt> => "string".
Por exemplo, pode-se usar os comandos <br/>
<tt>
m = 2; f = 2.3; c = 'A';<br/>
<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/>
<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>