Create a 1-D array

NumPy is the fundamental package for scientific computing in Python. It provides support for large, multi-dimensional arrays and matrices, along with a vast collection of mathematical functions to operate on these arrays efficiently. NumPy serves as the foundation upon which many of Python‘s most popular data science and scientific computing packages are built, including SciPy, Pandas, Matplotlib, and scikit-learn.

Whether you‘re working with huge datasets, performing complex mathematical operations, or developing machine learning models, getting to grips with NumPy will help take your scientific Python code to the next level. In this guide, we‘ll dive deep into the core capabilities of NumPy, understand the key concepts through practical examples, and uncover tips and best practices to supercharge your data science and numerical computing projects. Let‘s get started!

Why Use NumPy?

At the heart of NumPy is the ndarray – a fast and space-efficient multidimensional array providing vectorized arithmetic operations and sophisticated broadcasting capabilities. While Python has built-in support for arrays, NumPy‘s specialized data structures offer several advantages:

• Performance: NumPy arrays are densely packed in memory due to their homogeneous type. This allows mathematical operations on large chunks of data to be carried out very efficiently.
• Functionality: NumPy comes with an extensive collection of built-in mathematical and statistical functions to perform complex computations on arrays, including mathematical, logical, shape manipulation, sorting, selecting, basic linear algebra, basic statistical operations, random number generation and more.
• Compatibility: The NumPy array object is utilized by many other Python libraries, such as SciPy, Pandas, Matplotlib, scikit-learn and more. Learning NumPy will help you better understand how these libraries work under the hood.

Creating NumPy Arrays

NumPy‘s array class is called ndarray (or alias array). There are several ways to create ndarrays:

1. From Python lists or tuples

import numpy as np

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

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

2. Using built-in NumPy functions

# Create an array of zeros
np.zeros(5)
>>> array([0., 0., 0., 0., 0.])

np.ones((2,3)) 



array([[1., 1., 1.],
[1., 1., 1.]])





np.arange(0, 20, 2)  



array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])

3. From an existing data file

# Load an array from disk
arr = np.load(‘myarray.npy‘)

np.save(‘myarray‘, arr) 

Array Attributes

Once you‘ve created a NumPy array, you can start to examine its attributes:

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

arr.shape



(2, 3)




arr.itemsize 



8




arr.nbytes



48

Accessing and Modifying Array Elements

NumPy offers several ways to index into arrays:

Slicing: Similar to Python lists, NumPy arrays can be sliced along each dimension.

# Create 2x2x3 array
arr = np.array([[[1, 2, 3], [4, 5, 6]], 
                [[7, 8, 9], [10, 11, 12]]])

arr[1, ...]



array([[ 7,  8,  9], 
[10, 11, 12]])




arr[..., 1:3]  



array([[[ 2,  3],
[ 5,  6]],



       [[ 8,  9],    
        [11, 12]]])

Integer array indexing: When using integer arrays for indexing, the shape of the result reflects the shape of the index arrays rather than the shape of the array being indexed.

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


a[[0, 1, 2], [0, 1, 0]]  



array([1, 4, 5])





Boolean array indexing: This type of indexing is used to pick out arbitrary elements of the array. It‘s often used to select elements that satisfy some condition.

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

a[bool_idx]  



array([3, 4, 5, 6])






Array Mathematics
Mathematical and statistical operations on arrays form the cornerstone of scientific computing with NumPy. These operations are designed to be as computationally efficient as possible, without the need for writing loops.
Arithmetic Operations:

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

x + y



array([[ 6,  8], 
[10, 12]])




x - y



array([[-4, -4],
[-4, -4]])




x * y



array([[ 5, 12], 
[21, 32]])




x / y  



array([[0.2       , 0.33333333],
[0.42857143, 0.5       ]])





Statistical Methods:

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



21



arr.min() 



1



arr.max(axis=1)  



array([3, 6])



arr.mean()



3.5



arr.std() 



1.707825127659933





Broadcasting
Broadcasting is a powerful mechanism that allows NumPy to work with arrays of different shapes when performing arithmetic operations. Frequently, we have a smaller array and a larger array, and we want to use the smaller array multiple times to perform some operation on the larger array.
For example, suppose that we want to add a constant vector to each row of a matrix. We could do it like this:

