np.concatenate

Your analyst stored the first half of the IPL season in one array and the second half in another. Now the coach wants the full season in one table. Or a new player joined the squad and his scores must become a new row. Gluing arrays together is called concatenation, and np.concatenate is the general tool behind all the "stack" helpers.

Definition

np.concatenate joins a sequence of arrays end to end along an existing axis, returning a new array. All input arrays must have the same number of dimensions and the same size in every dimension except the joining axis.

• Sequence of arrays — you pass a tuple or list: np.concatenate((a, b)), not np.concatenate(a, b).
• Existing axis — no new dimension is created. Two (2, 3) arrays become (4, 3) or (2, 6), never (2, 2, 3) (that is np.stack).
• New array — the data is copied; the originals are unchanged.
• Same size except the joining axis — to add rows, the column counts must match; to add columns, the row counts must match.

Syntax

np.concatenate((a1, a2, ...), axis=0, out=None, dtype=None, casting="same_kind")

Picture it

axis=0 (more ROWS)              axis=1 (more COLUMNS)

 [A A A]                         [A A A | B B B]
 [A A A]                         [A A A | B B B]
 -------
 [B B B]          (2,3)+(2,3)  -> (2,6)
 [B B B]
(2,3)+(2,3) -> (4,3)

Example — 1D arrays: one long season

import numpy as np

a = np.array([10, 20, 30])
b = np.array([40, 50])
c = np.array([60])
print(np.concatenate([a, b, c]))

[10 20 30 40 50 60]

How it works: 1D arrays have only axis 0, so they are joined end to end. The lengths can be different (3 + 2 + 1 = 6) because the joining axis is the only axis.

Example — axis=1: first half + second half of the season

first_half = np.array([[72, 45, 88],
                       [56,  0, 74]])      # 2 players x 3 matches
second_half = np.array([[31, 64,  0],
                        [88, 32, 45]])     # same 2 players, next 3 matches
season = np.concatenate((first_half, second_half), axis=1)
print(season)
print(season.shape)

[[72 45 88 31 64  0]
 [56  0 74 88 32 45]]
(2, 6)

How it works: axis=1 places the arrays side by side. The row counts (2 and 2) must match; the column counts are added (3 + 3 = 6).

Example — axis=0: new players join the squad

new_players = np.array([[45, 32,  0],
                        [33, 61, 45]])
squad = np.concatenate((first_half, new_players), axis=0)
print(squad)
print(squad.shape)

[[72 45 88]
 [56  0 74]
 [45 32  0]
 [33 61 45]]
(4, 3)

How it works: axis=0 places the arrays one below the other. Column counts (3 and 3) must match; rows are added (2 + 2 = 4).

Example — axis=None flattens first

print(np.concatenate([first_half, second_half], axis=None))

[72 45 88 56  0 74 31 64  0 88 32 45]

Shape rules — when does it fail?

The two error messages, exactly as NumPy prints them:

ValueError: all the input array dimensions except for the concatenation axis must match exactly, but along dimension 1, the array at index 0 has size 3 and the array at index 1 has size 4
ValueError: all the input arrays must have same number of dimensions, but the array at index 0 has 1 dimension(s) and the array at index 1 has 2 dimension(s)

Note: Unlike arithmetic, concatenation does not broadcast. A (3,) array is not automatically treated as (1, 3) — reshape it yourself, or use np.vstack, which does that for you.

Dtype of the result

print(np.concatenate([np.array([1, 2]), np.array([2.5, 3.5])]))
print(np.concatenate([np.array([1, 2]), np.array([3, 4])], dtype=float))

[1.  2.  2.5 3.5]
[1. 2. 3. 4.]

Mixed int + float gives float (the common type). dtype= lets you choose.

Common mistakes

• ❌ np.concatenate(a, b) — the second argument is read as axis. ✅ np.concatenate((a, b)) — pass one tuple/list.
• ❌ Joining a 1D row onto a 2D table: np.concatenate((squad, row)). ✅ np.concatenate((squad, row.reshape(1, -1))) or np.vstack((squad, row)).
• ❌ Expecting axis=0 to put arrays side by side. ✅ axis=0 adds rows (down), axis=1 adds columns (across).
• ❌ Concatenating inside a loop to grow an array. ✅ Collect pieces in a Python list, concatenate once at the end.

Interview tip

Q: What is the difference between np.concatenate and np.stack? A: concatenate joins along an existing axis, so the number of dimensions stays the same ((2,3)+(2,3) → (4,3)). stack creates a new axis, so dimensions go up by one ((2,3)+(2,3) → (2,2,3)) and all inputs must have exactly the same shape.