Ver Feed RSS

[email protected]:/# chmod o+r *

[Curso de Python] Tipos Built-In - Parte 2

Avalie este Post de Blog

Antes de prosseguir leia os artigos anteriores aqui



Na última aula começamos a analisar os tipos built-in um por um. Vimos os tipos None, NotImplemented e o Ellipsis. Hoje daremos continuidade nesse estudo. Hoje veremos rapidamente os tipos numéricos.

Tipos Built-In - Parte 2




Retomando a lista dos tipos built-in:

  • None;
  • NotImplemented;
  • Ellipsis;
  • Numericos:
    • int;
    • long;
    • float;
    • bool;
    • complex;

  • Sequências Imutáveis:
    • str;
    • unicode;
    • tuple;

  • Sequências Mutáveis:
    • list;
    • bytearray;

  • Sets:
    • set;
    • frozenset;

  • Mapeamentos:
    • dict;

  • slice;
  • callable;
  • file;



Os tipos numéricos já foram brevemente abordados em aulas passadas, então comentarei um pouco mais sobre eles.


Int

Inicialmente temos o tipo inteiro identificado pela palavra int. Esse tipo representa um número inteiro, positivo ou negativo, nulo ou não-nulo que esteja entre -2147483648 e 2147483647. Caso uma operação matemática gere um número que extrapola essa faixa, ele é automaticamente retornado como um inteiro Longo (em alguns casos pode ocorrer o erro OverflowError).

Código python:
>>> type(12)
<type 'int'>
>>> 12**8
429981696
>>> 12**9
5159780352L
>>> type(12**9)
<type 'long'>
>>>



Long

Os números inteiros longos não estão restritos a uma faixa (como os inteiros), estão restritos somente à disponibilidade de memória virtual. Isto quer dizer que o interpretador do Python aloca espaços de memória dinamicamente possibilitando ter números de tamanhos incríveis. Quando necessário, o resultado de uma operação é automaticamente adaptado para um inteiro longo. Em um sistema de 32 bits o número 2.147.483.647 é o menor inteiro simples disponível.

Código python:
>>> int_simples = 10**9
>>> int_simples
1000000000
>>> type(int_simples)
<type 'int'>
>>>
>>> int_longo = 10**10
>>> int_longo
10000000000L
>>> type(int_longo)
<type 'long'>
>>>

O processo inverso não ocorre naturalmente, é necessário converter manualmente o inteiro longo para inteiro simples.
Código python:
>>> resultado = 10000000000L/100
>>> resultado
100000000L
>>> type(resultado)
<type 'long'>
>>> int(resultado)
100000000
>>> type(int(resultado))
<type 'int'>
>>>



Curiosidade

Uma curiosidade sobre os números é que eles podem ser escritos de forma binário ou hexadecimal. para escrever um número no modo binário basta preceder o número por 0b. Segue alguns exemplos:
Código python:
>>> 0b101111
47
>>> 0b011
3
>>> 0b111011111000011
30659

Para escrever um número em hexadecimal, utilizamos a notação 0x antes do número. Segue alguns exemplos:
Código python:
>>> 0xff
255
>>> 0x0a
10
>>>


Outra forma de se obter números através de representações binárias/hexadecimais é utilizar o construtor int:
Código python:
>>> print int('01010101111',2)
687
>>> int('1010', 2)
10
>>>
>>> int('ff', 16)
255
>>> int('b', 16)
11
>>>

Como podemos ver basta informar o número na forma de string e informar posteriormente a base numérica (2 para binário e 16 para hexadecimal).

Também é possível criar uma representação binária de um número inteiro comum. Note que o resultado é uma string:
Código python:
>>> bin(173)
'0b10101101'


Para criar uma representação hexadecimal de um número inteiro comum utilize a função hex:
Código python:
>>> hex(111)
'0x6f'
>>> hex(255)
'0xff'
>>> hex(14)
'0xe'
>>>



Float

O tipo float, são números que se utilizam de casas decimais para representar valores reais.

Código python:
>>> 1.2
1.2
>>> 2.75
2.75
>>>

O Python utiliza o ponto como marcador de casas decimais. Algumas vezes o Python pode apresentar números "incertos". Por exemplo:

Código python:
>>> 1.2-1.0
0.199999999999999996

Isto não é um bug. Na verdade isso não é relacionado com o Python em si, mas sim com a forma que a plataforma C manipula pontos flutuantes e com a imprecisão adicionada pelo processo de convertes números para strings com um numero definido de casas decimais.

