LanguagesPythonIntroduction to Python NumPy

# Introduction to Python NumPy

Developer.com content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.

NumPy is short for “Numerical Python” and is a popular Python library used in scientific computing scenarios. The library provides support for things such as mathematical functions, linear algebra, and support for arrays – to name but a few. It is considered an important tool for data scientists and developers look to manipulate or analyze data. In this tutorial, we will explore the basics of working with NumPy in Python, learning why you should use it and reviewing code examples to better understand its syntax and use.

## What is NumPy? NumPy is an open source library Python developers can use to work with large, multi-dimensional arrays and matrices. The library also contains a vast collection of mathematical functions that you can use to perform equations and evaluation on arrays and matrices. Its was developed as a way to perform efficient array operations in a convenient manner (versus manual calculations), with particular emphasis on numerical and scientific computational tasks.

## Why Use NumPy?

NumPy offers several advantages for developers and data scientists looking to automate tasks with Python. They include the following:

• Efficiency: NumPy arrays are considered more memory-efficient and faster to operate on than Python lists. This is especially true when working with large datasets.
• More Convenient: NumPy, as stated, offers a vast range of built-in functions for both common mathematical and statistical operations. These save developers time by saving them from having to write functions from scratch. Another byproduct of this is that it reduces human errors in typing and mathematical logic.
• Interoperability: NumPy integrates with many other scientific computing libraries, including SciPy (used for advanced scientific and engineering computations) and Matplotlib (used for data visualization).
• Compatibility: In addition to integrating with other scientific computing libraries, NumPy is also compatible with data analysis libraries, such as pandas and scikit-learn, both of which are built on top of NumPy. This helps ensure compatibility with a wide range of tools and libraries within the Python developer ecosystem.

Now that we understand why you should use NumPy and what it is, let’s delve into how to install NumPy and the basics of how to use it.

## How to Install NumPy

Like most libraries, before you can use NumPy you need to first install it. You can do so by using a Python package manager like pip or conda (for those of you using the Anaconda distribution).

To install NumPy with pip, you must first open up your command prompt and enter the following command:

```pip install numpy
```

To install NumPy using conda, using the following command:

```conda install numpy
```

Next, once NumPy has been installed, you can import it into your Python scripts or interactive sessions using a simple import method, like so:

```import numpy as np
```

It should be noted that the convention is to use import NumPy as np. This makes it easier to refer to NumPy functions and objects.

## How to Create NumPy Arrays

Below is a code example demonstrating how to create NumPy arrays. Our first example shows how to create arrays from lists in Python, which is the most common method.

```import numpy as np

# How to create a NumPy array from a list
our_list = [1, 2, 3, 4, 5]
our_array = np.array(our_list)

print(our_array)
```

Running this code creates the following output:

```[1 2 3 4 5]
```

### NumPy Array Attributes

NumPy arrays host several attributes used to provide information about an array. This can include things like shape, size, data type, and so forth. Below are the three most common attributes:

• shape: Used to return a tuple that represents the dimensions of an array.
• dtype: Used to return the data type of an array’s elements.
• size: Used to return the total number of elements in an array.

Here is a code example of how to work with Python NumPy array attributes:

```import numpy as np

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

print("The Shape is:", arr.shape)
print("The Data Type is:", arr.dtype)
print("Th Size is:", arr.size)
```

Running this code produces:

```The Shape is: (5,)
The Data Type is: int64
The Size is: 5
```

## Basic NumPy Array Operations

Below are some of the basic operations programmers can perform on NumPy arrays in Python.

### Indexing and Slicing NumPy Arrays

In Python, NumPy supports the concept of indexing and slicing of arrays, similar to the equivalent list operations. Developers can access each element in an array, or the slices of an array, using square brackets [ ]. It should be noted that NumPy uses 0-based indexing.

Here is a code example showing how to slice NumPy arrays:

```import numpy as np

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

# How to access individual elements
print("First element:", arr)
print("Last element:", arr[-1])

# How to slice
print("Here is a slice from index 1 to 3:", arr[1:4])
```

This produces the output:

```First element: 1
Last element: 5
Here is a slice from index 1 to 3: [2 3 4]
```

### How to Reshape NumPy Arrays

NumPy array shapes can be changed using the reshape method. This is helpful when you need to convert a 1D array into a 2D or higher-dimensional array. Here is some code showing how to use the reshape method on a NumPy array:

```import numpy as np

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

# Reshape a 2x3 array
our_shape = (2, 3)
reshaped_arr = arr.reshape(our_shape)

print(reshaped_arr)
```

Here, the output would be:

```[[1 2 3]
[4 5 6]]
```

### How to Combine Arrays

NumPy arrays can be combined using several functions, including:

• np.concatenate
• np.vstack (vertical stack)
• np.hstack (horizontal stack)

Each of these functions allow you to join arrays along specified axis’.

```import numpy as np

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

# Concatenate along a specified axis (0 for rows, 1 for columns)
joined_arr = np.concatenate([arr1, arr2], axis=0)

print(joined_arr)
```

The output would be:

```[1 2 3 4 5 6]
```

## Element-wise Operations

One key feature of NumPy involves its ability to perform element-wise operations, which are used to apply an operation to each element in an array. This is particularly helpful for mathematical operations and can be performed using the standard arithmetic operators or NumPy functions.

```import numpy as np

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

test_result = arr1 + arr2

# Performing element-wise multiplication
more_result = arr1 * arr2

print("Element-wise multiplication:", more_result)
```

If we were to run this, we would get the output:

```Element-wise addition: [5 7 9]
Element-wise multiplication: [ 4 10 18]
```