# We will add the vector v to each row of the matrix x,
# storing the result in the matrix y
x = np.array([[1,2,3], [4,5,6], [7,8,9]])
v = np.array([1, 0, 1])
y = np.empty_like(x)   # Create an empty matrix with the same shape as x

for i in range(3):
y[i, :] = x[i, :] + v



y
array([[ 2,  2,  4],
[ 5,  5,  7], 
[ 8,  8, 10]])





This works but when the matrix x is very large, computing an explicit loop in Python could be slow.

Note that adding the vector v to each row of the matrix x is equivalent to forming a matrix vv by stacking multiple copies of v vertically, then performing elementwise summation of x and vv. We could implement this approach like this:

vv = np.tile(v, (3, 1))  # Stack 3 copies of v on top of each other
>>> vv
array([[1, 0, 1], 
       [1, 0, 1],
       [1, 0, 1]])
y = x + vv  # Add x and vv elementwise



y

array([[ 2,  2,  4], 
[ 5,  5,  7],
[ 8,  8, 10]])





NumPy broadcasting allows us to perform this computation without actually creating multiple copies of v. Consider this version, using broadcasting:

y = x + v  # Add v to each row of x using broadcasting    
>>> y
array([[ 2,  2,  4],
       [ 5,  5,  7], 
       [ 8,  8, 10]])

The line y = x + v works even though x has shape (3, 3) and v has shape (3,) due to broadcasting.
Working with Mathematical Formulas
NumPy provides a vast array of mathematical functions that you can directly apply to arrays, allowing you to implement mathematical formulas with minimal code:

# Trigonometric Functions
angles = np.linspace(0, 2 * np.pi, 3)
np.sin(angles)
>>> array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])

np.exp(angles)  



array([1.        , 535.49165552,   1.        ])




np.sinh(angles)



array([0.00000000e+00, 3.62686041e+00, 1.22464680e-16])






Linear Algebra
NumPy provides a plethora of functions to perform linear algebra calculations, such as matrix multiplication, transpose, decompositions, determinants, and more.

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

np.matmul(a,b)



array([[19, 22],
[43, 50]])




np.linalg.det(a)



-2.0000000000000004




np.linalg.eig(a)  



(array([-0.37228132,  5.37228132]),
array([[-0.82456484, -0.41597356],
[ 0.56576746, -0.90937671]]))





Random Sampling
NumPy‘s random module provides numerous functions to generate arrays with various random distributions. This is incredibly useful for simulations, testing algorithms, and more.

# Generate a 2x3 array of random integers between 0 (inclusive) and 10 (exclusive)
np.random.randint(0, 10, (2,3))
>>> array([[2, 2, 6],
           [1, 3, 6]])

np.random.normal(0, 1, (2,3))



array([[ 0.6476239 , -0.94408546,  0.23281562],
[ 1.46916825,  0.2643683 , -0.42159474]])




arr = np.array([1, 2, 3, 4, 5])
np.random.shuffle(arr)



arr
array([2, 4, 1, 5, 3])






Best Practices and Tips

Vectorize operations when possible, avoiding explicit loops.
Use broadcasting to perform operations on arrays with differing shapes.
Leverage built-in NumPy functions and methods rather than manually implementing them.
Be mindful of array shapes and data types to ensure compatibility and performance.
Utilize views instead of copies when manipulating subsets of data to conserve memory.
Leverage NumPy‘s integration with other scientific Python libraries like SciPy, Pandas, and Matplotlib.

Conclusion
NumPy is an incredibly powerful library that forms the backbone of scientific computing in Python. Its ability to efficiently store and manipulate large arrays, coupled with its vast collection of mathematical functions, makes it an indispensable tool for any data scientist or engineer.
In this guide, we‘ve covered the core concepts and features of NumPy, from creating arrays and accessing elements to performing complex mathematical operations and random sampling. By leveraging NumPy‘s capabilities and following best practices, you‘ll be able to write more efficient, expressive, and robust scientific Python code.
As you continue on your data science journey, keep exploring NumPy and its many applications. With a solid grasp of this fundamental library, you‘ll be well-equipped to tackle a wide range of computational challenges across various domains, from machine learning and image processing to physics simulations and financial modeling. Happy coding!


	
Related