Article: NumPy the Essential 25 Methods to transform you into a data ninja

 import numpy as np

my_array = np.array([1, 2, 3, 4])
print(my_array)  # Output: [1 2 3 4]
 

zeros_array = np.zeros((3, 4))  # 3 rows, 4 columns of zeros
print(zeros_array)

ones_array = np.ones((2, 2))
print(ones_array)  # Output: [[1. 1.]
                    #        [1. 1.]]

4. empty(): Creates an array of uninitialized elements (like empty boxes).

empty_array = np.empty((2, 3))
print(empty_array)  # Output will vary depending on memory allocation

5. arange(): Generates an array of evenly spaced values within a specified range.

arange_array = np.arange(5, 15, 2)  # Start, stop (exclusive), step
print(arange_array)  # Output: [5, 7, 9, 11, 13]

6. linspace(): Creates an array with a specified number of elements (num) spaced evenly within a given interval (start and stop).

linspace_array = np.linspace(0, 10, 5)  # Start, stop, number of elements
print(linspace_array)  # Output: [ 0.  2.  4.  6.  8. 10.]

7. reshape(): Transforms an array into a new shape without copying data (if possible).

reshaped_array = my_array.reshape(2, 2)
print(reshaped_array)  # Output: [[1 2], [3 4]]

8. dtype(): Gets or sets the data type of the elements in an array.

print(my_array.dtype)  # Output: int64
float_array = my_array.astype(np.float32)  # Convert to 32-bit floats
print(float_array.dtype)  # Output: float32

9. size(): Returns the total number of elements in an array.

print(my_array.size)  # Output: 4

10. shape(): Returns a tuple representing the dimensions of an array.

print(my_array.shape)  # Output: (4,)

11. ndim(): Returns the number of dimensions (number of arrays within arrays) in an array.

multi_array = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(multi_array.ndim)  # Output: 3

12. item(): Returns the value at a specific index in a NumPy array (flattened view).

first_element = multi_array.item(0)
print(first_element)  # Output: 1

13. flatten(): Returns a flattened view of the array, collapsing all dimensions into a single row.

flat_array = multi_array.flatten()
print(flat_array)

14. concatenate(): Joins arrays along a specified axis (dimension).

array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])
combined_array = np.concatenate((array1, array2))
print(combined_array)  # Output: [1, 2, 3, 4, 5, 6]

15. stack(): Vertically stacks arrays (combines along the first dimension).

stacked_array = np.stack((array1, array2))
print(stacked_array)  # Output: [[1 2 3], [4 5 6]]

16. vsplit(): Splits an array vertically (along the first dimension) into a list of sub-arrays.

vsplit_arrays = np.vsplit(stacked_array, 2)  # Split into two sub-arrays
print(vsplit_arrays)  # Output: [array([[1, 2, 3]]), array([[4, 5, 6]])]

17. hsplit(): Splits an array horizontally (along the second dimension) into a list of sub-arrays.

hsplit_arrays = np.hsplit(array1, 2)  # Split into two sub-arrays
print(hsplit_arrays)  # Output: [array([1]), array([2, 3])]

18. copy(): Creates a new array with a copy of the data from the original array.

copied_array = my_array.copy()
print(copied_array)  # Output: [1, 2, 3, 4] (independent copy)

19. view(): Creates a new view of the array’s data without copying it (changes in one reflect in the other).

viewed_array = my_array.view()
viewed_array[0] = 100  # Change reflected in original array
print(my_array)  # Output: [100, 2, 3, 4]

20. dot(): Calculates the dot product of two arrays (matrix multiplication for 2D arrays).

matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
dot_product = np.dot(matrix1, matrix2)
print(dot_product)  # Output: [[19, 22], [43, 50]]

21. sum(): Calculates the sum of all elements in the array (or along a specified axis).

sum_of_elements = my_array.sum()
print(sum_of_elements)  # Output: 10

22. mean(): Calculates the mean (average) of all elements in the array (or along a specified axis).

mean_value = my_array.mean()
print(mean_value)  # Output: 2.5

23. std(): Calculates the standard deviation of all elements in the array (or along a specified axis).

standard_deviation = my_array.std()
print(standard_deviation)  # Output: ~1.29

24. where(): Creates a new array with elements from one array where a condition is met.

condition = my_array > 2
filtered_array = np.where(condition, my_array, 0)  # Replace non-matching with 0
print(filtered_array)  # Output: [100, 2, 0, 4]

25. argsort(): Returns the indices that would sort an array along a specified axis.

sorted_indices = my_array.argsort()
print(sorted_indices)  # Output: [1, 2, 3, 0]

Remember, NumPy offers a vast array of methods for data manipulation and analysis. Keep practicing, experimenting, and learning to become a true NumPy master!