## NumPy Functions and Universal Functions

Below are several important types of NumPy functions developers should be aware of.

### Mathematical NumPy Functions

As noted, NumPy provides a huge amount of mathematical functions that can be applied to arrays. These functions operate element-wise and can include trigonometric, exponential, and logarithmic functions, to name but a few. Here are some code examples demonstrating NumPy mathematical functions:

```import numpy as np

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

# Showing the square root of each element
sqrt_arr = np.sqrt(arr)

print("The Square root is:", sqrt_arr)

# Showing the Exponential function
exp_arr = np.exp(arr)

print("The Exponential is:", exp_arr)
```

Here, the anticipated output would be:

```The Square root is: [1.         1.41421356 1.73205081]
The Exponential is: [ 2.71828183  7.3890561  20.08553692]
```

## Aggregation Functions

NumPy offers functions for aggregating data, including those for computing the sum, mean, minimum, and maximum of an array.

```import numpy as np

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

# Sum all elements
sum_arr = np.sum(arr)

print("The Sum is:", sum_arr)

# Mean of all elements
mean_arr = np.mean(arr)

print("The Mean is:", mean_arr)

# Maximum and minimum
max_val = np.max(arr)
min_val = np.min(arr)

print("The Maximum value is:", max_val)
print("The Minimum value is:", min_val)
```

resulting in the output:

```The Sum is: 15
The Mean is: 3.0
The Maximum is: 5
The Minimum is: 1
```

NumPy lets developers broadcast, which is a powerful feature when you want to perform operations on arrays of different shapes. When broadcasting, smaller arrays are “broadcasted” to match the shape of the larger arrays, which makes element-wise operations possible. Here is a demonstration:

```import numpy as np

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

# How to Broadcast the scalar to the array
test_result = arr * scalar

```

Our output?

```Broadcasted multiplication: [2 4 6]
```

## How to Perform Linear Algebra with NumPy

One of NumPy’s most common uses is for linear algebra operations. Coders can perform matrix multiplication, matrix inversion, and other types of linear algebra operations simply with the Python library.

```import numpy as np

# How to create matrices
matrix_a = np.array([[1, 2], [3, 4]])
matrix_b = np.array([[5, 6], [7, 8]])

# Example of matrix multiplication
result = np.dot(matrix_a, matrix_b)

print("Matrix multiplication result:")
print(result)

# Example of matrix inversion
inverse_a = np.linalg.inv(matrix_a)

print("Matrix inversion result:")
print(inverse_a)
```

The result here would be:

```Matrix multiplication result:
[[19 22]
[43 50]]

Matrix inversion result:
[[-2.   1. ]
[ 1.5 -0.5]]
```

<3>Solving Linear Equations with NumPy

NumPy can further be used to solve systems of linear equations using the numpy.linalg.solve function, shown below:

```import numpy as np

# Example of a coefficient matrix
A = np.array([[2, 3], [4, 5]])

# Example of a right-hand side vector
b = np.array([6, 7])

# How to Solve the linear equation of Ax = b
x = np.linalg.solve(A, b)

print("The solution for x is:", x)
```

Our output:

```The solution for x is: [-5.  6.]
```

## Data Generation with NumPy

NumPy has several functions for generating random data also, which can be used for simulations and testing purposes. Here are some random number generation examples:

```# Random number generation with NumPy
import numpy as np

# Generate random integers ranging between 1 and 100
random_integers = np.random.randint(1, 101, size=5)

print("Some random integers:", random_integers)

# Generate random floating-point numbers between 0 and 1
random_floats = np.random.rand(5)

print("Some random floats:", random_floats)
```

Output:

```Some random integers: [58  3 62 67 43]
Some random floats: [0.82364856 0.12215347 0.08404936 0.07024606 0.72554167]
```

Note that your output may differ from mine since the numbers are randomly generated each time the code is run.

### Data Sampling

NumPy can be used for data sampling as well. For example, here is how you can sample data from a given dataset.

```import numpy as np

# Sample data set
data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

# Randomly sampling 3 elements without replacement
test_sample = np.random.choice(data, size=3, replace=False)

print("Random sample:", test_sample)
```

The output here would be:

```Random sample: [ 1  7 10]
```

## NumPy Best Practices

Below are some best practices for when working with NumPy in Python.

### Memory Efficiency

NumPy arrays, by default, are more memory-efficient. That being said, it is important to be mindful of memory usage, especially when working with larger datasets. Developers should avoid creating unnecessary copies of arrays, and, instead use slicing and views whenever possible to save memory.

### Vectorization

Vectorization refers to performing operations on entire arrays, rather than using explicit loops. This is a fundamental concept of NumPy, which can significantly improve performance. In cases where you find yourself using loops to iterate over elements, consider, instead, whether you can rewrite your code to use NumPy’s vectorized operations.

### Avoid Python Loops

Although NumPy provides tools for more efficient array operations, Python loops are slow when applied to NumPy arrays. Instead of using loops, try to express operations as array operations whenever possible, as these are much faster.

## Final Thoughts on Python NumPy

In this tutorial we learned that NumPy is a powerful library that is the foundation of scientific computing in Python. Here, we learned how to install NumPy, create arrays, perform basic operations, use NumPy functions, and even dove head first into linear algebra. With further practice and deeper exploration, programmers can harness all of NumPy’s considerable might for data analysis, machine learning, and scientific computing tasks. Remember that NumPy’s efficiency and convenience are the main facets that make it an indispensable tool for anyone – programmer, researcher, or data scientist – working with numerical data in Python.

Subscribe to Developer Insider for top news, trends & analysis