Numpy Cheat Sheet : analyse de données essentielles en Python

En tant que data scientist travaillant avec Python, vous avez très probablement rencontré la bibliothèque NumPy . C'est l'un des packages de base pour le calcul scientifique en Python .

Avec sa capacité à effectuer des opérations hautes performances sur des tableaux multidimensionnels, NumPy est un outil essentiel pour quiconque plonge dans la science des données ou le calcul numérique en Python.

Une feuille de triche NumPy peut être une excellente ressource pour vous guider dans votre voyage dans cette bibliothèque Python. Une feuille de triche complète vous aidera à naviguer dans les fonctionnalités de NumPy et à maîtriser rapidement son utilisation pour diverses tâches !

N'oubliez pas non plus que NumPy est au cœur d'importantes bibliothèques telles que Pandas, SciPy, sci-kit-learn et d'autres packages Python.

En maîtrisant ses bases grâce à l'aide de la feuille de triche Python NumPy , vous serez mieux équipé pour travailler avec ces bibliothèques. Vous développerez également vos compétences dans la gestion de structures de données et de calculs complexes.

Êtes-vous de la vieille école (comme nous) et souhaitez-vous télécharger et éventuellement imprimer votre aide-mémoire ?

Faites défiler vers le bas pour le faire.

Table des matières

• Les bases de NumPy
  • 1. Installer et importer NumPy
  • 2. Création de tableau
  • 3. Attributs de tableau
  • 4. Types de données
• Manipulation de tableaux
  • 1. Remodelage
  • 2. Copie
  • 3. Concaténation
  • 4. Fractionnement
  • 5. Ajout/suppression d'éléments
  • 6. Indexation
  • 7. Trancher
• Fonctions élémentaires
  • 1. Opérations arithmétiques
  • 2. Trigonométrie
  • 3. Exposants et logarithmes
• Analyse de tableau
  • 1. Fonctions d'agrégation
  • 2. Fonctions statistiques
  • 3. Recherche
  • 4. Tri
• Fonctions avancées
  • 1. Radiodiffusion
  • 2. Algèbre linéaire
• Entrée et sortie
  • 1. Enregistrement et chargement de tableaux
  • 2. Lecture et écriture dans des fichiers texte
• Téléchargez votre feuille de triche ci-dessous
• Dernières pensées

Les bases de NumPy

Dans cette section, nous couvrirons les bases de NumPy, en nous concentrant sur l'installation de NumPy, la création de tableaux, les attributs de tableau et les types de données. Ces concepts fourniront une base solide pour comprendre et utiliser efficacement NumPy dans vos projets de science des données Python.

1. Installer et importer NumPy

Vous pouvez installer NumPy depuis la ligne de commande en utilisant la commande ci-dessous :

pip install numpy

Une fois installé, importez-le dans votre code.

import numpy as np

Gardez à l'esprit que vous pouvez utiliser n'importe quel autre nom en dehors de np . Cependant, np est la convention d'importation NumPy standard utilisée par la plupart des développeurs et des data scientists.

2. Création de tableau

La création de tableaux dans NumPy est simple et directe. Vous pouvez créer des tableaux à partir de listes ou de tuples à l'aide de la fonction numpy.array() :

import numpy as np

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

Vous pouvez également générer des tableaux de formes et de valeurs spécifiques à l'aide de diverses fonctions :

• np.zeros() : Crée un tableau rempli de zéros

• np.ones() : Crée un tableau rempli de uns

• np.identity() : Crée un tableau de matrice d'identité.

• np.empty() : Crée un tableau sans initialiser ses éléments à une valeur particulière

• np.arange() : Crée un tableau avec des valeurs régulièrement espacées entre une valeur de début et de fin

• np.linspace() : Crée un tableau avec un nombre spécifié de valeurs régulièrement espacées entre une valeur de début et de fin

Remarque : Vous ne pouvez pas générer un tableau vide dans NumPy. Chaque tableau NumPy a une taille fixe et immuable et chaque élément du tableau doit être rempli lors de la création du tableau.

La fonction np.empty() crée la forme de tableau requise et la remplit avec des valeurs aléatoires. La méthode par défaut crée un tableau de flottants aléatoires.

Vous pouvez créer un type de données de tableau différent à l'aide du paramètre dtype .

3. Attributs de tableau

Les tableaux NumPy ont plusieurs attributs qui fournissent des informations utiles sur le tableau. Regardons certains d'entre eux :

• ndarray.shape : renvoie les dimensions du tableau sous forme de tuple (lignes, colonnes)

