2024-07-27

- Combines arrays by placing them side-by-side (column-wise).
- Arrays must have the same shape along all dimensions except the second (columns).
- For 1D arrays, it concatenates along the first dimension (rows).

**vstack (vertical stack):**

- Combines arrays by placing them on top of each other (row-wise).

**append:**

- Primarily used for lists, not NumPy arrays.
- Appends a single element to the end of a list.
- Not ideal for combining multiple arrays at once.

**concatenate:**

- Offers more flexibility than
`hstack`

and`vstack`

. - Concatenates arrays along a specified axis.
- Can handle arrays of different shapes (with broadcasting for compatible shapes).
- Use
`axis=0`

for vertical stacking,`axis=1`

for horizontal stacking.

**column_stack:**

- A convenient shortcut for stacking columns (similar to
`hstack`

but along the second dimension). - Arrays can have different lengths (number of rows).

**Choosing the Right Function:**

**For simple vertical or horizontal stacking with the same number of rows/columns:**- Use
`vstack`

for vertical stacking (`axis=0`

).

- Use
**For stacking arrays with different shapes (broadcasting):**- Use
`concatenate`

with the appropriate`axis`

argument.

- Use
**For specifically stacking columns with potentially different row lengths:****For appending a single element to a list:**- Use
`append`

(but remember it's not for NumPy arrays).

- Use

**Example:**

`import numpy as nparr1 = np.array([1, 2, 3])arr2 = np.array([4, 5, 6])# Horizontal stacking (columns)horizontal = np.hstack((arr1, arr2)) # [1 2 3 4 5 6]column_stack = np.column_stack((arr1, arr2)) # [[1 4], [2 5], [3 6]] (better for columns)# Vertical stacking (rows)vertical = np.vstack((arr1, arr2)) # [[1 2 3], [4 5 6]]# Concatenation (demonstrating broadcasting)concat_v = np.concatenate((arr1[:, np.newaxis], arr2[:, np.newaxis]), axis=0) # [[[1]], [[2]], [[3]], [[4]], [[5]], [[6]]]concat_h = np.concatenate((arr1, arr2.reshape(-1, 1)), axis=1) # [[1 4], [2 5], [3 6]]`

**Key Points:**

`hstack`

and`vstack`

are more specialized for vertical/horizontal stacking with matching shapes.`concatenate`

offers more general concatenation along any axis.`column_stack`

is a convenient alternative to`hstack`

for stacking columns.- Choose the function that best suits your specific array manipulation needs.

`import numpy as nparr1 = np.array([1, 2, 3])arr2 = np.array([4, 5, 6])# Stacking arrays horizontally (side-by-side)horizontal_stack = np.hstack((arr1, arr2))print("hstack:", horizontal_stack) # Output: [1 2 3 4 5 6]`

`import numpy as nparr1 = np.array([1, 2, 3])arr2 = np.array([4, 5, 6])# Stacking arrays vertically (on top of each other)vertical_stack = np.vstack((arr1, arr2))print("vstack:", vertical_stack) # Output: [[1 2 3] [4 5 6]]`

`import numpy as nparr1 = np.array([1, 2, 3])arr2 = np.array([4, 5, 6])arr3 = np.array([[7], [8], [9]]) # Different shape (3 rows, 1 column)# Concatenating vertically (axis=0)concat_vertical = np.concatenate((arr1, arr2, arr3), axis=0)print("concatenate (vertical):", concat_vertical) # Output: [[1 2 3] [4 5 6] [7] [8] [9]]# Concatenating horizontally (axis=1) with broadcasting (arr3 reshaped)concat_horizontal = np.concatenate((arr1, arr2.reshape(-1, 1), arr3), axis=1)print("concatenate (horizontal):", concat_horizontal) # Output: [[1 4 7] [2 5 8] [3 6 9]]`

`import numpy as nparr1 = np.array([1, 2, 3])arr2 = np.array([4, 5, 6])arr3 = np.array([7]) # Single element array (treated as a column)# Stacking columns (convenient for potentially different row lengths)column_stacked = np.column_stack((arr1, arr2, arr3))print("column_stack:", column_stacked) # Output: [[1 4 7] [2 5] [3 6]]`

For basic stacking of 1D arrays (lists) where you don't need the efficiency of NumPy arrays, you can use list comprehension:

`arr1 = [1, 2, 3]arr2 = [4, 5, 6]# Horizontal stackinghorizontal_list = [val for arr in (arr1, arr2) for val in arr]print("Horizontal list comprehension:", horizontal_list) # Output: [1, 2, 3, 4, 5, 6]# Vertical stackingvertical_list = [arr for arr in (arr1, arr2)]print("Vertical list comprehension:", vertical_list) # Output: [[1, 2, 3], [4, 5, 6]]`

**append with Loops (for Selective Stacking):**

If you need to conditionally append elements or perform operations during stacking, you can use `append`

within a loop:

`import numpy as nparr1 = np.array([1, 2, 3])arr2 = np.array([4, 5, 6])filtered_arr2 = arr2[arr2 % 2 == 0] # Filter even elementscombined_arr = arr1.copy() # Create a copy to avoid modifying original arrayfor val in filtered_arr2: combined_arr = np.append(combined_arr, val)print("Selective stacking with append:", combined_arr) # Output: [1 2 3 4 6]`

**np.newaxis for Broadcasting (for Specific Reshaping):**

For creating new dimensions for broadcasting purposes, you can use `np.newaxis`

:

`import numpy as nparr1 = np.array([1, 2, 3])arr2 = np.array([4]) # Single element array# Reshaping arr2 for horizontal stacking (broadcasting)horizontal_newaxis = np.concatenate((arr1[:, np.newaxis], arr2[:, np.newaxis]), axis=1)print("Horizontal stacking with newaxis:", horizontal_newaxis) # Output: [[1 4] [2 4] [3 4]]`

- List comprehension: Suitable for simple stacking when NumPy arrays aren't necessary.
`append`

with loops: Useful for conditional stacking or performing operations during stacking.`np.newaxis`

: Helpful for creating new dimensions for specific broadcasting scenarios.

**Remember:**

- These alternatives may not be as efficient as
`hstack`

,`vstack`

,`concatenate`

, and`column_stack`

for large datasets. - Choose the method that best suits your specific needs based on complexity, performance requirements, and code readability.

python numpy