DEV Community: Sahil

NumPy 101: Learn NumPy in 10 minutes

Sahil — Sat, 01 Apr 2023 04:23:44 +0000

Numpy is a popular Python library for scientific computing and data analysis. It provides a powerful array object, along with many useful functions and methods for manipulating and processing numerical data. In this blog post, I will share some of the essential numpy operations that can help you write faster and cleaner code. Whether you are a beginner or an expert, I hope you will find something useful in this numpy cheat sheet.

Installation

If you dont have numpy, then first you need to install it. You can install it in two days:

Using pip

pip install numpy

Using Conda

First, activate your anaconda environment and then use the following command:

conda install -c anaconda numpy

The Basics

Before doing any operations using numpy, we need to import it.

import numpy as np

Scalar

Lets start from the very basic and learn how to create scalar values of numpy class.

# int type

python_int = 2
numpy_int = np.int32(2)
print(type(python_int)) # ---> <class 'int'>
print(type(numpy_int)) # ---> <class 'numpy.int32'>

# float type

python_float = 2.5
numpy_float = np.float32(2.5)
print(type(python_float)) # ---> <class 'float'>
print(type(numpy_float)) # ---> <class 'numpy.float32'>

For more detail, take a look at the documentation https://numpy.org/doc/stable/reference/arrays.scalars.html#

Now, its time to move on to Arrays or Lists.

1-D Array

Lets now create a 1-D array using numpys array() method.

# creating an 1-D array of int type

one_d_array_int = np.array([1,2,3]) 
print(one_d_array_int) # ---> output : [1 2 3]

# creating an 1-D array of float type

one_d_array_float = np.array([1.5,2.5,3.5])
print(one_d_array_float) # ---> output : [1.5 2.5 3.5]

2-D Array

Lets now create a 2-D array using numpys array() method.

# 2-D int array

two_d_array_int = np.array([
                [1,2,3],
                [4,5,6],
                [7,8,9]
               ])
print(two_d_array_int) # ---> [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 2-D float array

two_d_array_float= np.array([
                [1.1,2.1,3.0],
                [4.1,5.1,6.1],
                [7.1,8.1,9.1]
               ])
print(two_d_array_float) # ---> [[1.1, 2.1, 3.0], [4.1, 5.1, 6.1], [7.1, 8.1, 9.1]]

Get The Dimension of an Array

Now, lets learn how do you get the dimension of the any array.

# If the array is a 1-D array, then it'll return 1
print(one_d_array_int.ndim) # ---> output : 1

# If the array is a 2-D array, then it'l return 2
print(two_d_array_int.ndim) # ---> output : 2

Get The Shape of an Array


print(one_d_array_int.shape) # ---> output : (3,)

print(two_d_array_int.shape) # ---> output : (3, 3)

As, the one_d_array_int is basically a vector, it returns the shape of a vector, whereas two_d_array_int is a matrix which has 3 rows and 3 columns and thats why it returns the shape as (3, 3).

Get the Data Type of an Array

print(one_d_array_int.dtype) # ---> output : dtype('int32')

By default, its int32 and there are different size of int in numpy that you can use to optimise your space consumption.

Manipulating Elements of an Array

Lets create a new array and then we will perform operations on this new array.

a = np.array([[1,2,3,4,5,6,7],[8,9,10,11,12,13,14]])
print(a) # ---> output : [[1 2 3 4 5 6 7]
# [8 9 10 11 12 13 14]]

Access a Specific Element

Lets say we want to access first rows third element.

# accessing 1st row's 3rd element
print(a[0,2]) # ---> output : 3

In numpy to access a specific element then, we first need to specify the row and then the column.

Remember, numpy also follows the 0-based indexing and due to this if we want to get the first row, we need to write 0 and not 1 and same goes for the column value if we needed the third element, then well write 2 and not 3.

Access only a specific row or column

# accessing only the first row
print(a[0,:]) # ---> output : [1 2 3 4 5 6 7]

# accessing only the second column
print(a[:,1]) # ---> output : [2 9]

Access elements with skip steps

