Learn NumPy and start doing scientific computing in Python

NumPy is one of the most important libraries in Python for scientific computing. It provides powerful tools for working with large, multi-dimensional arrays and matrices of numerical data. NumPy also offers a wide range of mathematical functions to operate on these arrays efficiently.

If you‘re doing any kind of scientific or numerical computing in Python, learning NumPy is essential. It will allow you to write cleaner, more efficient, and more powerful code to analyze and manipulate your data. In this article, we‘ll dive into the basics of NumPy and learn how to start using it in your own projects.

What is NumPy?

NumPy stands for "Numerical Python". It is an open source Python library used for working with arrays. In NumPy, dimensions are called axes. The number of axes is referred to as the rank.

For example, a 1D array is an array with only 1 axis. A 2D array has 2 axes. In NumPy, each axis is called a dimension. The number of dimensions is called the rank. So a 2D array is said to be of rank 2 and a 3D array is of rank 3.

The most basic object in NumPy is the homogeneous multidimensional array. It is a table of elements (usually numbers), all of the same data type, indexed by a tuple of non-negative integers. In NumPy, dimensions are called axes.

Why use NumPy?

There are several reasons you would want to use NumPy over Python lists for numerical computing:

1. NumPy arrays are more compact than Python lists. A Python list of lists for a 2D array of size 10×10 will take about 20KB of memory. A NumPy 2D array of the same size will only require 4KB of memory. The smaller size of NumPy arrays means that you can fit more data into memory, which is crucial for working with large datasets.

2. NumPy arrays are faster than Python lists. NumPy uses contiguous memory blocks for storing data and has optimized functions for operating on that data. As a result, NumPy can be orders of magnitude faster than Python lists for large arrays. This increased speed makes NumPy especially useful for computationally heavy tasks.

3. NumPy has a powerful N-dimensional array object that provides a lot of functionality. For example, you can easily perform element-wise addition, subtraction, multiplication, and division on NumPy arrays. NumPy also has functions for more complex operations like computing the dot product, determinant, inverse, etc. This extended functionality makes NumPy capable of performing complicated mathematical operations that would be cumbersome with Python lists.

Applications of NumPy

NumPy has a wide range of applications spanning many different fields. Some of the most common uses of NumPy include:

• Data analysis: NumPy provides powerful tools for working with large datasets. You can easily load data from files, manipulate it, compute statistics, and visualize it. NumPy is often used in conjunction with other data analysis libraries like pandas and matplotlib.

• Machine learning: NumPy arrays are the standard way to represent data in many machine learning libraries like scikit-learn and TensorFlow. The ability to efficiently operate on large arrays of numerical data is critical for training machine learning models.

• Scientific computing: NumPy has a vast collection of mathematical functions that are useful for scientific computing tasks. These include functions for working with polynomials, doing Fourier analysis, generating random numbers, and much more. NumPy is the foundation upon which many other scientific Python libraries are built.

• Image and signal processing: NumPy arrays can efficiently represent image and signal data. There are many libraries like scikit-image and scipy.ndimage that build on top of NumPy to provide specialized functions for working with these types of data.

NumPy Basics

Now that we‘ve covered what NumPy is and why you might use it, let‘s dive into the basics of working with NumPy arrays.

The core object in NumPy is the ndarray (N-dimensional array). To create an ndarray, you can pass a Python list to the np.array() function:

import numpy as np

# Create a 1D array
arr1 = np.array([1, 2, 3]) 

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

You can check the number of dimensions of an array using the ndim attribute and the size of each dimension with the shape attribute:

print(arr1.ndim)  # Output: 1
print(arr1.shape) # Output: (3,)

print(arr2.ndim)  # Output: 2  
print(arr2.shape) # Output: (2, 3)

NumPy arrays have a fixed size and data type. You can check the data type of an array using the dtype attribute:

print(arr1.dtype) # Output: int64

Accessing Array Elements

You can access individual elements in a NumPy array using square bracket indexing, just like with Python lists. For multi-dimensional arrays, you need to specify an index for each dimension:

print(arr1[0])  # Output: 1
print(arr2[0,1]) # Output: 2  

You can also access subarrays using slice notation. For example, to select the first two rows of arr2:

print(arr2[:2])
# Output: 
# [[1 2 3]
#  [4 5 6]]  

Array Creation

NumPy provides many functions to create arrays with specific properties. For example, you can create an array filled with zeros using np.zeros():

# Create a 2x3 array filled with zeros
arr = np.zeros((2,3))
print(arr) 
# Output:
# [[0. 0. 0.] 
#  [0. 0. 0.]]

Similarly, you can create an array filled with ones using np.ones() or an array with random values using np.random.random():

# Create a 2x3 array filled with ones  
arr = np.ones((2,3))

# Create a 2x3 array with random values between 0 and 1
arr = np.random.random((2,3))

Array Mathematics

One of the most powerful features of NumPy is the ability to perform mathematical operations on arrays. You can do element-wise arithmetic operations like addition, subtraction, multiplication, and division using the standard arithmetic operators:

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

print(arr1 + arr2) # Output: [5 7 9]
print(arr1 - arr2) # Output: [-3 -3 -3]
print(arr1 * arr2) # Output: [ 4 10 18]
print(arr1 / arr2) # Output: [0.25 0.4  0.5 ]

NumPy also provides a wide range of mathematical functions that operate on arrays, such as np.sin(), np.cos(), np.exp(), etc.:

arr = np.array([0, np.pi/2, np.pi])

print(np.sin(arr)) # Output: [0.0000000e+00 1.0000000e+00 1.2246468e-16]

Broadcasting

NumPy has a powerful broadcasting mechanism that allows arrays with different shapes to be used in arithmetic operations. The smaller array is "broadcasted" to the size of the larger array so that they have compatible shapes.

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

print(arr1 + arr2)
# Output:  
# [[11 22 33]
#  [14 25 36]]

In this example, arr2 has shape (3,) while arr1 has shape (2, 3). Broadcasting allows us to add arr2 to each row of arr1.

Reshaping Arrays

NumPy provides several functions to change the shape of an array. The reshape() function allows you to reshape an array to a new shape without changing its data:

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

print(arr.reshape(2, 3))  
# Output:
# [[1 2 3]
#  [4 5 6]]

You can also flatten an array into a 1D array using the flatten() function:

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

print(arr.flatten()) # Output: [1 2 3 4]  

Conclusion

NumPy is an essential tool for scientific computing in Python. Its powerful N-dimensional array object, along with its vast library of mathematical functions, make it invaluable for data analysis, machine learning, scientific research, and more.

In this article, we‘ve covered the basics of creating and manipulating NumPy arrays, performing mathematical operations, broadcasting, and reshaping arrays. This is just scratching the surface of what NumPy can do. As you work on more projects, you‘ll discover even more advanced features and techniques.

The best way to learn NumPy is through practice. Try working through some tutorials, experimenting with different functions and arrays, and applying NumPy to your own projects. With NumPy in your toolkit, you‘ll be able to write more efficient and powerful scientific Python code.