NumPy facilite le travail avec les tableaux.
Si vous travaillez avec Python, il est utile de connaître quelques bases de Python NumPy. Il est incroyablement utile pour travailler avec des tableaux car il est très rapide et efficace. Il contient également de nombreuses méthodes pour simplifier la manipulation et l'exécution d'opérations numériques sur des tableaux.
Il existe de nombreuses structures de données en Python, notamment des listes, des dictionnaires, des Pandas DataFrames et bien sûr des tableaux NumPy. Chacun a ses points forts, et savoir quand utiliser l'un ou l'autre peut vous faire gagner du temps et des efforts lors de l'écriture de vos programmes.
Dans cet article, nous allons vous montrer les bases de Python NumPy et vous expliquer pourquoi il est si utile. Nous vous donnerons quelques exemples pour vous mettre sur pied et vous donner les bases pour rendre vos projets d'analyse de données plus efficaces. Si vous souhaitez en savoir plus sur la science des données en Python, envisagez de suivre ce parcours conçu pour les débutants complets sans expérience en informatique.
Pourquoi NumPy ?
Les tableaux dans NumPy présentent de nombreuses similitudes avec d'autres structures de données telles que les listes. Ils peuvent stocker des données numériques ainsi que des chaînes, ils sont mutables et peuvent être découpés et indexés de manière similaire. Une liste, cependant, ne peut pas gérer les opérations numériques aussi facilement qu'un tableau.
Pour multiplier tous les éléments d'un tableau par 2, utilisez array*2 , où tableau est le nom du tableau. C'est ce qu'on appelle la vectorisation. Faire la même chose avec une liste nécessite une boucle for ou une compréhension de liste, qui nécessitent toutes deux plus de code. De plus, les tableaux sont beaucoup plus rapides que les listes et consomment beaucoup moins de mémoire puisque les méthodes NumPy sont hautement optimisées pour travailler avec des tableaux.
Pandas est une autre bonne alternative qui fournit des fonctionnalités pour l'analyse et la visualisation des données. La structure de données de base dans Pandas est le Series , qui est similaire à un tableau NumPy unidimensionnel. Cependant, encore une fois, NumPy est plus rapide et plus efficace lorsqu'il s'agit d'effectuer des calculs numériques. Pour plus d'informations sur l'utilisation de Pandas, consultez cet article. Nous avons également du matériel sur la visualisation des données de séries chronologiques dans Pandas.
Création de tableaux
Les tableaux NumPy ont une taille fixe à la création et les éléments doivent être du même type de données. Ce sont les deux principales contraintes à garder à l'esprit lors de la création de tableaux. Le array() fonction contient les arguments suivants :
numpy.array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, like=None)
Par souci de brièveté, nous ne détaillerons pas tous les arguments. Jetez un œil à la documentation si vous êtes intéressé par les détails. Pour la majorité des applications, il suffit de définir l'objet et éventuellement le dtype arguments.
Pour définir un tableau à une dimension et imprimer sa forme, procédez comme suit :
>>> import numpy as np >>> ar = np.array([1, 2, 3, 4]) >>> print(ar.shape) (4,)
Pour un tableau multidimensionnel NumPy, le object prend la forme d'une séquence imbriquée, où les séquences individuelles définissent les lignes du tableau. Par exemple :
>>> ar = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]) >>> print(ar.shape) (2, 4)
Un tableau NumPy peut également contenir différents types de données, par exemple, des entiers, des flottants, des chaînes et des booléens. Il peut même stocker des nombres complexes. Nous pouvons convertir les éléments de notre tableau ci-dessus en chaînes directement comme suit :
>>> ar_string = ar.astype(str)
>>> ar_string
array([['1', '2', '3', '4'],
['5', '6', '7', '8']], dtype='<U11')
Alternativement, nous pouvons définir dtype=str lors de la définition du tableau. Un tableau de valeurs booléennes peut être créé comme suit :
>>> np.array([[1, 1, 0, 0], [0, 1, 0, 1]], dtype=bool)
array([[True, True, False, False],
[False, True, False, True]])
Cela peut être utile si vous souhaitez masquer certaines valeurs dans un autre tableau.
Il existe plusieurs façons de définir un tableau avec des valeurs arbitraires comme espaces réservés pour remplir les données réelles ultérieurement. Le numpy.ones() et numpy.zeros() les fonctions créent un tableau rempli respectivement de uns et de zéros.
Le numpy.empty() La fonction crée un tableau sans initialiser les entrées. Cette fonction particulière nécessite que l'utilisateur définisse manuellement toutes les valeurs du tableau et doit être utilisée avec prudence. Cependant, cela peut être un peu plus rapide que les deux autres fonctions.
Pour utiliser ces fonctions, la taille du tableau doit être spécifiée :
>>> np.zeros((3, 2))
array([[0., 0.],
[0., 0.],
[0., 0.]])
Les tableaux avec une séquence fixe peuvent être définis avec deux fonctions NumPy utiles :arange et linspace . Pour arange , vous devez spécifier les valeurs de début et de fin et le pas. Par exemple :
>>> np.arange(2, 20, 4) array([ 2, 6, 10, 14, 18])
Ceci est similaire à la fonction intégrée range() , qui peut être utilisé pour la boucle. Consultez cet article pour plus de détails sur les boucles en Python. Le linspace La fonction dans NumPy renvoie des nombres régulièrement espacés sur un intervalle défini par les valeurs de début et de fin. En utilisant les mêmes arguments que le dernier exemple donne :
>>> np.linspace(2, 20, 4) array([ 2., 8., 14., 20.])
Ici, le troisième argument définit le nombre de valeurs à renvoyer plutôt que la taille du pas comme dans l'exemple précédent. Pour voir un exemple d'utilisation de cette fonction pour générer des valeurs régulièrement espacées pour un axe de temps, consultez cet article. Une fonction similaire, logspace , renvoie des nombres régulièrement espacés sur une échelle logarithmique. Essayez-le pour voir ce que vous obtenez.
Lire et écrire des CSV
La plupart du temps, vous souhaitez lire des données enregistrées dans un fichier dans un tableau NumPy. NumPy est livré avec quelques fonctions pour aider à charger et à enregistrer des tableaux. Ceux-ci sont axés sur la gestion des données binaires ou des données stockées dans des fichiers texte. Les deux fonctions load() et save() fournissent des fonctionnalités pour charger et enregistrer des tableaux dans un fichier binaire.
Si vous travaillez avec des fichiers texte, en particulier CSV en Python, la meilleure façon de lire et d'écrire des tableaux dans un fichier consiste à utiliser les fonctions loadtxt() et savetxt(). Ce dernier a deux arguments obligatoires, fname et X , qui définissent respectivement le nom du fichier et les données du tableau à enregistrer. Pour enregistrer au format CSV, vous devez également spécifier un delimiter . Pour illustrer cela, créons un tableau 2 x 4, enregistrons-le au format CSV, puis relisons-le :
>>> ar = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
>>> np.savetxt('output_array.csv', ar, delimiter=',')
>>> ar_read = np.loadtxt('output_array.csv', delimiter=',')
>>> ar_read
array([[1., 2., 3., 4.],
[5., 6., 7., 8.]])
Vous pouvez également utiliser Python pur et le open() intégré fonction. Voici un article sur l'écriture dans un fichier en Python qui vous montre comment. Si vous gérez un grand nombre de fichiers en Python, voici un article avec quelques conseils sur la façon de renommer les fichiers par programmation.
Certaines méthodes de tableau NumPy
Maintenant que nous avons couvert les façons de créer un tableau en Python, regardons ce que vous pouvez en faire. NumPy dispose de nombreuses méthodes utiles et hautement optimisées qui vous permettent d'effectuer des opérations sur les tableaux et d'obtenir des informations supplémentaires sur votre tableau.
Comme nous l'avons mentionné dans l'introduction, effectuer des opérations de base sur des tableaux tels que array1 + array2 ou multiplier par un scalaire est simple. Il existe des fonctions efficaces pour l'algèbre linéaire, par exemple pour calculer le produit scalaire ou croisé ou pour prendre la transposition d'un tableau.
Une exigence courante est de résumer le contenu d'un tableau. NumPy inclut des fonctions pour calculer des statistiques telles que la moyenne, la médiane, l'écart type, etc. Celles-ci sont utiles car elles vous permettent de spécifier un axe sur lequel calculer la statistique. Par défaut, la statistique est calculée sur le tableau aplati. Par exemple :
>>> ar = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]) >>> np.mean(ar) 4.5 >>> np.mean(ar, axis=0) array([3., 4., 5., 6.]) >>> np.mean(ar, axis=1) array([2.5, 6.5])
Spécifier axis=0 calcule la moyenne sur les colonnes, et axis=1 calcule la moyenne sur les lignes. Maintenant que nous savons comment générer une statistique récapitulative, nous pouvons trouver la moyenne des lignes et ajouter ces informations à une nouvelle colonne du tableau :
>>> row_mean = np.mean(ar, axis=1).reshape(2, 1)
>>> new_ar = np.append(ar, row_mean, axis=1)
>>> new_ar
array([[1., 2., 3., 4., 2.5],
[5., 6., 7., 8., 6.5]])
Ici, nous calculons notre statistique, la remodelons, puis utilisons la fonction d'ajout pour l'ajouter en tant que nouvelle colonne. Notez que le type de données de l'ensemble du tableau a changé puisque nos statistiques récapitulatives sont des nombres à virgule flottante.
Allez-y et NumPy
NumPy est un outil fondamental dans l'analyse de données Python. C'est une bibliothèque mature avec un grand nombre de fonctions et de méthodes utiles ainsi que la vitesse et l'efficacité à la base. Maintenant que vous connaissez les bases de Python NumPy, vous pouvez utiliser ce que vous avez appris ici pour rendre vos projets plus efficaces.
La visualisation de vos données est une étape importante dans le processus de science des données. Nous avons deux articles (Partie 1 et Partie 2) qui vous donnent une introduction au traçage avec Matplotlib en Python.