# [startindex:endindex:stepsize]
print(a[0, 1:-1:2]) # ---> output : [2 4 6]

Here, you are accessing first rows columns from 2nd column to the last column by accessing every 2nd column.

Changing elements value

a[0,2] = 99
print(a) # ---> output : [[1 2 99 4 5 6 7]
# [8 9 10 11 12 13 14]]

Here, you first assigned the value 99 to the first rows third column.

Special Arrays in Numpy

Zero Matrix

# creating a zero matrix of shape(2,3)

print(np.zeros((2,3))) # ---> output : [[0. 0. 0.]
 # [0. 0. 0.]
 # [0. 0. 0.]]

Here, 2 is the number of rows and 3 is the number of columns.

One Matrix

# All 1s matrix
print(np.ones((3,2,2))) # ---> output : [[[1. 1.]
# [1. 1.]]
#
# [[1. 1.]
# [1. 1.]]
#                                      
# [[1. 1.]
# [1. 1.]]]

# creating ones matrix int type
print(np.ones((3,2,2)), dtype='int32') # ---> output : [[[1 1]
# [1 1]]
#
# [[1 1]
# [1 1]]
#                                      
# [[1 1]
# [1 1]]]

Here, you are creating a matrix of ones. If you dont specify any data type then itll by default generate float type elements.

Random Array

If you want to have an array having random values of a specific shape, then you can use np.random.rand() method.

print(np.random.rand(3,3)) # ---> output : [[0.10671372 0.31133182 0.56572354]
# [0.34792672 0.88867917 0.25310353]
# [0.70052117 0.53243035 0.67948057]]

Random Array ( Only Integer Values )

If you want to have an array having random int values of a specific shape, then you can use np.random.randint() method.

# np.random.randint(start_value,end_value,size)

print(np.random.randint(-1,5, size=(3,3))) # ---> output : [[0 -1 2]
# [4 2 1]
# [4 4 0]]

start_value is inclusive thats why -1 is there in the output array.

end_value is exclusive thats why there is no 5 in the output array.

If you dont mention the start_value, then the default start value would be 0. You have to mention the end_value.

Identity Matrix

If you want to create an Identiity matrix, then you can use np.identity() method.

print(np.identity(3)) # ---> output : [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]

You have to mention the number_of_dimensions.

Transposing Array

a = np.random.randint(-1,5, size = (2,3)) # creating a random int array
print(a) # output : [[2 -1 1]
                                          # [0 1 1]]

print(a.T) # output : [[2 0]
                                          # [-1 1]
                                          # [1 1]]

Reshape Array

If you want to change the shape of the array you can use reshape() method.

a = np.random.randint(-1,5, size = (2,3)) # creating a random int array
print(a) # output : [[2 -1 1]
                                          # [0 1 1]]

print(a.reshape(3,2)) # output : [[2 0]
                                          # [-1 1]
                                          # [1 1]]

print(a.reshape(1,6)) # output : [[1 2 3 2 2 2]]

Note : You cant reshape (2,3) array to (3,3) as the original array has 6 cells while the new shape you want to have has 9 cells.

Fill with Any Number

If you want to have an aray filled with a specific value, then you can use np.full() method.

print(np.full((3,3), 14)) # ---> output : [[14 14 14]
# [14 14 14]
# [14 14 14]]

Fill Like

If you want to have an array with a specific value and you want it to be of same shape as some other array, then you can use np.full_like() method.

# Any other number (full_like)
print(np.full_like(a, 4)) # ---> output : [[4 4 4 4 4 4 4]
# [4 4 4 4 4 4 4]]

This method takes the shape of the mentioned array and a value, then it creates a new array of the same shape with the given value.

Copy Array

a = [1,2,3] # created an array a
b = [10,20,30] # created an array b
print(a) # output : [1 2 3]
a = b # I'll explain it below
b[1] = 200 # changed b's 2nd element's value to 200
print(a) # output : [10 200 30] HOW??????

Lets first understand what happened here : a = b.

Here, the values of b didnt get copied to a, instead a starts to point to b which in-turn changes the values of a but the catch is that whenever youll change something in b the same will reflect on a.

