# Conversões de Tipos

<address class="author">
  <a href="https://daltonserey.github.io/prog1">Dalton Serey</a>
</address>

Frequentemente, é necessário lidar com conversões de tipos de
dados. Em algumas situações, a própria linguagem faz
conversões automaticamente. Em outras, temos que tratar
o assunto explicatamente. Nesta lição veremos como Python lida
com conversões entre os tipos fundamentais da linguagem:
`int`, `float` e `string`. 


## Conversões implícitas

Em geral, esta é a conversão mais comum com as quais o
programador vai se defrontar. Ela ocorre sempre que for
necessário operar um valor do tipo `int` com um do tipo `float`.
Internemente, contudo, para que a operação possa ser executada
pela máquina, é necessário que os dois operandos sejam do mesmo
tipo. A questão é: qual conversão você acha que a linguagem deve
fazer? Vejamos as alternativas. 

Considere, por exemplo, que a operação `3 + 2.5` tenha que
ser realizada. Como já dissemos, não há como a CPU somar um
valor inteiro e um valor de ponto flutuante. Logo, a
linguagem precisa converter um dos valores para o outro tipo.
As opções seriam:

1. converter o segundo operando para `int`; isso significa
que o resultado da operação `3 + 2.5` seria possível para
Python, se solicitar à CPU que faça a operação `3 + 2`; o
resultado, portanto, seria `5`;

2. converter o primeiro operando para o tipo `float`; isso
significa que o resultado da operação `3 + 2.5` seria
possível para Python, solicitando à CPU que faça a operação
`3.0 + 2.5`; e o resultado, portanto, seria `5.5`;

Claramente a segunda opção é mais razoável para nosso
entendimento. E é essa a opção que Python faz. A regra é: sempre que
uma operação algébrica envolvendo um `int` e um `float` for ser
executada, o operando `int` será _implicitamente_ convertido para
`float` (em geral, conversões implícitas são denominadas de
_coerções_).


## Conversões explícitas

Muitas vezes, contudo, é conveniente e necessário fazer
conversões explicitamente. Às vezes queremos apenas a parte
inteira de uma divisão ou de uma expressão algébrica qualquer.
Nesse caso, as linguagens nos oferecem meios de produzir um valor
de um tipo específico a partir de outro. Não é raro que
precisemos converter inteiros nos valores equivalentes em ponto
flutuante ou vice-versa. Mais adiante você verá que
frequentemente precisaremos converter entre números e _strings_.


## Conversões Explícitas de Tipo

É para isso que existem as funções `int()`, `float()` e `str()`.
Elas permitem escrever expressões que convertem os valores
passados como argumentos para o tipo indicado pelo nome de cada
função. Assim, embora a expressão `3 / 2` resulte no ponto
flutuante 1,5, a expressão `int(3 / 2)` produz o inteiro 1.

> Atenção. Em Python 2, o operador `/` faz a divisão inteira.
> Isso quer dizer que a expressão `3 / 2` produz `1`. Isso era
> fonte de muita confusão. Por isso, perceba que o operador `/`,
> em Python 3, _sempre_ produz um ponto flutuante. Mesmo que os
> dois operandos sejam inteiros. Assim, `4 / 2` produz o ponto
> flutuante que representa 2,0. Em compensação, Python 3 introduz
> o operador `//` que permite fazer a divisão inteira.


Conceitualmente, podemos chamar de _cast_ o efeito das funções de
conversão de tipo de Python, dado que se trata de uma conversão
explícita de tipo. Tecnicamente, contudo, o que ocorre não é
exatamente o que se costuma chamar de _cast_ (principalmente na
linguagem C) e o nome pode enganar. Por isso, muitas vezes é
preferível dizer simplesmente conversão de tipo.

<script type="module">
    import { set_virtual_name } from "../assets/js/app.js";
    set_virtual_name("numeros_e_variaveis");
</script>