A representação interna do ponto flutuante usa um numero fixo de dígitos binários para representar o numero decimal, Alguns números decimais ão podem ser representados precisamente, resultando em pequenos erros de aproximação.

Para os matemáticos curiosos: é fácil provar que 0.99999... é igual a 1, aqui vai um link: 0.999... - Wikipedia, the free encyclopedia


Booleanos

Os valores booleanos assumem apenas 2 valores, verdadeiro e falso. Eles se comportam como 1 e 0.

Código python:
>>> True
True
>>> False
False
>>>
>>>
>>> True + True
2
>>> True + False
1
>>> False + False
0
>>>



Complex

Números complexos são muito utilizados na matemática e na engenharia. Eles são representados por dois números com ponto flutuante (ou inteiros/longos), parte real e imaginária. A parte imaginária sempre está acompanhada pelo número complexo j, dependendo do livro adotado também é utilizado o i, ambos são uma substituição para o número complexo srq(-1) (raix quadrada de um).

Em Python, semelhante ao Long, não existe uma limitação de tamanho para números complexos. Isso se deve ao fato dos números complexos serem pares de números que se comportam de forma diferente ao serem somados, subtraídos, multiplicados e divididos. Dessa forma esses pares podem ser inteiros, pontos flutuantes ou longos.

Código python:
>>> 1 + 2j
(1+2j)
>>>
>>> -5 + 4j
(-5+4j)
>>>
>>> 2j
2j
>>>

O Python suporta também é capaz de realizar operações matemáticas com números complexos:

Código python:
>>> (2 - 3j) + (1 + 5j)
(3+2j)
>>> (2 - 3j) - (1 + 5j)
(1-8j)
>>> (2 - 3j)*(-1j)
(-3-2j)
>>> (2 - 3j)/(-2+2j)
(-1.25+0.25j)
>>> (2 - 3j)**2
(-5-12j)
>>>


Outra Curiosidade

O Python é um ótima linguagem também para os matemáticos. Nela é possível representar números extremamente grandes ou extremamente pequenos utilizando a notação científica Notação científica - Wikipédia, a enciclopédia livre . Vamos a alguns exemplos:
Código python:
>>> 2e10
20000000000.0
>>> 5e-3
0.0050000000000000001
>>>

Para imprimir números em notação científica basta usar o identificador %e na formatação:
Código python:
>>> x = 100000
>>> y = 0.00001
>>> print 'Numero grande %.2e\nNumero pequeno %.2e'%(x, y)
Numero grande 1.00e+05
Numero pequeno 1.00e-05
>>>

Lembrando que o '.2', entre o '%' e 'e', define que serão utilizadas somente duas casas decimais de precisão.

Até a próxima pessoal...

Comentários

  1. Avatar de cleoson
    Olá Magnun,

    Legal sua explicação, achei que foi bem clara e objetiva.
    Com relação ao tipo float, independente de ser bug ou não, isso teria que ser tratado quando se está escrevendo um programa, não? :-)
    No exemplo que você citou ((1.2)-(1.0)), pra que a conta desse certo, poderia multiplicar os dois números por 10, realizar a divisão, e depois dividir o resultado por 10. Que tal essa "gambiarra"? :-)


    []'s
    Cléoson.
  2. Avatar de Magnun
    Como eu disse não é um bug é só uma imprecisão apresentada. Mas ao fazer o print do número já está tudo ok:
    Código python:
    >>> 1.2-1.0
    0.19999999999999996
    >>> print 1.2-1.0
    0.2
    >>>

    Não confundir com casos em que temos dízimas periódicas, para esses casos existem também funções que fazem o arredondamento:
    Código python:
    >>> y = 1.0/3.0
    >>> y
    0.33333333333333331
    >>> print y
    0.333333333333
    >>>
    >>> y2 = round(y, 4)
    >>> y2
    0.33329999999999999
    >>> print y2
    0.3333

    A função round arredonda o número em quantas casas decimais vc pedir, nesse caso eu delimitei em 4 casas decimais. Esses assuntos serão abordados quando eu for tratar as funções built-in, onde irei comentar com detalhes todas essas funções.

    Até mais...
  3. Avatar de fabraga
    Parece que na versão 3.2 do Python não temos mais o tipo Long. Fiz uns testes de atribuição de valores bem maiores do que os limites para número inteiro mas a função "type()" continua retornando o tipo "int". =/

+ Enviar Comentário




Visite: BR-Linux ·  VivaOLinux ·  Dicas-L