• ndarray.ndim : renvoie le nombre de dimensions dans le tableau

• ndarray.size : renvoie le nombre total d'éléments dans le tableau

• ndarray.dtype : renvoie le type de données des éléments du tableau

Pour accéder à ces attributs, utilisez la notation par points, comme ceci :

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

#Print out the array shape
print(a.shape)  # Output: (2, 3)

4. Types de données

NumPy fournit plusieurs types de données pour stocker des données dans des tableaux, tels que entier, chaîne, flottant, booléen et complexe. Par défaut, NumPy essaie de déduire le type de données en fonction des éléments d'entrée.

Cependant, vous pouvez également spécifier explicitement le type de données à l'aide du mot-clé dtype . Par exemple:

import numpy as np
a = np.array([1, 2, 3], dtype=float)  # Creates an array of floats

Les types de données NumPy courants incluent :

• np.int32 : entier 32 bits

• np.int64 : entier 64 bits

• np.float32: 32-bit floating-point number

• np.float64: 64-bit floating-point number

• np.complex: Complex number, represented by two 64-bit floating-point numbers

You can also convert arrays from one data type to another. In this example, here’s how we can convert the Integer array a into a Boolean array arr using the np.array() method.

From the example, we can see the array() method converts the array elements into boolean values. These boolean values then form the new NumPy array arr.

Understanding these basic concepts of NumPy will allow you to effectively work with arrays and perform a variety of mathematical NumPy operations. For example, you can check out our video on how to transform and code addresses In Python.

In it, we used Python Pandas and NumPy data types to geocode home addresses.

Array Manipulation

In this section, you will learn about various array shape manipulation techniques in NumPy. We will discuss reshaping, concatenation, copying, splitting, adding/removing elements, indexing, and slicing.

These techniques are crucial for effectively working with array data in your data science projects.

Let’s dive into each sub-section.

1. Reshaping

Reshaping an array in NumPy is a common task you’ll perform. You might need to change the shape of your array to match the requirements of a function or an algorithm.

To reshape an array, use the reshape() function:

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

This will convert your one-dimensional array into a two-dimensional array with 2 rows and 3 columns.

Note: Make sure the new shape you provide has the same size (number of array elements) as the original array.

2. Copying

You can copy the elements in one NumPy array to another using the copy() method. You should note that using the assignment operator ‘=’ creates a shallow copy.

#Creating a shallow copy of a NumPy array
a = np.array([9, 6, 12, 16, 20])
b = a
b[0] = 19

print(a) #Output:[19, 6, 12, 16, 20]
print(b) #Output:[19, 6, 12, 16, 20]

The new array only references the old array in the system’s memory. They contain the same elements and they are not independent of each other.

By using the deep copy, you create a new NumPy array that contains the same data as the old one while being independent of it.

#Creating a deep copy of a NumPy array
a = np.array([9, 6, 12, 16, 20])
b = np.copy(a)
b[0] = 19

print(a) #Output:[9, 6, 12, 16, 20]
print(b) #Output:[19, 6, 12, 16, 20]

3. Concatenation

Occasionally, you may need to merge two arrays into a single one. In NumPy, you can use the concatenate() function to join arrays along an existing axis:

import numpy as np

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

This combines arr1 and arr2 into a single array. Keep in mind that the arrays being concatenated should have the same shape, except along the specified axis.

4. Splitting

Splitting is the opposite of concatenation. You can divide an array into smaller sub-arrays using the split() function:

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

This splits the array into 3 equal-sized sub-arrays. Ensure that the number of splits you specify can evenly divide the size of the array along the given axis.

5. Adding/Removing Elements

Adding or removing elements in a NumPy array can be achieved using the append() and delete() functions. You can use the former to append values to the end of the array while the latter deletes the element at a specified index.

Here’s an example:

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

arr = np.append(arr, [4, 5, 6]) # Appends values to the end of the array
arr = np.delete(arr, 0) # Removes the array element on index 0

Keep in mind that NumPy arrays have a fixed size. When using append() or delete(), a new array is created, and the original one is not modified.

6. Indexing

You can perform indexing operations on NumPy arrays the same way you’d do them on Python lists or tuples. Let’s look at how you can access or change array elements in a given array.

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

#Returns the array element on index 1
element_2 = b[1]

#Change the array element on index 0
arr[0]= 89

7. Slicing

You can also slice NumPy arrays to extract or view a section of the data the same way you’d do Python lists or sets. Let’s take a look at an example below:

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

