Tipos de Dados

Todo objeto possui uma identidade, um tipo e um valor. A identidade de um objeto nunca muda após sua criação; você pode imaginá-la como sendo o endereço de memória de um objeto. O operador ‘is’ compara a identidade de dois objetos; a função id() retorna um número inteiro que representa a identidade de um objeto (atualmente
implementada como sendo o seu endereço). O tipo de um objeto também é inalterável.
O tipo do objeto determina as operações que o objeto suporta (ex., “ele tem um comprimento?”) e os possíveis valores para objetos deste tipo. A função type() retorna o tipo do objeto (que também e um objeto). O valor de alguns objetos pode mudar.
Objetos que podem mudar seu valor são denominados mutáveis; objetos que não podem mudar seu valor após terem sido criados são chamados de imutáveis. (O valor de um objeto contêiner imutável que possui uma referência para um objeto mutável pode alterar quando o valor do último é alterado; porém, o conteúdo do primeiro ainda é considerado imutável porque a coleção de objetos deste conteúdo não pode ser modificada. Logo, imutabilidade não é estritamente o mesmo que ter um valor inalterável, é algo mais sutil.) A mutabilidade de um objeto é determinada pelo seu tipo; por exemplo, números, strings e tuplas são imutáveis, enquanto dicionários e listas são
mutáveis.

Abaixo está uma lista de tipos que são internos ao interpretador Python. Módulos de extensão (escritos em C, Java, ou outras linguagens, dependendo da implementação) podem definir tipos adicionais. Versões futuras do Python podem adicionar tipos nesta hierarquia (ex, números racionais, arrays com armazenamento eficiente de inteiros, etc.).
Algumas das descrições de tipos abaixo contêm um parágrafo listando ‘atributos especiais.’ São atributos que fornecem acesso a implementação e cuja intenção não é de uso geral. Suas definições podem mudar no futuro.

None: Este tipo tem um valor único. Este objeto é acessado através do nome interno “None”. Ele é usado com o significado de ausência de valor em várias situações, ex., ele é retornado por funções que não retornam nada explicitamente. Seu valor lógico é falso.
NotImplemented: Este tipo tem um valor único. Este objeto é acessado através do nome interno “NotImplemented”. Métodos numéricos e métodos completos de comparação podem retornar este valor se eles não implementam a operação para os operandos fornecidos. (O interpretador tentará então uma operação refletida, ou alguma chamada alternativa, dependendo do operador.) Seu valor lógico é verdadeiro.
Ellipsis: Este tipo tem um valor único. Este objeto é acessado através do nome interno Ellipsis. Ele é usado para indicar a presença da sintaxe ‘...’ em uma fatia. Seu valor lógico é verdadeiro. Números São criados por números literais e retornados como resultado por operadores aritméticos e funções aritméticas internas. Objetos numéricos são imutáveis; uma vez criados seus valores nunca mudam.

Números em Python são fortemente relacionados com números matemáticos, mas sujeitos às limitações da representação numérica em computadores.
Python faz distinção entre inteiros, números de ponto flutuante, e números complexos:

Inteiros: Representam elementos do conjunto matemático dos números inteiros (positivos e negativos). Existem três tipos de inteiros:
Inteiros Planos: Representam números na faixa de -2147483648 até 2147483647. (A faixa pode ser maior em máquinas com um tamanho de palavra maior, mas não menor.) Quando o resultado de uma operação fica fora dessa faixa, o resultado é retornado normalmente como um inteiro longo (em alguns casos, a exceção OverflowError é levantada no lugar). Para propósito de deslocamento (binário) e operações com máscaras, assume-se que eles usem notação binária de 32 bits ou mais e números negativos são representados usando complemento de dois, e não escondem nenhum bit do usuário (ex., todos os 4294967296 padrões de bits diferentes correspondem a um valor diferente).
Inteiros Longos: Representam números numa faixa ilimitada, sujeita apenas à memória (virtual). Para propósito de deslocamento (binário) e operações com máscaras, assume-se que usem notação binária e números negativos são representados com uma variação do complemento de dois que dá a ilusão de uma string infinita com o bit de sinal extendendo para a esquerda.
Booleanos: Representam os valores lógicos False (Falso) e True (Verdadeiro). Os dois objetos que representam os valores False e True são os únicos objetos Booleanos. O tipo Booleano é um subtipo dos inteiros planos, e valores Booleanos se parecem com os valores 0 e 1, respectivamente, em quase todos os contextos, a excec¸˜ao ´e quando são convertidos para uma string, as strings "False" ou "True" são retornadas, respectivamente. As regras para representação de inteiros foram feitas com a intenção de facilitar a interpretação de operações com máscara e deslocamento envolvendo inteiros negativos, e com o mínimo de problemas quando eles trocam entre os domínios dos inteiros planos e dos inteiros longos. Qualquer operação exceto o deslocamento a esquerda, se mantiver o resultado no mesmo domínio dos inteiros planos sem causar sobrecarga, irá manter o resultado no mesmo domínio dos inteiros longos ou ao usar operadores mistos.
Números de ponto flutuante: Eles representam os números de ponto flutuante de precisão dupla no nível da máquina. Vai depender da arquitetura da máquina (e da implementação de C ou Java) para a definir qual é a faixa aceita e a manipulação de sobrecargas. Python não suporta números de ponto flutuante de precisão simples; a economia de processamento e de uso de memória que geralmente são a razão para usar este tipo de técnica são mínimas perto do trabalho de usar objetos em Python, então não há razão para complicar a linguagem com dois tipos de números de ponto flutuante.
Números complexos: Representam os números complexos com um par de números de ponto flutuante de precisão dupla no nível da máquina. As mesmas características se aplicam como no caso dos números de ponto flutuante. As partes reais e imaginárias de um número complexo z podem ser obtidas através dos atributos somente de leitura z.real e z.imag.

Seqüências: Representam conjuntos finitos ordenados indexados por um número não-negativo. A função interna len() retorna o número de itens da sequência. Quando o tamanho de uma sequência é n, o conjunto de índices contêm os números 0, 1, . . . , n-1. O item i de uma seqüência a é retornado por a[i]. Seqüências também suportam fatiamento (slicing): a[i:j] retorna todos os itens com índice k onde i <=k < x =" i">= 0 e i <= x < j. Seqüências são divididas de acordo com sua “mutabilidade”:
· Seqüências imutáveis: Um objeto do tipo sequência imutável não pode ser alterado após sua criação. (Se o objeto contêm referências para outros objetos, estes objetos podem ser mutáveis e podem ser alterados; todavia, a coleção de objetos diretamente referenciadas por um objeto imutável não pode alterar). Os seguintes tipos são sequências imutáveis:
· Strings: Os itens de uma string são caracteres. Não há um tipo a parte para caracteres; eles são representados por uma string de um único item. Caracteres representam (pelo menos) um byte. As funções internas chr() e ord() convertem entre caracteres e números inteiros positivos representando os valores. Bytes com os valores de 0 a 127 geralmente representam o valor ASCII correspondente, mas a sua interpretação correta depende do programa. O tipo string é ainda usado para representar matrizes de dados, por exemplo, para guardar dados lidos de um arquivo. (Em sistemas cujo conjunto de caracteres nativo não é ASCII, strings podem usar EBCDIC em sua representação interna, contanto que as funções chr() e ord() implementem um mapeamento entre EBCDIC, e comparações de strings preservem a ordem ASCII. Ou será que talvez alguém pode propôr uma regra melhor?)
· Unicode: Os items de um objeto Unicode são unidades de código Unicode. São representadas por um objeto Unicode de um item e podem conter valores de 16 ou 32 bits, representando um caracter ordinal Unicode (o valor máximo é dado por sys.maxunicode e depende de como o interpretador Python foi configurado no momento da compilação). Pares surrogate podem estar presentes no objeto Unicode, e serão reportados como dois itens separados. As funções internas unichr() e ord() convertem entre unidades de código e inteiros positivos, representando os ordinais Unicode, como definidos no Unicode Standard 3.0. Conversão de, e para outros códigos são possíveis através do método Unicode encode e a função interna unicode().
· Tuples: Os itens de uma tupla são quaisquer objetos Python. Tuplas de dois ou mais itens são formadas por uma lista de expressões, separadas por vírgula. Uma tupla de um item (’singleton’) pode ser formada adicionando uma vírgula a uma expressão (uma expressão sozinha entre parênteses não cria uma tupla, já que parênteses podem ser usados para criar grupos de expressões). Uma tupla vazia pode ser criada por um par de parênteses.

Seqüências mutáveis: Sequências mutáveis podem ser alteradas depois de criadas. As notações de subscrição e fatiamento podem ser usadas como o alvo de atribuições ou do comando (del). Atualmente há apenas uma sequência mutável intrínseca a linguagem:
· Listas: Os itens de uma lista são quaisquer objetos Python. Listas são criadas colocando uma lista de expressões separadas por vírgulas entre dois colchetes. (Note que não há nenhuma regra especial necessária para criar listas de comprimento 0 ou 1.) O módulo array fornece um exemplo adicional de uma sequência mutável.
· Mapeamentos: Mapeamentos representam conjuntos finitos de objetos, indexados por índices arbitrários. A notação a[k] seleciona o item indexado por [k] do mapeamento a; isto pode ser usado em expressões e como o alvo de atribuições ou do comando del. A função interna len() retorna o número de itens num mapeamento. Atualmente há apenas um único mapeamento intrínseco a linguagem.
· Dicionários: Dicionários () representam conjuntos finitos de objetos, indexados por índices praticamente arbitrários. O único tipo de objeto inaceitável como chave são listas ou dicionários ou outros objetos mutáveis que são comparados pelo valor e não pela identidade. A razão para isso é que uma implementação eficiente de dicionários requer que o valor do hash da chave permaneça constante. Tipos numéricos usados para chaves obedecem as regras normais de comparação: se na comparação dois números são considerados iguais (por exemplo, 1 e 1.0) então qualquer um deles pode ser usado para indexar o mesmo valor em um dicionário. Dicionários são mutáveis; eles podem ser criados pela notação {...}.

(conteúdo retirado do endereço web "http\\www.python.org")