NumPy: Concatenação e Divisão

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

Concatenação e Divisão

1. O que Você Aprenderá

❶ concatenate — juntando ao longo de um eixo
❷ vstack / hstack — funções de conveniência
❸ stack — juntando com uma nova dimensão
❹ split / vsplit / hsplit — dividindo arrays
❺ repeat / tile — repetindo e expandindo

2. Uma História Real de um Desenvolvedor

(1) O Problema

Alice tem 3 meses de dados de vendas, cada mês como um array 4×3 (4 produtos × 3 regiões). Ela quer mesclá-los em uma grande tabela mas fica confusa sobre qual eixo usar com concatenate.

(2) A Solução

Bob desenha um diagrama: "Ao longo do eixo 0, as linhas aumentam; ao longo do eixo 1, as colunas aumentam." concatenate(axis=0) empilha verticalmente, concatenate(axis=1) empilha horizontalmente.

(3) O Resultado

Após dominar concatenação e divisão, Alice pode mesclar dados mensais com um comando, dividir por trimestre e usar tile para expandir templates de previsão — melhoria de 10x na eficiência de montagem de dados.

3. Conceitos-Chave

(1) np.concatenate — Juntar Ao Longo de um Eixo

np.concatenate é a função de junção mais geral, com o parâmetro axis controlando a direção.

PYTHON

import numpy as np

a = np.array([[1, 2, 3],
              [4, 5, 6]])

b = np.array([[7, 8, 9],
              [10, 11, 12]])

# Ao longo do eixo 0: empilhar verticalmente (linhas aumentam)
c0 = np.concatenate([a, b], axis=0)
# [[ 1  2  3]
#  [ 4  5  6]
#  [ 7  8  9]
#  [10 11 12]]

# Ao longo do eixo 1: empilhar horizontalmente (colunas aumentam)
c1 = np.concatenate([a, b], axis=1)
# [[ 1  2  3  7  8  9]
#  [ 4  5  6 10 11 12]]

TEXT 📖 Somente leitura

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

⚠️ Nota: O código abaixo precisa ser executado em um ambiente Python local.

(2) vstack e hstack

PYTHON

import numpy as np

a = np.array([[1, 2],
              [3, 4]])
b = np.array([[5, 6],
              [7, 8]])

# vstack: mesmo que concatenate(axis=0)
v = np.vstack([a, b])
print(v.shape)  # (4, 2)

# hstack: mesmo que concatenate(axis=1)
h = np.hstack([a, b])
print(h.shape)  # (2, 4)

TEXT 📖 Somente leitura

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

⚠️ Nota: O código abaixo precisa ser executado em um ambiente Python local.

(3) stack — Juntar com uma Nova Dimensão

stack cria um novo eixo e junta ao longo dele:

PYTHON

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.array([7, 8, 9])

s = np.stack([a, b, c])
print(s.shape)  # (3, 3)
print(s)
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

TEXT 📖 Somente leitura

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

⚠️ Nota: O código abaixo precisa ser executado em um ambiente Python local.

(4) split — Dividindo Arrays

PYTHON

import numpy as np

a = np.arange(12).reshape(6, 2)

# Dividir em 3 partes iguais
parts = np.split(a, 3)
print(len(parts))  # 3
print(parts[0].shape)  # (2, 2)
print(parts[1].shape)  # (2, 2)
print(parts[2].shape)  # (2, 2)

# Dividir em índices específicos
parts2 = np.split(a, [2, 4])
print([p.shape for p in parts2])  # [(2,2), (2,2), (2,2)]

# vsplit: dividir ao longo do eixo 0 (vertical)
# hsplit: dividir ao longo do eixo 1 (horizontal)
v = np.vsplit(a, 3)  # mesmo que split(a, 3, axis=0)
h = np.hsplit(a, 2)  # dividir colunas

TEXT 📖 Somente leitura

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

⚠️ Nota: O código abaixo precisa ser executado em um ambiente Python local.

(5) repeat e tile

PYTHON

import numpy as np

a = np.array([1, 2, 3])

# repeat: repetir cada elemento
print(np.repeat(a, 3))  # [1 1 1 2 2 2 3 3 3]

# tile: repetir o array inteiro
print(np.tile(a, 3))  # [1 2 3 1 2 3 1 2 3]

# tile 2D
b = np.array([[1, 2], [3, 4]])
print(np.tile(b, (2, 3)).shape)  # (4, 6)

TEXT 📖 Somente leitura

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

⚠️ Nota: O código abaixo precisa ser executado em um ambiente Python local.

▶ Exemplo

TEXT 📖 Somente leitura

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

: Concatenação vs stacking (Dificuldade ⭐)

PYTHON

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

print("concatenate:", np.concatenate([a, b]))
# [1 2 3 4 5 6]

