Números Python, Conversão de Tipos e Matemática

Números Python, conversão de tipo e matemática

Neste artigo, você aprenderá sobre os diferentes números usados ​​em Python, como converter de um tipo de dados para outro e as operações matemáticas suportadas em Python.

Tipo de dados numérico em Python

Python suporta números inteiros, números de ponto flutuante e números complexos. Eles são definidos como int , float e complex aulas em Python.

Os inteiros e os pontos flutuantes são separados pela presença ou ausência de um ponto decimal. Por exemplo, 5 é um número inteiro enquanto 5.0 é um número de ponto flutuante.

Os números complexos são escritos na forma, x + yj , onde x é a parte real e y é a parte imaginária.

Podemos usar o type() função para saber a qual classe uma variável ou valor pertence e isinstance() função para verificar se ele pertence a uma determinada classe.

Vejamos um exemplo:

a = 5

print(type(a))

print(type(5.0))

c = 5 + 3j
print(c + 3)

print(isinstance(c, complex))

Quando executamos o programa acima, obtemos a seguinte saída:

<class 'int'>
<class 'float'>
(8+3j)
True

Embora os números inteiros possam ter qualquer comprimento, um número de ponto flutuante é preciso apenas até 15 casas decimais (a 16ª casa é imprecisa).

Os números com os quais lidamos todos os dias são do sistema numérico decimal (base 10). Mas os programadores de computador (geralmente programadores embarcados) precisam trabalhar com sistemas numéricos binários (base 2), hexadecimais (base 16) e octal (base 8).

Em Python, podemos representar esses números colocando adequadamente um prefixo antes desse número. A tabela a seguir lista esses prefixos.

Sistema Numérico	Prefixo
Binário	'0b' ou '0B'
Octal	'0o' ou '0O'
Hexadecimal	'0x' ou '0X'

Aqui estão alguns exemplos

# Output: 107
print(0b1101011)

# Output: 253 (251 + 2)
print(0xFB + 0b10)

# Output: 13
print(0o15)

Ao executar o programa, a saída será:

107
253
13

---

Conversão de tipo

Podemos converter um tipo de número em outro. Isso também é conhecido como coação.

Operações como adição, subtração forçam o inteiro a flutuar implicitamente (automaticamente), se um dos operandos for float.

>>> 1 + 2.0
3.0

Podemos ver acima que 1 (inteiro) é coagido em 1.0 (float) para adição e o resultado também é um número de ponto flutuante.



Também podemos usar funções internas como int() , float() e complex() para converter explicitamente entre tipos. Essas funções podem até converter de strings.

>>> int(2.3)
2
>>> int(-2.8)
-2
>>> float(5)
5.0
>>> complex('3+5j')
(3+5j)

Ao converter de float para inteiro, o número fica truncado (as partes decimais são removidas).

---

Decimal Python

A classe interna do Python float realiza alguns cálculos que podem nos surpreender. Todos nós sabemos que a soma de 1,1 e 2,2 é 3,3, mas Python parece discordar.

>>> (1.1 + 2.2) == 3.3
False

O que está acontecendo?

Acontece que os números de ponto flutuante são implementados no hardware do computador como frações binárias, pois o computador só entende binário (0 e 1). Por esse motivo, a maioria das frações decimais que conhecemos não pode ser armazenada com precisão em nosso computador.

Vamos dar um exemplo. Não podemos representar a fração 1/3 como um número decimal. Isso dará 0,33333333... que é infinitamente longo, e só podemos aproximá-lo.

Acontece que a fração decimal 0,1 resultará em uma fração binária infinitamente longa de 0,000110011001100110011... e nosso computador armazena apenas um número finito dela.

Isso só se aproximará de 0,1, mas nunca será igual. Portanto, é a limitação do hardware do nosso computador e não um erro em Python.

>>> 1.1 + 2.2
3.3000000000000003

Para superar esse problema, podemos usar o módulo decimal que vem com o Python. Enquanto os números de ponto flutuante têm precisão de até 15 casas decimais, o módulo decimal tem precisão configurável pelo usuário.

Vamos ver a diferença:

import decimal

print(0.1)

print(decimal.Decimal(0.1))

Saída

0.1
0.1000000000000000055511151231257827021181583404541015625

Este módulo é usado quando queremos realizar cálculos decimais como aprendemos na escola.

Também preserva o significado. Sabemos que 25,50 kg é mais preciso do que 25,5 kg, pois tem duas casas decimais significativas em comparação com uma.

from decimal import Decimal as D

print(D('1.1') + D('2.2'))

print(D('1.2') * D('2.50'))

Saída

3.3
3.000

Observe os zeros à direita no exemplo acima.

Podemos perguntar, por que não implementar Decimal cada vez, em vez de flutuar? A principal razão é a eficiência. As operações de ponto flutuante são realizadas mais rápido que Decimal operações.

Quando usar Decimal em vez de float?

Geralmente usamos Decimal nos seguintes casos.

• Quando estamos fazendo aplicativos financeiros que precisam de representação decimal exata.
• Quando queremos controlar o nível de precisão necessário.
• Quando queremos implementar a noção de casas decimais significativas.

---

Frações Python

Python fornece operações envolvendo números fracionários por meio de seu fractions módulo.

Uma fração tem um numerador e um denominador, ambos inteiros. Este módulo tem suporte para aritmética de números racionais.

Podemos criar objetos Fraction de várias maneiras. Vamos dar uma olhada neles.

import fractions

print(fractions.Fraction(1.5))

print(fractions.Fraction(5))

print(fractions.Fraction(1,3))

Saída

3/2
5
1/3

Ao criar Fraction de float , podemos obter alguns resultados incomuns. Isso se deve à representação de número de ponto flutuante binário imperfeito, conforme discutido na seção anterior.

Felizmente, Fraction nos permite instanciar com string também. Esta é a opção preferida ao usar números decimais.

import fractions

# As float
# Output: 2476979795053773/2251799813685248
print(fractions.Fraction(1.1))

# As string
# Output: 11/10
print(fractions.Fraction('1.1'))

Saída

2476979795053773/2251799813685248
11/10

Este tipo de dados suporta todas as operações básicas. Aqui estão alguns exemplos.

from fractions import Fraction as F

print(F(1, 3) + F(1, 3))

print(1 / F(5, 6))

print(F(-3, 10) > 0)

print(F(-3, 10) < 0)

Saída

2/3
6/5
False
True

---

Matemática Python

Python oferece módulos como math e random para realizar diferentes matemáticas como trigonometria, logaritmos, probabilidade e estatística, etc.

import math

print(math.pi)

print(math.cos(math.pi))

print(math.exp(10))

print(math.log10(1000))

print(math.sinh(1))

print(math.factorial(6))

Saída

3.141592653589793
-1.0
22026.465794806718
3.0
1.1752011936438014
720

Aqui está a lista completa de funções e atributos disponíveis no módulo de matemática Python.

import random

print(random.randrange(10, 20))

x = ['a', 'b', 'c', 'd', 'e']

# Get random choice
print(random.choice(x))

# Shuffle x
random.shuffle(x)

# Print the shuffled x
print(x)

# Print random element
print(random.random())

Quando executamos o programa acima, obtemos a saída da seguinte forma. (Os valores podem ser diferentes devido ao comportamento aleatório)

18
e
['c', 'e', 'd', 'b', 'a']
0.5682821194654443

Aqui está a lista completa de funções e atributos disponíveis no módulo aleatório do Python.