Stacking Arrays

If you want to stack multiple arrays vertically or horizontally, you can use vstack() method or hstack() method respectively.

# Vertically stacking vectors
v1 = np.array([1,2,3,4]) # created array v1
v2 = np.array([5,6,7,8]) # create array v2

np.vstack([v1,v2,v1,v2]) # output : [[1 2 3 4]
                                        # [5 6 7 8]
                                        # [1 2 3 4]
                                        # [5 6 7 8]]
print(np.hstack([v1,v2])) # output : [1 2 3 4 5 6 7 8]

Aggregate Functions

a = np.array([1, 2, 3])
print(a.sum()) # sum of all values of a
print(a.max()) # max of all elements of a
print(a.mean()) # return mean of a
print(np.median(a)) # return median of a
print(np.std(a)) # return standard deviation of a

Conclusion

This concludes our numpy cheatsheet blogpost. We hope you found it useful and learned some new tricks to work with arrays and matrices in Python. Numpy is a powerful and versatile library that can help you perform various numerical computations and data analysis tasks. If you want to learn more about numpy, you can check out the official documentation or some of the online tutorials and courses available. Thank you for reading and happy coding!

What's new in Python 3.9

Sahil — Mon, 20 Jul 2020 14:46:56 +0000

A new version of Python is coming! Soon, we'll be using it in our python projects. As of 20/07/2020 Python 3.9 is in beta version(3.9.0b4) and will release the full version of Python 3.9 pretty soon.

Enough of introduction. Let's get started and learn about the new features.

New features in Python 3.9

Dictionary merge and update operators

Python 3.9 introduces merge(|) and update(|=) operators in the dict class. If you have two dictionaries a and b, you can now use these operators to do merge and update them.

a = {1: "Sam", 2: "Alex"}
b = {3: "Daniel", 4: "Tom", 5: "Jimmy"}

You can use | to merge these both dictionaries.

c = a|b
print(c)

**[Output]**: {1: "Sam", 2: "Alex", 3: "Daniel", 4: "Tom", 5: "Jimmy"}

If both the dictionaries have a common key, then the output will display the second key-value pair.

a = {1: "Sam", 2: "Alex", 3: "James"}
b = {3: "Daniel", 4: "Tom", 5: "Jimmy"}

c = a|b
print(c)

**[Output]**: {1: "Sam", 2: "Alex", 3: "Daniel", 4: "Tom", 5: "Jimmy"}

For updating the dictionary, you can use the following operator.

a = {1: "Sam", 2: "Alex"}
b = {2: "Daniel"}
a|=b
print(a)

**[Output]: {1: "Sam", 2: "Daniel"}**

removeprefix() and removesuffix() string methods

In Python’s str class, the new update introduces new removeprefix() and removesuffix() methods.

You can remove the prefix from any string using the removeprefix() method.

'HelloWorld'.removeprefix('Hello')
**[Ouput]: 'World' **

If the string doesn’t start with the input prefix, the copy of the original string will be returned.

'BaseTestCase'.removeprefix('Test')
**[Ouput]: 'BaseTestCase' **

If the string ends with input suffix, the output will look like string[:-len(suffix)].

'MiscTests'.removesuffix('Tests')
'Misc'

If the input suffix is empty or the string doesn’t end with it, the output will be a copy of the original string.

'BadTestCase'.removesuffix('Tmp')
'BadTestCase'

New parser

Python 3.9 uses a new parser which is a PEG-based parser. Previously, Python used LL(1). PEG is more flexible than LL(1) when it comes to building new features in the language. The official documentation says that this flexibility will be seen in Python 3.10 and later.

Type hinting

Python dynamically specifies datatypes to a variable. For static allocation of data types, type hinting is used. This was introduced in Python 3.5.
You can now use built-in collection types (list and dict ) as generic types. Earlier, you had to import the capital types (List or Dict) from typing.

def greet_all(names: list[str]) -> None:
    for name in names:
        print("Hello", name)

Now there is no need to call List from typing.List.