print("stack:", np.stack([a, b]))
# [[1 2 3]
#  [4 5 6]]

print("vstack:", np.vstack([a, b]))
# [[1 2 3]
#  [4 5 6]]

print("hstack:", np.hstack([a, b]))
# [1 2 3 4 5 6]

TEXT 📖 Somente leitura

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

⚠️ Nota: O código abaixo precisa ser executado em um ambiente Python local.

4. Tabelas Comparativas

(1) Métodos de Concatenação

Função	eixo	Requisito de Shape	Mudança de Shape Resultante
`concatenate`	especificado	Mesmo exceto eixo de junção	Eixo de junção soma
`vstack`	0	Mesmo número de colunas	Linhas aumentam
`hstack`	1	Mesmo número de linhas	Colunas aumentam
`stack`	novo eixo	Mesmo shape inteiramente	Nova dimensão adicionada

(2) repeat vs tile

Função	Comportamento	Exemplo
`repeat(3)`	Repetir cada elemento 3x	`[1,2]` → `[1,1,1,2,2,2]`
`tile(3)`	Repetir o array inteiro 3x	`[1,2]` → `[1,2,1,2,1,2]`

▶ Exemplo: Usando array_split para divisões desiguais (Dificuldade ⭐⭐)

PYTHON

import numpy as np

a = np.arange(10)

# split requer partes iguais — gera erro para 3 partes
# array_split lida com divisões desiguais graciosamente
parts = np.array_split(a, 3)
for i, p in enumerate(parts):
    print(f"Part {i}: shape={p.shape}, values={p}")

# array_split 2D
b = np.arange(20).reshape(5, 4)
parts_2d = np.array_split(b, 3)
for i, p in enumerate(parts_2d):
    print(f"2D Part {i}: shape={p.shape}")

Output:

TEXT 📖 Somente leitura

Part 0: shape=(4,), values=[0 1 2 3]
Part 1: shape=(3,), values=[4 5 6]
Part 2: shape=(3,), values=[7 8 9]
2D Part 0: shape=(2, 4)
2D Part 1: shape=(2, 4)
2D Part 2: shape=(1, 4)

▶ Exemplo: repeat e tile para expansão de dados (Dificuldade ⭐)

PYTHON

import numpy as np

a = np.array([1, 2, 3])

# repeat: repetir cada elemento individualmente
print("repeat:", np.repeat(a, 3))

# tile: repetir o array inteiro
print("tile:", np.tile(a, 3))

# Prático: expandir um padrão
pattern = np.array([[1, 0], [0, 1]])
grid = np.tile(pattern, (2, 3))
print("Tiled pattern:\n", grid)
print("Shape:", grid.shape)

Output:

TEXT 📖 Somente leitura

repeat: [1 1 1 2 2 2 3 3 3]
tile: [1 2 3 1 2 3 1 2 3]
Tiled pattern:
 [[1 0 1 0 1 0]
 [0 1 0 1 0 1]
 [1 0 1 0 1 0]
 [0 1 0 1 0 1]]
Shape: (4, 6)

❓ Perguntas Frequentes

P: Qual é a diferença entre concatenate e stack? R: concatenate junta arrays existentes ao longo de um eixo existente — sem novas dimensões. stack cria um novo eixo e junta ao longo dele, adicionando uma dimensão.

P: Posso concatenar arrays de shapes diferentes? R: Eles devem corresponder em todas as dimensões exceto o eixo de junção. Por exemplo, para concatenar ao longo do eixo 0, os arrays devem ter o mesmo número de colunas.

P: O que acontece se eu dividir um array em partes desiguais? R: np.split requer divisões iguais — gera erro. Use np.array_split para divisões desiguais, que lida com o restante graciosamente.

📖 Resumo

concatenate junta ao longo de um eixo existente; os eixos devem corresponder exceto o eixo de junção
vstack / hstack são atalhos para concatenação nos eixos 0 e 1
stack cria uma nova dimensão, útil para construir lotes de dados
split / vsplit / hsplit dividem arrays em partes iguais ou em índices específicos
repeat repete elementos; tile repete o array inteiro

📝 Exercícios

Básico (Dificuldade ⭐): Crie dois arrays 3x4 de números aleatórios. Concatene-os ao longo do eixo 0, depois ao longo do eixo 1. Imprima os shapes dos resultados.
Intermediário (Dificuldade ⭐⭐): Crie três arrays 1D de comprimento 5. Use stack para combiná-los em um array 3x5. Depois use vstack e compare os shapes.
Desafio (Dificuldade ⭐⭐⭐): Crie um array 12x8. Divida em 3 partes iguais, depois divida nos índices [3, 7]. Use np.tile para repetir um padrão 2x2 em uma grade 8x8.

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