intr_prog/introducao_caracteres.html

<!--
Introdução aos caracteres
Prof. Leônidas de Oliveira Brandão
Material didático para apoio aos cursos de Introdução à Programação
Direitos reservados
Pode ser usado mediante citação de autoria (Prof. Leônidas de Oliveira Brandão) e origem (https://www.ime.usp.br/~leo/mac2166/introducao/)
Versao 2 [2018/04/28] Revisao, acerto no 2^8 (que estava 512...)
Versao 1 [2017/05/01]
-->

 <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 aos caracteres</p>

<!--
<center><p>[
 <a href="#erro">Erros</a> |
 <a href="#pontoflutuante">Ponto flutuante</a> | 
 <a href="#exemplo">Exemplo</a> | 
 <a href="#io">Entrada/saída</a></a>
 ]</p>
</center>
-->

<p>
  Nesta seção examinaremos resumidamente como utilizar caracteres tanto em <em>C</em> quanto em <em>Python</em>.
  Desse modo, quem está aprendendo uma das linguagens poderá aprender o funcionamento equivalente na outra.
</p>

<a name="caracteres"><span style="color: #0050A0">Representação como caractere</span></a>

<p>
Como citado na seção sobre 
<a href="#" onclick="trocaPagina('introducao_var.html')" title="variaveis">variáveis</a>, a informação básica
nos computadores digitais é uma sequência de <i>bits</i> e o contexto é quem indica como estes <i>bits</i> devem ser
interpretados.
Por exemplo, a sequência com 6 <i>bits</i> <tt>100001</tt>, poderia ser interpretada como um valor inteiro e
neste caso seria o valor 33, pois <tt>1*2^5 + 0*2^4 + 0*2^3 + 0*2^3 + 0*2^2 + 0*2^1 + 1*2^0 = 32+1 = 33</tt>.
Por outro lado, a mesma sequência poderia ser interpretada como um caractere, no caso o <tt>'!'</tt> (exclamação).
</p>

<p>
<!-- Um exemplo do problema numérico está ilustrado no exemplo abaixo, quando tentamos imprimir as somas de <tt>0.1</tt> -->
Assim as linguagens de programação possibilita a interpretação de uma sequência de <i>bits</i> como um caractere
(e.g. como uma letra ou um dígito).
Deste modo para apresentá-lo é preciso estabelecer uma tabela de conversão, por exemplo, que indique que a sequência
<tt>110000</tt> deve ser interpretada como o caracteres <tt>'0'</tt>, que corresponde ao decimal
<tt>1*2^5 + 1*2^4 + 0*2^3 + 0*2^3 + 0*2^2 + 0*2^1 + 0*2^0 = 32+16 = 48</tt>.
</p>

<a name="ascii">
<p class="subsecao">Código ASCII</p>
</a>

<p>
Um primeiro padrão para representar os caracteres é o 
<a href="https://en.wikipedia.org/wiki/ASCII" title="ver detalhes na WikiPedia"
   target="_blank"><b>American Standard Code for Information Interchange</b></a>.
O padrão ASCII é bastante antigo, ainda da década de 1960 e por isso utiliza um número reduzido de <i>bits</i>,
somente 8, o que possibilita a codificação de apenas <i>2<sup>8</sup>=256</i> símbolos distintos.
<!-- codigos/ -->
</p>

<center>
<a name="tab1">
<i>Tab. 1. Os 20 primeiros números naturais na base binária (0, 1) e correspondente decimal</i>
</a>
<br/>
<table><tr><td>
<table class="tbCodeLinCol">
 <tr><th>Binário</th> <th>Decimal</th></tr>
   <tr><td><tt>00000000</tt></td><td align="right"><tt>       0</tt></td></tr>
   <tr><td><tt>00000001</tt></td><td align="right"><tt>       1</tt></td></tr>
   <tr><td><tt>00000010</tt></td><td align="right"><tt>       2</tt></td></tr>
   <tr><td><tt>00000011</tt></td><td align="right"><tt>       3</tt></td></tr>
   <tr><td><tt>00000100</tt></td><td align="right"><tt>       4</tt></td></tr>
   <tr><td><tt>00000101</tt></td><td align="right"><tt>       5</tt></td></tr>
   <tr><td><tt>00000110</tt></td><td align="right"><tt>       6</tt></td></tr>
   <tr><td><tt>00000111</tt></td><td align="right"><tt>       7</tt></td></tr>
   <tr><td><tt>00001000</tt></td><td align="right"><tt>       8</tt></td></tr>
   <tr><td><tt>00001001</tt></td><td align="right"><tt>       9</tt></td></tr>
</table></td>
<td>    
<table class="tbCodeLinCol">
 <tr><th>Binário</th> <th>Decimal</th></tr>
   <tr><td><tt>00001010</tt></td><td align="right"><tt>      10</tt></td></tr>
   <tr><td><tt>00001011</tt></td><td align="right"><tt>      11</tt></td></tr>
   <tr><td><tt>00001100</tt></td><td align="right"><tt>      12</tt></td></tr>
   <tr><td><tt>00001101</tt></td><td align="right"><tt>      13</tt></td></tr>
   <tr><td><tt>00001110</tt></td><td align="right"><tt>      14</tt></td></tr>
   <tr><td><tt>00001111</tt></td><td align="right"><tt>      15</tt></td></tr>
   <tr><td><tt>00010000</tt></td><td align="right"><tt>      16</tt></td></tr>
   <tr><td><tt>00010001</tt></td><td align="right"><tt>      17</tt></td></tr>
   <tr><td><tt>00010010</tt></td><td align="right"><tt>      18</tt></td></tr>
   <tr><td><tt>00010011</tt></td><td align="right"><tt>      19</tt></td></tr>
</table></td></tr>
</table></center>
</p>



<p>
Como o padrão <i>ASCII</i> foi criado nos Estados Unidos e a lingua Inglesa não utiliza símbolos especiais,
na pratica eles utilizavam apenas 7 <i>bits</i>, ou seja, usavam 128 diferentes caracteres.
<!--
Como o código ASCII foi baseado no alfabeto em lingua Inglesa, eles presentam apenas caracteres sem acentos.
Usualmente associamos um natural a cada símbolo, assim no ASCII pode-se associar caracteres aos <b>códigos ASCII</b>
0 até 256. -->
</p>

<p>
Como exemplos de código ASCII a letra 'A' é associada ao natural 65, o 'B' ao 66 e assim por diante.
Do mesmo modo, o 'a' é associada ao natural 97 e o caractere 'z' ao 122.
Já o natural 48 é associado do dígito '0', o 49 ao '1' e assim por diante até o 57 associado '9'.
</p>


<a name="io">
<p class="subsecao">Entrada e saída de caracteres em <i>C</i> e em <i>Python</i></p>
</a>

<p>
Como já citado nas outras seções, o contexto deve definir como sequências de <i>bits</i> devem ser tratadas.
Para tratar um conjunto <i>bits</i> como caractere deve-se indicar isso ao computador de alguma forma.
Por exemplo, as linguagens de programação geralmente dispõem de um tipo de variável especial para caracteres.
<!--
Tanto a linguagem <i>C</i> como a linguagem <i>Python</i> dispõe um tipo especial variável para tratar com caracteres.
-->
</p>

<p> 
Na linguagem <i>C</i> existe o tipo <tt>char</tt> e tanto para leitura quanto para impressão, utiliza-se o formatador
<tt>%c</tt>. Mas pode-se imprimir uma variável <tt>char</tt> como se fosse um número inteiro e vice-versa,
neste caso usa-se seu código ASCII.
</p>

<p> 
Já em <i>Python 2</i> é preciso de uma função especial para leitura de caracteres, a função <tt>raw_input()</tt>.
Na impressão, se não for usada impressões especiais, não é preciso qualquer diferenciação, pois o <i>Python</i>
aplica um filtro para tratar se a variávem sendo impressa é inteira, flutuante ou caractere.
Vide  <a href="#tab2">tabela</a> abaixo.
</p>
<center>
<a name="tab2">
<i>Tab. 2. Sobre a leitura de caracteres em <i>C</i> e em <i>Python</i></i>
</a>
<br/>
<table class="tbCodeLinCol">
 <tr><th>C </th> <th>Python 2</th> <th>Python 3</th></tr>
 <tr valign="top"><td><table class="tbCode">
   <tr><td><pre>char x; // declaracao de variavel para armazenar caracteres
scanf("%c", &x); // leia como "caractere"
printf("%c", x); // imprima como "caractere"
</pre></td></tr>
 </table></td>
 <td><table class="tbCode"><pre># Vale notar: se o usuario digitar uma "string", como
# "nome", a variavel x recebera' a "string" toda
x = raw_intput(); # leia como "caractere"
print(x);

</pre></td></tr>
   </table></td>
 <td><table class="tbCode"><pre># Vale notar: se o usuario digitar uma "string", como
# "nome", a variavel x recebera' a "string" toda
x = intput(); # leia como "caractere"
print(x);

</pre></td></tr>
   </table></td>
   </tr>
</table></center>
</p>

<a name="constantes">
<p class="subsecao">Constantes do tipo caractere em <i>C</i> e em <i>Python</p>
</a>

<p>
Assim como várias outras linguagens, <i>C</i> e <i>Python</i>, adotam o uso de apóstrofes para
indicar que deve pegar o caractere entre os apóstrofes.
Por exemplo, para atribuir a constante 'a' à uma variável do tipo caractere, de nome <tt>varc</tt>,
deve-se usar
<center><tt>varc = 'a';</tt> (o finalizador ';' é opcional em <i>Python</i>).</center>
<br/>
A necessidade de um marcador pode ser facilmente entendida ao escrevermos o código
<tt>varc = a;</tt>, que corresponde a guardar o valor atual da variável <i>a</i> na variável <i>varc</i>.
</p>

<p> 
Abaixo um exemplo de código que imprime primeiro o caractere associado ao código ASCII dado e depois
o contrário. Ao rodar este código será impresso os caracteres de código 48, 49, 97, 98, 65 e 66, respectivamente
'0', '1', 'a', 'b', 'A' e 'B'.
<center>
<i>Tab. 3. Sobre conversão entre o caractere ASCII e seu código inteiro</i>
<br/>
<table class="tbCodeLinCol">
 <tr><th>C </th> <th>Python 2</th></tr>
 <tr valign="top"><td><table class="tbCode">
   <tr><td><pre>#include &lt;stdio.h&gt;
int main (void) {
  int          // Criando 6 variaveis como (implicitamente) do tipo "int".
    val1 = 48, // Cada variavel recebera um valor inteiro que depois sera'
    val2 = 49, // interpretado como caractere.
    num1 = 97, //
    num2 = 98, //
    Num1 = 65, //
    Num2 = 66; //
  char            // Declarando variaveis tipo caractere
    charN1 = '0', // NOTE que para constantes do tipo
    charN2 = '1', // caractere, deve-se usar aspa simples
    Char1  = 'A', //
    Char2  = 'B', //
    char1  = 'a', //
    char2  = 'b'; //
  printf(" int | codigo\n"); // '\n' usado para forcar quebra de linha na impressao
  printf("  %d | %c\n", val1, val1);
  printf("  %d | %c\n", val2, val2);
  printf("  %d | %c\n", num1, num1);
  printf("  %d | %c\n", num2, num2);
  printf("  %d | %c\n", Num1, Num1);
  printf("  %d | %c\n", Num2, Num2);
  printf(" int | codigo\n");
  printf(" %c | %d\n", charN1, charN1);
  printf(" %c | %d\n", charN2, charN2);
  printf(" %c | %d\n", char1,  char1);
  printf(" %c | %d\n", char2,  char2);
  printf(" %c | %d\n", Char1,  Char1);
  printf(" %c | %d\n", Char2,  Char2);
  return 0;
  }</pre></td></tr>
 </table></td>
 <td><table class="tbCode"><pre>def main():
  val1 = 48 # Criando 6 variaveis como (implicitamente) do tipo "int".
  val2 = 49 # Cada variavel recebera um valor inteiro que depois sera'
  num1 = 97 # interpretado como caractere.
  num2 = 98 #
  Num1 = 65 #
  Num2 = 66 #
  print(" int | codigo")
  print(" ", val1, " | ", chr(val1)) # A funcao chr(...) devolve
  print(" ", val2, " | ", chr(val2)) # o caractere associado ao
  print(" ", num1, " | ", chr(num1)) # codigo ASCII dado
  print(" ", num2, " | ", chr(num2))
  print(" ", Num1, " | ", chr(Num1))
  print(" ", Num2, " | ", chr(Num2))
  charN1 = '0' # NOTE que para constantes do tipo
  charN2 = '1' # caractere, deve-se usar aspa simples
  Char1 = 'A' #
  Char2 = 'B' #
  char1 = 'a' #
  char2 = 'b' #
  print(" int | codigo")
  print("  ", charN1, " | ", ord(charN1)) # A funcao ord(...) devolve
  print("  ", charN2, " | ", ord(charN2)) # o codigo ASCII do caractere dado
  print("  ", char1, " | ", ord(char1))
  print("  ", char2, " | ", ord(char2))
  print("  ", Char1, " | ", ord(Char1))
  print("  ", Char2, " | ", ord(Char2))
main()</pre></td></tr>
   </table></td></tr>
</table></center>
</p>

<a name="tabela">
<p class="subsecao">Como gerar uma tabelas ASCII em <i>C</i> e em <i>Python</p>
</a>

<p>
  Vale destacar que a codificação dos caracteres segue uma organização lógica, uma vez que o código para o
  caractere <i>0</i> é o <i>48</i>, então o <i>49</i> é para o <i>1</i> e assim por diante. Do mesmo modo, sendo
  <i>65</i> o código do caractere <i>A</i>, <i>66</i> é o caractere <i>B</i> e assim por diante.
</p>

<p>
  Assim, podemos fazer um código para gerar tabelas dos caracteres e seu código ASCII, como ilustrado
  abaixo. Experimente alterar os limites do controle do laço, mas cuidado com os caracteres especiais, alguns
  podem "quebrar" linhas ou corresponder a outros caracteres de controle que podom deixar a tela "suja".
</p>

<p>
  Em <i>C</i> a converção entre inteiro ou caractere é praticamente direta, bastando usar o formatador correto
  (<tt>%d</tt> para inteiro ou <tt>%c</tt> para caractere). Entretanto em <i>Python</i> é necessário
  usar duas funções pré-definidas para isso, <tt>ord(inteiro)</tt> e <tt>chr(caractere)</tt>:
  sendo <tt>i</tt> inteiro, <tt>chr(i)</tt> fornece o caractere cujo código é <tt>i</tt>;
  sendo <tt>c</tt> caractere, <tt>ord(c)</tt> fornece o código do caractere <tt>c</tt>.
</p>

<center>
Tab. 4. Como imprimir uma tabela código ASCII e o correspondente caractere<br/>
<table class="tbCodeLinCol">
 <tr><th>C </th> <th>Python 2</th></tr>
 <tr valign="top"><td><table class="tbCode">
   <tr><td><pre>#include &lt;stdio.h&gt;
int main (void) {
  int i, ini = 48, fim = 58;
  printf("cod. : car.\n");
  for (i=ini; i&lt;fim; i++)
    printf(" %3d :  %3c\n", i, i);
  printf("------------\n");
  ini = 65; fim = 91;
  for (i=ini; i&lt;fim; i++)
    printf(" %3d :  %3c\n", i, i);
  printf("------------\n");
  ini = 97; fim = 123;
  for (i=ini; i&lt;fim; i++)
    printf(" %3d :  %3c\n", i, i);
  printf("------------\n");   
  return 0;
  }</pre></td></tr>
 </table></td>
 <td><table class="tbCode"><pre>def main () :
  ini = 48; fim = 58;
  print("cod. : car.\n");
  for i in range(ini, fim) :
    print(" %3d :  %3c" % (i, chr(i)));
  print("------------\n");
  ini = 65; fim = 91;
  for i in range(ini, fim) :
    print(" %3d :  %3c" % (i, chr(i)));
  print("------------");
  ini = 97; fim = 123;
  for i in range(ini, fim) :
    print(" %3d :  %3c" % (i, chr(i)));
  print("------------");
     
main();</pre></td></tr>
   </table></td></tr>
</table></center>
</p>

<p>
  Primeiro notem que usamos os formatadores <tt>%3d</tt> e <tt>%3c</tt> para ajustar 3 colunas à
  direita, o que é bastante útil para imprimir tabelas.
  O <tt>%d</tt> é utilizado para imprimir inteiro, enquanto <tt>%c</tt> para caractere,
  tanto em <i>C</i>, quanto em <i>Python</i>.
  Logo após a cadeia de caracteres, com eventuais valores a serem substituidos, deve vir uma
  lista de variáveis/valores compatíveis. No exemplo, a cadeia era formada por
  <tt>" %3d :  %3c"</tt>, portanto deveria vir a seguir 2 valores, o primeiro inteiro e o segundo caractere.
</p>
<p> 
  Entretanto existe uma diferença na sintaxe das duas linguagens, em <i>C</i> a lista de parâmetros vem
  separadas por vírgula simples, mas em <i>Python</i> precisa do símbolo de percentagem (<tt>%</tt>) após
  a cadeia de caracteres
  (<tt>" %3d :  %3c"</tt>) e, havendo mais de um valor a substituir, deve-se usar a sintaxe de
  <i>lista</i> (<tt>(i, chr(i))</tt>).
</p>

<p>
  Note que o <i>Python</i> precisa de uma função especial para conveter inteiro em caractere,
  <tt>chr(i)</tt>, que devolve o caractere cujo código seja o valor armazenado na variável <i>i</i>
  (que deve ser inteira).
  Para fazer o oposto deve-se usar a função <tt>ord(varc)</tt> que é a função que devolve o código
  ASCII (<i>ord</i>enado) do caractere armazenado na variável <i>varc</i> (que neste caso deve ser
  para caractere - <i>char</i>).
</p>

<p>
<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/19: novo formato, pequenas correções<br/>
    2019/04/18: acerto '0010'=4 para '100001'=33, explicita funções <tt>ord</tt> e <tt>chr</tt>)<br/>
    2018/04/28: acertos no texto (valor 2^8) e cortada a parte sobre numero em ponto flutuante<br/>
    2017/05/01: primeira versão
</p>

</div>