# To return the first 3 elements of arr1
print(arr1[0:3]) #Output: [1, 2, 3]

# To return the second row in arr2
b = arr2[1, : ].copy() #Output: [4, 5, 6, 11, 13]

Note: Slicing creates a shallow copy that still references the main array. So, any change you make to the sliced data will be applied to the main array and vice versa.

To avoid this, you can use the copy() method to create a deep, independent copy.

Elementary Functions

In this section, you’ll learn about different elementary functions in NumPy, which will ease your data analysis tasks. We’ll cover arithmetic operations, trigonometry, and exponents and logarithms.

1. Arithmetic Operations

NumPy offers various math operations on arrays that make them simple and efficient to work with. array mathematics vector math

Some of the operations are:

• Addition: numpy.add(x1, x2)

• Subtraction: numpy.subtract(x1, x2)

• Multiplication: numpy.multiply(x1, x2)

• Division: numpy.divide(x1, x2)

• Modulus: numpy.mod(x1, x2)

• Power: numpy.power(x1, x2)

• Square root: numpy.sqrt(x)

Note: When using these operations, the two arrays must be the same shape. If not, you’ll run into errors.

There is an exception for certain arrays thanks to a NumPy feature called broadcasting. We’ll cover that in a later section.

You can perform these operations element-wise on the arrays, which makes them highly efficient for large-scale data manipulation.

2. Trigonometry

Trigonometric functions play a significant role in various mathematical and scientific computations. NumPy provides a wide range of trigonometric functions.

Some of the essential functions are:

• Sine: numpy.sin(x)

• Cosine: numpy.cos(x)

• Tangent: numpy.tan(x)

• Arcsine: numpy.arcsin(x)

• Arccosine: numpy.arccos(x)

• Arctangent: numpy.arctan(x)

These functions work seamlessly with arrays, making it easier for you to perform vectorized computations on large datasets.

3. Exponents and Logarithms

Exponents and logarithms are crucial for various numerical operations. NumPy provides an extensive collection of functions for dealing with exponents and logarithms.

Some of the primary functions are:

• Exponential: numpy.exp(x)

• Logarithm(base e): numpy.log(x)

• Logarithm(base 10): numpy.log10(x)

• Logarithm(base 2): numpy.log2(x)

Utilizing these functions, you can quickly perform complex mathematical operations on each element in the array. This makes your data analysis tasks more accessible and efficient.

Array Analysis

In this section, we will discuss various techniques to analyze arrays and array elements in NumPy. Some of the key features we will cover include aggregate functions, statistical functions, searching, and sorting.

1. Aggregate Functions

NumPy provides several aggregate functions that allow you to perform operations on arrays, such as summing all their elements, finding the minimum or maximum value, and more:

• sum: np.sum(your_array) – Calculate the sum of all the elements in the array.

• min: np.min(your_array) – Find the minimum array element.

• max: np.max(your_array) – Find the maximum array element.

• mean : np.mean(your_array) – Calcule la moyenne des valeurs du tableau.

• median : np.median(your_array) – Trouver la médiane des valeurs du tableau.

2. Fonctions statistiques

NumPy dispose également d'une variété de fonctions statistiques pour vous aider à analyser les données :

• std : np.std(your_array) – Calcule l'écart type des valeurs du tableau.

• var: np.var(your_array) – Calcule la variance des valeurs du tableau.

• corrcoef : np.corrcoef(your_array) – Calcule le coefficient de corrélation du tableau.

3. Recherche

La recherche dans les tableaux NumPy peut être effectuée à l'aide de différentes méthodes :

• argmin : np.argmin(your_array) – Trouver l'index de l'élément minimum du tableau.

• argmax : np.argmax(your_array) – Trouver l'index de l'élément de tableau maximum.

• où : np.where(condition) – Renvoie les indices des éléments du tableau qui satisfont la condition donnée.

4. Tri

Vous pouvez trier les éléments de votre tableau à l'aide des fonctions suivantes :

• sort : np.sort(your_array) – Trie les éléments du tableau par ordre croissant.

• argsort : np.argsort(your_array) – Renvoie les indices qui trieraient le tableau.

Grâce à ces fonctions et techniques, vous pouvez facilement analyser et manipuler vos tableaux NumPy pour découvrir des informations précieuses et soutenir vos efforts d'analyse de données.

Fonctions avancées

Dans cette section, nous allons explorer certaines fonctions avancées de NumPy pour vous aider à travailler plus efficacement avec vos données. Nous couvrirons les fonctions de diffusion et d'algèbre linéaire.

