Tutoriel Python Numpy

Dans cette leçon sur la bibliothèque Python Numpy, nous examinerons comment cette bibliothèque nous permet de gérer de puissants objets de tableau de dimension N avec des fonctions sophistiquées présents pour manipuler et fonctionner sur ces tableaux. Pour rendre cette leçon complète, nous couvrirons les sections suivantes:

• Quel est le package Python Numpy?
• Tableaux numpy
• Différentes opérations qui peuvent être effectuées sur des tableaux numpy
• Quelques fonctions plus spéciales

Quel est le package Python Numpy?

Autrement dit, Numpy signifie «Python numérique» et c'est ce qu'il vise à réaliser, pour permettre des opérations numériques complexes effectuées sur des objets de tableau N dimensionnel très facilement et de manière intuitive. C'est la bibliothèque de base utilisée dans informatique scientifique, avec des fonctions présents pour effectuer des opérations algébriques linéaires et des opérations statistiques.

L'un des concepts les plus fondamentaux (et attrayants) de Numpy est son utilisation d'objets de tableau N dimensionnel. Nous pouvons prendre ce tableau comme juste un Collection de lignes et de colonne, Tout comme un fichier ms-excel. Il est possible de convertir une liste Python en un tableau Numpy et des fonctions d'exploitation dessus.

Représentation du tableau nu

Juste une note avant de commencer, nous utilisons un environnement virtuel pour cette leçon que nous avons faite avec la commande suivante:

python -m virtualvv numpy
Source Numpy / Bin / Activate

Une fois l'environnement virtuel actif, nous pouvons installer la bibliothèque Numpy dans l'env virtual afin que les exemples que nous créons ensuite puissent être exécutés:

pip installer Numpy

Nous voyons quelque chose comme ça lorsque nous exécutons la commande ci-dessus:

Testons rapidement si le package Numpy a été installé correctement avec l'extrait de code court suivant:

Importer Numpy comme NP
a = np.Array ([1,2,3])
Imprimer (a)

Une fois que vous avez exécuté le programme ci-dessus, vous devriez voir la sortie suivante:

Nous pouvons également avoir des tableaux multidimensionnels avec Numpy:

multi_dimension = np.Array ([(1, 2, 3), (4, 5, 6)])
imprimer (multi_dimension)

Cela produira une sortie comme:

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

Vous pouvez également utiliser Anaconda pour exécuter ces exemples, ce qui est plus facile et c'est ce que nous avons utilisé ci-dessus. Si vous souhaitez l'installer sur votre machine, regardez la leçon qui décrit «comment installer Anaconda Python sur Ubuntu 18.04 LTS »et partagez vos commentaires. Maintenant, passons à divers types d'opérations qui peuvent être effectuées avec des tableaux Python Numpy.

En utilisant des tableaux Numpy sur des listes de python

Il est important de demander que lorsque Python a déjà une structure de données sophistiquée pour contenir plusieurs éléments que pourquoi nous avons besoin de tableaux Numpy? Les tableaux numpy sont Préféré aux listes Python Pour les raisons suivantes:

• Pratique à utiliser pour les opérations en mathématiques et à calculer en raison de la présence de fonctions numpy compatibles
• Ils sont beaucoup plus rapides en raison de la façon dont ils stockent les données en interne
• Moins de mémoire

Laissez-nous prouver que les tableaux numpy occupent moins de mémoire. Cela peut être fait en écrivant un programme Python très simple:

Importer Numpy comme NP
heure d'importation
importer sys
python_list = plage (500)
imprimer (sys.getSizeof (1) * len (python_list))
numpy_arr = np.Arange (500)
Imprimer (Numpy_arr.Taille * Numpy_arr.itemSize)

Lorsque nous exécuterons le programme ci-dessus, nous obtiendrons la sortie suivante:

14000
4000

Cela montre que la même liste est plus de 3 fois en taille par rapport au tableau numpy de même taille.

Effectuer des opérations numpy

Dans cette section, regardons rapidement les opérations qui peuvent être effectuées sur des tableaux Numpy.

Trouver des dimensions dans le tableau

Comme le tableau Numpy peut être utilisé dans n'importe quel espace dimensionnel pour contenir des données, nous pouvons trouver la dimension d'un tableau avec l'extrait de code suivant:

Importer Numpy comme NP
numpy_arr = np.Array ([(1,2,3), (4,5,6)))
Imprimer (Numpy_arr.ndim)

Nous verrons la sortie comme «2» car il s'agit d'un tableau bidimensionnel.

Trouver le type de données des éléments dans le tableau

Nous pouvons utiliser un tableau Numpy pour contenir n'importe quel type de données. Découvrons maintenant le type de données des données qu'un tableau contient:

autre_arr = np.Array ([('' Awe ',' B ',' Cat ')])
imprimer (autre_arr.dtype)
numpy_arr = np.Array ([(1,2,3), (4,5,6)))
Imprimer (Numpy_arr.dtype)

Nous avons utilisé différents types d'éléments dans l'extrait de code ci-dessus. Voici la sortie que ce script montrera:

int64

Cela se produit car les caractères sont interprétés comme des caractères Unicode et le deuxième est évident.

Remodeler les articles d'un tableau

Si un tableau Numpy se compose de 2 lignes et 4 colonnes, il peut être remodelé pour contenir 4 lignes et 2 colonnes. Écrivons un extrait de code simple pour le même:

Original = NP.Array ([('1', 'B', 'C', '4'), ('5', 'F', 'G', '8')]))
Imprimer (original)
Reshaped = original.Reshape (4, 2)
imprimer (remodelé)

Une fois que nous exécuterons l'extrait de code ci-dessus, nous obtiendrons la sortie suivante avec les deux tableaux imprimés à l'écran:

[['1' 'B' 'C' '4']
['5' 'f' 'g' '8']]
[['1' 'b']
['C' '4']
['5' 'f']
['g' '8']]

Notez comment Numpy s'est occupé de déplacer et d'associer les éléments à de nouvelles lignes.

Opérations mathématiques sur les articles d'un tableau

Effectuer des opérations mathématiques sur les articles d'un tableau est très simple. Nous allons commencer par écrire un extrait de code simple pour découvrir maximum, minimum et ajout de tous les éléments du tableau. Voici l'extrait de code:

numpy_arr = np.tableau ([(1, 2, 3, 4, 5)])
Imprimer (Numpy_arr.max ())
Imprimer (Numpy_arr.min ())
Imprimer (Numpy_arr.somme())
Imprimer (Numpy_arr.moyenne())
Imprimer (NP.sqrt (numpy_arr))
Imprimer (NP.std (numpy_arr))

Dans les 2 dernières opérations ci-dessus, nous avons également calculé la racine carrée et l'écart type de chaque élément de tableau. L'extrait ci-dessus fournira la sortie suivante:

5
1
15
3.0
[[1. 1.41421356 1.73205081 2. 2.23606798]]
1.4142135623730951

Convertir des listes de python en tableaux Numpy

Même si vous avez utilisé des listes de python dans vos programmes existants et que vous ne voulez pas modifier tout ce code mais que vous souhaitez toujours utiliser des tableaux Numpy dans votre nouveau code, il est bon de savoir que nous pouvons facilement convertir un Python Liste à un tableau Numpy. Voici un exemple:

# Créer 2 nouvelles listes de taille et de poids
hauteur = [2.37, 2.87, 1.52, 1.51, 1.70, 2.05]
poids = [91.65, 97.52, 68.25, 88.98, 86.18, 88.45]
# Créez 2 tableaux numpy à partir de la hauteur et du poids
np_height = np.tableau (hauteur)
np_weight = np.tableau (poids)

Juste pour vérifier, nous pouvons maintenant imprimer le type de l'une des variables:

print (type (np_height))

Et cela montrera:

Nous pouvons maintenant effectuer des opérations mathématiques sur tous les éléments à la fois. Voyons comment nous pouvons calculer l'IMC du peuple:

# Calculer BMI
BMI = np_weight / np_height ** 2
# Imprimez le résultat
Imprimer (BMI)

Cela montrera l'IMC de toutes les personnes calculées en termes d'élément:

[16.31682957 11.8394056 29.54033934 39.02460418 29.8200692 21.04699584]

N'est-ce pas si simple et pratique? Nous pouvons même filtrer facilement les données avec une condition à la place d'un index à l'intérieur des crochets:

BMI [BMI> 25]

Cela donnera:

Array ([29.54033934, 39.02460418, 29.8200692])

Créer des séquences et répétitions aléatoires avec Numpy

Avec de nombreuses fonctionnalités présentes dans Numpy pour créer des données aléatoires et l'organiser sous une forme requise, les tableaux Numpy sont plusieurs fois utilisés pour générer un ensemble de données de test à de nombreux endroits, notamment le débogage et les tests. Par exemple, si vous souhaitez créer un tableau de 0 à n, nous pouvons utiliser l'Arange (notez le seul 'R') comme l'extrait donné:

Imprimer (NP.Arange (5))

Cela renverra la sortie comme:

[0 1 2 3 4]

La même fonction peut être utilisée pour fournir une valeur inférieure afin que le tableau commence à partir d'autres nombres que 0:

Imprimer (NP.Arange (4, 12))

Cela renverra la sortie comme:

[4 5 6 7 8 9 10 11]

Les chiffres n'ont pas besoin d'être continus, ils peuvent sauter une étape de correction comme:

Imprimer (NP.arange (4, 14, 2))

Cela renverra la sortie comme:

[4 6 8 10 12]

Nous pouvons également obtenir les nombres dans un ordre décroissant avec une valeur de baisse négative:

Imprimer (NP.arange (14, 4, -1))

Cela renverra la sortie comme:

[14 13 12 11 10 9 8 7 6 5]

Il est possible de financer N nombres entre X et Y avec un espace égal avec la méthode Linspace, voici l'extrait de code pour le même:

NP.linspace (start = 10, stop = 70, num = 10, dtype = int)

Cela renverra la sortie comme:

Array ([10, 16, 23, 30, 36, 43, 50, 56, 63, 70])

Veuillez noter que les éléments de sortie ne sont pas également espacés. Numpy fait de son mieux pour le faire, mais vous n'avez pas besoin de compter sur lui car il fait l'arrondissement.

Enfin, regardons comment nous pouvons générer un ensemble de séquences aléatoires avec Numpy qui est l'une des fonctions les plus utilisées à des fins de test. Nous passerons une gamme de nombres à Numpy qui seront utilisés comme point initial et final pour les nombres aléatoires:

Imprimer (NP.aléatoire.randint (0, 10, taille = [2,2]))

L'extrait ci-dessus crée un tableau Numpy de 2 par 2 dimensions qui contiendra des nombres aléatoires entre 0 et 10. Voici l'échantillon de sortie:

[[0 4]
[8 3]]

Veuillez noter que les nombres sont aléatoires, la sortie peut différer même entre les 2 exécutions sur la même machine.

Conclusion

Dans cette leçon, nous avons examiné divers aspects de cette bibliothèque informatique que nous pouvons utiliser avec Python pour calculer Ingénierie des données et calcul de DAT numérique, certainement une compétence que nous devons avoir à notre actif.

Veuillez partager vos commentaires sur la leçon sur Twitter avec @sbmaggarwal et @linuxhint.