Python como calculadora

Operadores matemáticos

A linguagem Python possui operadores que utilizam símbolos especiais para representar operações de cálculos, assim como na matemática:

  • Soma (\(+\))

    >>> 2 + 3
    5
    

    Para utilizar números decimais, use o ponto no lugar de vírgula:

    >>> 3.2 + 2.7
    5.9
    
  • Subtração (\(-\))

    >>> 6 - 4
    2
    
    >>> 7 - 8
    -1
    
  • Multiplicação (\(*\))

    >>> 7 * 8
    56
    
    >>> 2 * 2 * 2
    8
    
  • Divisão (\(/\))

    >>> 100 / 20
    5.0
    
    >>> 10 / 3
    3.3333333333333335
    

    E se fizermos uma divisão por zero?

    >>> 2 / 0
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ZeroDivisionError: division by zero
    

    Como não existe um resultado para a divisão pelo número zero, o Python interrompe a execução do programa (no caso a divisão) e mostra o erro que aconteceu, ou seja, «ZeroDivisionError: divison by zero».

  • Divisão inteira (\(//\))

    >>> 10 // 3
    3
    >>> 666 // 137
    4
    >>> 666 / 137
    4.861313868613139
    
  • Resto da divisão (\(\%\))

    >>> 10 % 2
    0
    >>> 10 % 3
    1
    >>> 666 % 137
    118
    

Agora que aprendemos os operadores aritméticos básicos podemos seguir adiante. Como podemos calcular \(2^{10}\)? O jeito mais óbvio seria multiplicar o número dois dez vezes:

>>> 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2
1024

Porém, isso não é muito prático, pois há um operador específico para isso, chamado de potenciação/exponenciação: \(**\)

>>> 2 ** 10
1024
>>> 10 ** 3
1000
>>> (10 ** 800 + 9 ** 1000) * 233
407254001651377825050774086265365912933271559572398924650169906751889900030955189004916347478470698880616885512201849445183728845558993514870858509087817789576388584560964682795896403435448681980001360244790530805842737419978616650940647045809688543958807077794866143976192872389017280782837244051514550016751431331392474612723898201318251801288569103581859710953756463227568553903785400053293756105145991925711692828410365978814157929143646138367222515290495329841814490874087309733954914817582614165290441834984054374534909954119315442169415884429645515258867781282214407424938115130906555866837546110340314133204645184212592152733050063403478054121909337278892530383627259086060904403894148963384111173869448637825223750221720739904084905206403076141255284819817001128530851921214720479861908207168928806625713775441834487646542035428141369478170696522098960677314242891140325390964310295889079588950798788612324634050495786532200848059999839607732520233

E a raiz quadrada?

Lembrando que \(\sqrt{x} = x^\frac{1}{2}\), então podemos calcular a raiz quadrada do seguinte modo:

>>> 4 ** 0.5
2.0

Mas a maneira recomendada para fazer isso é usar a função sqrt() da biblioteca math:

>>> import math
>>> math.sqrt(16)
4.0

Na primeira linha do exemplo importamos, da biblioteca padrão do Python, o módulo math e então usamos a sua função sqrt para calcular \(\sqrt{16}\)

E se precisarmos utilizar o número \(\pi\)?

>>> math.pi
3.141592653589793

Não esqueça que é preciso ter executado import math antes de usar as funções e constantes dessa biblioteca.

Exercícios

  1. Calcule o resto da divisão de 10 por 3.

  2. Calcule a tabuada do 13.

  3. Davinir não gosta de ir às aulas. Mas ele é obrigado a comparecer a pelo menos 75% delas. Ele quer saber quantas aulas pode faltar, sabendo que tem duas aulas por semana, durante quatro meses. Ajude o Davinir!

    Nota

    Um mês tem quatro semanas.

  4. Calcule a área de um círculo de raio \(r = 2\).

    Lembrete: a área de um círculo de raio \(r\) é:

    \[A_\circ = \pi \, r^2\]

Expressões Numéricas

Agora que já aprendemos diversos operadores, podemos combiná-los e resolver problemas mais complexos:

>>> 3 + 4 * 2
11
>>> 7 + 3 * 6 - 4 ** 2
9
>>> (3 + 4) * 2
14
>>> (8 / 4) ** (5 - 2)
8.0

Quando mais de um operador aparece em uma expressão, a ordem de avaliação depende das regras de precedência.

O Python segue as mesmas regras de precedência da matemática. O acrônimo PEMDAS ajuda a lembrar essa ordem:

  1. Parênteses

  2. Exponenciação

  3. Multiplicação e Divisão (mesma precedência)

  4. Adição e Subtração (mesma precedência)

Notação Científica

Notação científica em Python usa a letra e como sendo a potência de 10:

>>> 10e6
10000000.0
>>> 1e6
1000000.0
>>> 1e-5
1e-05

Também pode ser usada a letra E maiúscula:

>>> 1E6
1000000.0

Pontos Flutuantes

Uma consideração importante sobre pontos flutuantes (números decimais). Por exemplo:

>>> 0.1
0.1

É importante perceber que este valor, em um sentido real na máquina, não é exatamente 1/10. Está arredondando a exibição do valor real da máquina.

>>> format(0.1, '.50f')
'0.10000000000000000555111512312578270211815834045410'

Veja que somente após a 18ª casa que há diferença. Isso é mais dígitos do que a maioria das pessoas acham úteis, então o Python mantém o número de dígitos gerenciáveis exibindo um valor arredondado

Este fato se torna aparente assim que você tenta fazer aritmética com esses valores

>>> 0.1 + 0.2
0.30000000000000004

>>> 0.7 - 0.2
0.49999999999999994

Note que isso é da mesma natureza do ponto flutuante binário, não é um bug no Python e muito menos um bug no seu código. Você verá o mesmo tipo de coisa em todos os idiomas que suportam a aritmética de ponto flutuante de seu hardware (embora alguns idiomas possam não exibir a diferença por padrão ou em todos os modos de saída).

Os erros de representação referem-se ao fato de que a maioria das frações decimais não podem ser representadas exatamente como frações binárias (base 2). Essa é a principal razão pela qual o Python (ou Perl, C, C++, Java, Fortran e muitos outros) geralmente não exibe o número decimal exato que é esperado.

O valor de 1/10 não é exatamente representável como uma fração binária. Quase todas as máquinas atualmente (considerando após novembro de 2000) usam aritmética de ponto flutuante IEEE-754, e quase todas as plataformas mapeiam pontos flutuantes do Python para a «dupla precisão» IEEE-754, que contêm 53 bits de precisão. Portanto, na entrada, o computador se esforça para converter 0.1 na fração mais próxima possível da forma J/2 ** N, onde J é um inteiro contendo exatamente 53 bits.

Exercícios

  1. Quantos segundos há em 3 horas, 23 minutos e 17 segundos?

  2. Se você correr 65 quilômetros em 3 horas, 23 minutos e 17 segundos, qual é a sua velocidade média em m/s?

  3. Resolva essa expressão:

    \[\frac{100 - 413 \cdot (20 - 5 \times 4)}{5}\]
  4. Enivaldo quer ligar três capacitores, de valores:

    • \(C_1 = 10 \, \mu F\)

    • \(C_2 = 22 \, \mu F\)

    • \(C_3 = 6.8\, \mu F\)

    Se ele ligar os três em paralelo, a capacitância resultante é a soma:

    \[C_p = C_1 + C_2 + C_3\]

    Se ele ligar os três em série, a capacitância resultante é:

    \[\frac{1}{C_s} = \frac{1}{C_1} + \frac{1}{C_2} + \frac{1}{C_3}\]

    Ou seja:

    \[C_s = \frac{1}{\frac{1}{C_1} + \frac{1}{C_2} + \frac{1}{C_3}}\]

    Qual é o valor resultante em cada um desses casos?

  5. Você e os outros integrantes da sua república (Joca, Moacir, Demival e Jackson) foram no supermercado e compraram alguns itens:

    • 75 latas de cerveja: R$ 2,20 cada (da ruim ainda, pra fazer o dinheiro render)

    • 2 pacotes de macarrão: R$ 8,73 cada

    • 1 pacote de Molho de tomate: R$ 3,45

    • 420g Cebola: R$ 5,40/kg

    • 250g de Alho: R$ 30/kg

    • 450g de pães franceses: R$ 25/kg

    Calcule quanto ficou para cada um.

  6. Krissia gosta de bolinhas de queijo. Ela quer saber quantas bolinhas de queijo dá para colocar dentro de um pote de sorvete de \(2\, L\). Ela pensou assim:

    Um pote de sorvete tem dimensões 15 cm x 10 cm x 13 cm. Uma bolinha de queijo é uma esfera de raio r = 1.2 cm. O fator de empacotamento ideal é 0.74, mas o pote de sorvete tem tamanho comparável às bolinhas de queijo, aí tem efeitos de borda, então o fator deve ser menor. Mas as bolinhas de queijo são razoavelmente elásticas, então empacota mais. Esse valor parece razoável.

    Sabendo que o volume de uma esfera de raio \(r\) é \(V = \frac{4}{3} \pi r^3\), o volume do pote de sorvete é \(V = x \cdot y \cdot z\) e o fator de empacotamento é a fração de volume ocupado pelas bolinhas de queijo. Ou seja, \(74 \%\) do pote de sorvete vai ser ocupado pelas bolinhas de queijo.

    Ajude a Krissia descobrir quantas bolinhas de queijo cabem no pote de sorvete!

Sobre Comentários

Caso precise explicar alguma coisa feita no código, é possível escrever um texto (que não será executado), que ajuda a entender ou lembrar o que foi feito. Esse texto é chamado de comentário, e para escrever um basta utilizar o caractere #. Exemplo:

>>> 3 + 4  # será lido apenas o cálculo, do # para frente o interpretador do Python irá ignorar!
7
>>> # Aqui vai um código só com comentários! Posso falar o que quiser que não será interpretado, lalala, la-le-li-lo-lu. A job we hate to buy things we don't need.

Comparações

Os operadores de comparação em Python são:

Operação

Significado

<

menor que

<=

menor igual que

>

maior que

>=

maior igual que

==

igual

!=

diferente

>>> 2 < 10
True
>>> 2 > 11
False
>>> 10 > 10
False
>>> 10 >= 10
True
>>> 42 == 24
False
>>> 666 != 137
True
>>> 8**2 == 60 + 4
True
>>> 100 != 99 + 3
True