NumPy: Tipos de Dados dtype

Última atualização: 2026-08-26

Tipos de Dados dtype

1. O que Você Aprenderá

• O sistema dtype e classificação
• Criando arrays com dtypes específicos
• Conversão de tipos e riscos de overflow
• Dtypes estruturados
• O compromisso memória/precisão/velocidade do dtype

2. História

A precisão do modelo da Alice caiu de 95% para 12% da noite para o dia. O culpado: converter float64 para int8 fez overflow de todos os valores acima de 127 para negativos. "dtype não é um detalhe menor — escolha o tipo errado e seus dados estão arruinados."

3. Conceitos-Chave

(1) O Sistema dtype

O dtype (tipo de dados) do NumPy descreve o tipo de cada elemento em um array. Todo ndarray tem um atributo .dtype.

np.int32    # inteiro com sinal de 32 bits
np.float64  # ponto flutuante de 64 bits
np.bool_    # booleano
np.str_     # string unicode
np.object_  # objeto Python

dtype tem dois campos:

import numpy as np

a = np.array([1, 2, 3])
print(a.dtype)       # int64 (em plataformas 64-bit)
print(a.dtype.kind)  # 'i'
print(a.dtype.itemsize)  # 8

> **Saída:** Execute NumPy 2.x no seu ambiente Python local para ver a saída do ndarray. O servidor Piston não tem NumPy pré-instalado — instale localmente (`pip install numpy`) e compare. Os valores reais podem variar conforme a versão do NumPy e a semente aleatória.

(2) Comparação de Tipos Inteiros

(3) Comparação de Tipos de Ponto Flutuante

(4) Especificando dtype

import numpy as np

# Por objeto de tipo NumPy
a = np.array([1, 2, 3], dtype=np.float32)

# Por string
b = np.array([1, 2, 3], dtype='float32')

# Por código de caractere único
c = np.array([1, 2, 3], dtype='f4')  # float32: 'f' + 4 bytes

(5) Conversão de Tipos e Overflow

import numpy as np

# astype retorna um novo array com o dtype alvo
a = np.array([1, 2, 3], dtype=np.int32)
b = a.astype(np.float64)  # [1. 2. 3.]

# Overflow: valores além do intervalo alvo fazem wrap around
c = np.array([100, 200, 300], dtype=np.uint8)
# [100, 200, 44]  — 300 - 256 = 44

# Float para int trunca
d = np.array([1.9, 2.5, 3.1])
print(d.astype(np.int32))  # [1 2 3]

Saída: Execute NumPy 2.x no seu ambiente Python local para ver a saída do ndarray. O servidor Piston não tem NumPy pré-instalado — instale localmente (pip install numpy) e compare. Os valores reais podem variar conforme a versão do NumPy e a semente aleatória.

(6) Dtypes Estruturados

Para dados tabulares com tipos mistos, use dtypes estruturados:

import numpy as np

# Definir um dtype estruturado
dt = np.dtype([('name', 'U10'), ('age', 'i4'), ('salary', 'f8')])

# Criar array com dtype estruturado
employees = np.array([
    ('Alice', 30, 75000.0),
    ('Bob', 25, 62000.0),
    ('Charlie', 35, 85000.0)
], dtype=dt)

print(employees['name'])   # ['Alice' 'Bob' 'Charlie']
print(employees['salary'].mean())  # 74000.0

Saída: Execute NumPy 2.x no seu ambiente Python local para ver a saída do ndarray. O servidor Piston não tem NumPy pré-instalado — instale localmente (pip install numpy) e compare. Os valores reais podem variar conforme a versão do NumPy e a semente aleatória.

▶ Exemplo

> **Saída:** Execute NumPy 2.x no seu ambiente Python local para ver a saída do ndarray. O servidor Piston não tem NumPy pré-instalado — instale localmente (`pip install numpy`) e compare. Os valores reais podem variar conforme a versão do NumPy e a semente aleatória.

: Demonstração de overflow (Dificuldade ⭐⭐)

import numpy as np

# intervalo int8: -128 a 127
vals = np.array([100, 120, 127, 128, 130, 200], dtype=np.int8)
print("int8 values:", vals)
# [100  120  127 -128 -126  -56]

# intervalo uint8: 0 a 255
vals_u = np.array([200, 255, 256, 300], dtype=np.uint8)
print("uint8 values:", vals_u)
# [200 255   0  44]

> **Saída:** Execute NumPy 2.x no seu ambiente Python local para ver a saída do ndarray. O servidor Piston não tem NumPy pré-instalado — instale localmente (`pip install numpy`) e compare. Os valores reais podem variar conforme a versão do NumPy e a semente aleatória.

▶ Exemplo

> **Saída:** Execute NumPy 2.x no seu ambiente Python local para ver a saída do ndarray. O servidor Piston não tem NumPy pré-instalado — instale localmente (`pip install numpy`) e compare. Os valores reais podem variar conforme a versão do NumPy e a semente aleatória.

: Dtype estruturado — registros de funcionários (Dificuldade ⭐⭐)

import numpy as np

dt = np.dtype([('name', 'U10'), ('dept', 'U15'), ('salary', 'f8'), ('years', 'i2')])

data = np.array([
    ('Alice', 'Engineering', 95000, 5),
    ('Bob', 'Marketing', 72000, 3),
    ('Charlie', 'Engineering', 110000, 8),
    ('Diana', 'Sales', 68000, 2),
], dtype=dt)