1. Radiodiffusion

La diffusion est une puissante fonctionnalité NumPy qui vous permet d'effectuer des opérations sur des tableaux de différentes formes et tailles. Cela fonctionne en élargissant automatiquement les dimensions du plus petit tableau pour qu'elles correspondent au plus grand tableau, ce qui facilite l'exécution d'opérations par élément.

Voici un exemple :

import numpy as np
A = np.array([1, 2, 3])
B = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

C = A + B

Dans cet exemple, le tableau 1D A est diffusé pour correspondre à la forme du tableau 2D B, permettant une addition élément par élément.

Gardez ces règles à l'esprit lorsque vous travaillez avec la diffusion :

• Les dimensions des tableaux doivent être compatibles (soit la même taille soit l'un d'entre eux vaut 1).

• La diffusion est appliquée à partir des dimensions de fin et travaille vers les dimensions de tête.

2. Algèbre linéaire

NumPy fournit plusieurs fonctions d'algèbre linéaire qui peuvent être utiles lorsque vous travaillez avec des tableaux multidimensionnels. Certaines de ces fonctions incluent :

• np.dot(A, B) : calcule le produit scalaire de deux tableaux.

• np.linalg.inv(A) : Calcule l'inverse d'une matrice carrée.

• np.linalg.eig(A) : Calcule les valeurs propres et les vecteurs propres d'une matrice carrée.

• np.linalg.solve(A, B) : Résout un système linéaire d'équations, où A est la matrice de coefficients et B est la matrice constante.

Pensez à toujours vérifier si vos matrices sont compatibles avant d'effectuer ces opérations.

Entrée et sortie

Dans cette section, nous verrons comment enregistrer et charger des tableaux, ainsi que comment lire et écrire des fichiers à l'aide de NumPy.

1. Enregistrement et chargement de tableaux

Pour enregistrer un tableau, vous pouvez utiliser la fonction np.save() de NumPy . Cette fonction prend le nom de fichier et le tableau comme ses deux principaux arguments.

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

np.save('my_array.npy', arr)

Pour charger le tableau enregistré, utilisez la fonction np.load() , en fournissant le nom du fichier comme argument.

loaded_array = np.load('my_array.npy')

print(loaded_array)  
# Output: array([1, 2, 3])

Vous pouvez également enregistrer et charger plusieurs tableaux à l'aide des fonctions np.save() et np.load() .

2. Lecture et écriture dans des fichiers texte

NumPy fournit des fonctions pour lire et écrire des fichiers texte avec des tableaux, tels que np.loadtxt() et np.savetxt() . Vous pouvez utiliser ces fonctions pour enregistrer et charger des données à partir de formats de fichiers comme un fichier txt ou CSV.

Pour lire un fichier texte dans un tableau, utilisez la fonction np.loadtxt() . Il prend le nom de fichier comme argument principal et prend également en charge les arguments facultatifs pour spécifier le délimiteur, le dtype, etc.

arr_from_txt = np.loadtxt('data.txt', delimiter=',')
print(arr_from_txt)

Pour lire les données d'un fichier CSV, vous pouvez également utiliser la fonction np.loadtxt() . Cependant, assurez-vous que le délimiteur est toujours défini sur la virgule, " , ".

Pour écrire un tableau dans un fichier texte, utilisez la fonction np.savetxt() . Cette fonction prend le nom de fichier et le tableau comme ses deux arguments principaux, suivis d'arguments facultatifs, tels que le délimiteur et l'en-tête.

arr_to_txt = np.array([[1, 2, 3], [4, 5, 6]])
np.savetxt('output_data.txt', arr_to_txt, delimiter=',')

Ces fonctions d'entrée et de sortie vous permettent de travailler efficacement avec des tableaux et des fichiers texte dans vos tâches de traitement et de manipulation de données à l'aide de NumPy.

Téléchargez votre feuille de triche ci-dessous

Télécharger Numpy Cheat Sheet

Dernières pensées

Eh bien, c'est tout ce que vous devez savoir pour démarrer avec la bibliothèque Numpy Python ! Vous pouvez également utiliser la feuille de triche Python Numpy comme référence pratique lorsque vous travaillez avec la bibliothèque.

Pour des fonctionnalités plus avancées, vous pouvez consulter la documentation NumPy . Vous pouvez également consulter cette amusante feuille de triche Python que nous avons préparée pour les développeurs débutants et expérimentés.

Bonne chance!