# Consultar por departamento
eng = data[data['dept'] == 'Engineering']
print("Engineering avg salary:", eng['salary'].mean())

# Ordenar por salário
sorted_data = np.sort(data, order='salary')
print("Top earner:", sorted_data[-1]['name'], sorted_data[-1]['salary'])

> **Saída:** Execute NumPy 2.x no seu ambiente Python local para ver a saída do ndarray. O servidor Piston não tem NumPy pré-instalado — instale localmente (`pip install numpy`) e compare. Os valores reais podem variar conforme a versão do NumPy e a semente aleatória.

4. Tabelas Comparativas

(1) Regras de Conversão de Tipos

(2) Matriz Memória vs Precisão

(3) Comportamento de Overflow

5. Diagrama de Princípios

graph TB
    A[Objeto Python] --> B{Inferência de dtype}
    B -->|int| C[int64]
    B -->|float| D[float64]
    B -->|misturado| E[promoção para tipo comum]
    B -->|explícito| F[dtype especificado pelo usuário]
    C --> G[ndarray com dtype fixo]
    D --> G
    E --> G
    F --> G
    G --> H[operações vetorizadas]
    G --> I[armazenamento eficiente em memória]
    
    style A fill:#e1f5fe
    style G fill:#c8e6c9
    style H fill:#fff9c4
    style I fill:#fff9c4

graph TB
    A[Objeto Python] --> B{Inferência de dtype}
    B -->|int| C[int64]
    B -->|float| D[float64]
    B -->|misturado| E[promoção para tipo comum]
    B -->|explícito| F[dtype especificado pelo usuário]
    C --> G[ndarray com dtype fixo]
    D --> G
    E --> G
    F --> G
    G --> H[operações vetorizadas]
    G --> I[armazenamento eficiente em memória]
    
    style A fill:#e1f5fe
    style G fill:#c8e6c9
    style H fill:#fff9c4
    style I fill:#fff9c4

▶ Exemplo: Conversão de dtype e uso de memória (Dificuldade ⭐⭐)

import numpy as np

# Comparar uso de memória de diferentes dtypes
arr_int64 = np.ones(1000000, dtype=np.int64)
arr_float32 = np.ones(1000000, dtype=np.float32)
arr_int8 = np.ones(1000000, dtype=np.int8)

print(f"int64:  {arr_int64.nbytes / 1e6:.1f} MB")
print(f"float32: {arr_float32.nbytes / 1e6:.1f} MB")
print(f"int8:   {arr_int8.nbytes / 1e6:.1f} MB")

# Converter entre tipos
converted = arr_float32.astype(np.int32)
print(f"Converted dtype: {converted.dtype}")

Saída:

TEXT 📖 Somente leitura

📋 Copy

int64:  8.0 MB
float32: 4.0 MB
int8:   1.0 MB
Converted dtype: int32

❓ Perguntas Frequentes

P: Qual é o dtype inteiro padrão? R: int64 em plataformas 64-bit, int32 em 32-bit. NumPy escolhe com base na arquitetura do seu sistema. Você sempre pode especificar explicitamente com dtype=np.int32.

P: O que acontece quando faço overflow de um inteiro? R: Ele faz wrap around silenciosamente — sem erro, sem aviso. int8(127) + 1 = -128. Esta é uma fonte comum de bugs. Use np.seterr(over='warn') para detectá-lo.

P: Quando devo usar float32 vs float64? R: Use float64 para computação científica onde a precisão importa. Use float32 para aprendizado profundo (GPUs são mais rápidas com float32) ou quando a memória é limitada. float32 tem ~7 dígitos de precisão — suficiente para a maioria das tarefas de ML.

P: Qual a diferença entre 'f' e 'd'? R: 'f' = float32 (4 bytes), 'd' = float64 (8 bytes). Estes são códigos de caractere único do float e double do C.

P: Posso ter tipos mistos em um array? R: Não em um ndarray regular. Mas você pode usar dtypes estruturados (como uma tabela de banco de dados com colunas nomeadas) ou dtype object (que armazena referências a objetos Python, perdendo desempenho).

📖 Resumo

• dtype define o tipo de elemento de cada ndarray, com campos kind (categoria) e itemsize (bytes)
• Tipos inteiros: int8/16/32/64, uint8/16/32/64 — overflow faz wrap silenciosamente
• Tipos de ponto flutuante: float16/32/64/128 — mais bytes = mais precisão + mais memória
• Especifique dtype via np.dtype(), objetos de tipo, strings ou códigos de caractere único
• astype() converte entre tipos; overflow faz wrap, float-para-int trunca
• Dtypes estruturados permitem dados tabulares de tipos mistos dentro de um único ndarray

📝 Exercícios

1. Básico (Dificuldade ⭐): Crie arrays de int8, int16, int32, int64, float32, float64 — cada um com 1000 elementos de valor 1. Imprima seus nbytes e explique as diferenças de memória.

2. Intermediário (Dificuldade ⭐⭐): Crie um array uint8 com valores [0, 127, 128, 255, 256, -1]. Observe quais valores fazem overflow e explique os resultados. Depois crie um dtype estruturado para um catálogo de livros com campos: título (string), autor (string), ano (int16), preço (float32).

3. Desafio (Dificuldade ⭐⭐⭐): Converta um array float64 de 1 milhão de números aleatórios para float32, depois de volta para float64. Compute o erro absoluto médio entre o original e o array de ida e volta. Repita com float16. Registre a perda de precisão para cada tipo.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós