Ce tutoriel vous montrera comment utiliser la fonction NumPy max, que vous verrez dans le code Python comme np.max.

A un haut niveau, je veux expliquer la fonction et vous montrer comment elle fonctionne. Cela étant, il y a deux sections principales dans ce tutoriel : la syntaxe de NumPy max, et des exemples de la façon d’utiliser NumPy max.

Si vous commencez toujours à utiliser NumPy, je vous recommande de lire tout le tutoriel, du début à la fin. Cela dit, si vous voulez juste obtenir une réponse rapide à une question, vous pouvez passer directement à la section appropriée avec l’un des liens suivants :

• La syntaxe de NumPy max
• Exemples d’utilisation de NumPy max

Ok. Avec tout cela en tête, commençons.

D’abord, parlons de NumPy et de la fonction NumPy max.

Une introduction rapide à la fonction NumPy max

Il est probablement clair pour vous que la fonction NumPy max est une fonction du module NumPy.

Mais si vous êtes un vrai débutant, vous ne savez peut-être pas vraiment ce qu’est NumPy. Donc, avant de parler spécifiquement de la fonction np.max, parlons rapidement de NumPy.

Qu’est-ce que NumPy exactement ?

Numpy est un module de manipulation de données pour Python

Pour le dire très simplement, NumPy est un paquet de manipulation de données pour le langage de programmation Python.

Si vous vous intéressez à la science des données en Python, NumPy est très important. En effet, une grande partie du travail de science des données consiste simplement à manipuler des données. Que vous fassiez de l’apprentissage profond ou de l’analyse de données, une énorme quantité de travail en science des données consiste simplement à nettoyer les données, à les préparer et à les explorer pour s’assurer qu’elles peuvent être utilisées.

Encore, en raison de l’importance de la manipulation des données, NumPy est très important pour la science des données en Python.

Numpy est une boîte à outils pour travailler avec des données numériques

Spécifiquement cependant, NumPy fournit un ensemble d’outils pour travailler avec des données numériques.

Python a d’autres boîtes à outils pour travailler avec des données non numériques et des données de type mixte (comme le module Pandas). Mais si vous avez une sorte de données numériques que vous devez nettoyer, modifier, remodeler ou analyser, NumPy est probablement la boîte à outils dont vous avez besoin.

Bien que les fonctions NumPy puissent opérer sur une variété de structures de données, elles sont construites pour opérer sur une structure appelée tableau NumPy. Les tableaux NumPy sont juste un type spécial d’objet Python qui contient des données numériques. Il existe une variété de façons de créer des tableaux numpy, y compris la fonction np.array, la fonction np.ones, la fonction np.zeros et la fonction np.arange, ainsi que de nombreuses autres fonctions couvertes dans des tutoriels antérieurs ici à Sharp Sight.

Important, les tableaux NumPy sont optimisés pour les calculs numériques. Il y a donc un ensemble d’outils dans NumPy pour effectuer des calculs numériques sur les tableaux NumPy, comme calculer la moyenne d’un tableau NumPy, calculer la médiane d’un tableau NumPy, et ainsi de suite.

Essentiellement, NumPy vous donne une boîte à outils pour créer des tableaux de données numériques, et effectuer des calculs sur ces données numériques.

L’un des calculs que vous pouvez effectuer est de calculer la valeur maximale d’un tableau NumPy. C’est là qu’intervient la fonction np.max.

NumPy max calcule le maxium des valeurs d’un tableau NumPy

La fonction numpy.max() calcule la valeur maximale des valeurs numériques contenues dans un tableau NumPy. Elle peut également calculer la valeur maximale des lignes, des colonnes ou d’autres axes. Nous en parlerons dans la section des exemples.

Syntaxiquement, vous verrez souvent la fonction NumPy max dans le code sous le nom de np.max. Vous la verrez écrite comme cela lorsque le programmeur a importé le module NumPy avec l’alias np.

En outre, juste pour clarifier, vous devez savoir que la fonction np.max est la même chose que la fonction NumPy amax, AKA np.amax. Essentiellement, np.max est un alias de np.amax. Mis à part le nom, ils sont les mêmes.

Un exemple de haut niveau du fonctionnement de np.max

Plus tard dans ce tutoriel, je vous montrerai des exemples concrets d’utilisation de la fonction np.max, mais ici même, je veux vous donner une idée générale de ce qu’elle fait.

Par exemple, supposons que vous ayez un tableau NumPy à 1 dimension avec cinq valeurs:

Nous pouvons utiliser la fonction NumPy max pour calculer la valeur maximale:

Bien que cet exemple vous montre comment la fonction np.max() fonctionne sur un tableau NumPy à 1 dimension, elle fonctionne de manière similaire sur des tableaux à 2 dimensions et des tableaux multidimensionnels. Encore une fois, je vous montrerai des exemples complets dans la section des exemples de ce tutoriel.

Avant de regarder les exemples de code cependant, jetons un coup d’œil rapide à la syntaxe et aux paramètres de np.max.

La syntaxe de numpy max

La syntaxe de la fonction np.max est assez simple, bien que quelques paramètres de la fonction puissent être un peu confus.

Ici, nous allons parler de la structure syntaxique de la fonction, et j’expliquerai également les paramètres importants.

Une note rapide

Une note rapide avant de commencer à examiner la syntaxe.

Syntaxiquement, le nom propre de la fonction est numpy.max().

Ayant dit cela, vous verrez souvent la fonction dans le code comme np.max().

Pourquoi ?

Communément, au début d’un programme qui utilise le module NumPy, les programmeurs importeront la fonction NumPy sous la forme np. Vous verrez littéralement une ligne de code dans le programme qui se lit import numpy as np. Effectivement, cela importe le module NumPy avec l’alias np. Cela permet au programmeur de se référer à NumPy en tant que np dans le code, ce qui lui permet de se référer à la fonction numpy.max en tant que np.max.

Ayant dit cela, regardons de plus près la syntaxe.

Une explication de la syntaxe

À un haut niveau, la syntaxe de np.max est assez simple.

Il y a le nom de la fonction – np.max() – et à l’intérieur de la fonction, il y a plusieurs paramètres qui nous permettent de contrôler le comportement exact de la fonction.

Regardons de plus près les paramètres de np.max, car les paramètres sont ce qui vous donne vraiment un contrôle fin de la fonction.

Les paramètres de np.max

La fonction numpy.max possède quatre paramètres primaires :

• a
• axis
• out
• keepdims

Parlons de chacun de ces paramètres individuellement.

a (obligatoire)

Le paramètre a vous permet de spécifier les données sur lesquelles la fonction np.max va opérer. Essentiellement, il spécifie le tableau d’entrée de la fonction.

Dans de nombreux cas, ce tableau d’entrée sera un tableau NumPy approprié. Cela dit, numpy.max (et la plupart des autres fonctions NumPy) fonctionnera sur n’importe quelle « séquence de type tableau » de données. Cela signifie que l’argument du paramètre a peut être une liste Python, un tuple Python, ou une de plusieurs autres séquences Python.

N’oubliez pas que vous devez fournir quelque chose à cet argument. Il est obligatoire.

axe (facultatif)

Le paramètre axisvous permet de spécifier l’axe sur lequel vous calculerez les valeurs maximales.

Dit plus simplement, le paramètre axe vous permet de calculer les maxima de ligne et les maxima de colonne.

J’expliquerai comment faire cela avec plus de détails dans la section des exemples ci-dessous, mais laissez-moi expliquer rapidement comment le paramètre axis fonctionne.

Un examen rapide des axes de tableau

À un niveau élevé, vous devez comprendre que les tableaux NumPy ont des axes.

Les axes sont comme des directions le long du tableau NumPy. Dans un tableau à 2 dimensions, l’axe 0 est l’axe qui pointe vers le bas des lignes et l’axe 1 est l’axe qui pointe horizontalement à travers les colonnes.

Le paramètre tableau spécifie l’axe pour calculer les maxima

Alors, comment cela se rapporte-t-il au paramètre axis ?

Lorsque nous utilisons le paramètre axis dans la fonction numpy.max, nous spécifions l’axe le long duquel trouver les maxima.

Cela nous permet effectivement de calculer les maxima de colonne et les maxima de ligne.

Laissez-moi vous montrer ce que je veux dire.

Rappelez-vous que l’axe 0 est l’axe qui pointe vers le bas, vers les rangées.

Lorsque nous utilisons le code np.max(axis = 0) sur un tableau, nous disons effectivement à NumPy de calculer les valeurs maximales dans cette direction… la direction de l’axe 0.

Effectivement, lorsque nous définissons axis = 0, nous spécifions que nous voulons calculer les maxima de la colonne.

De même, rappelez-vous que dans un tableau à 2 dimensions, l’axe 1 pointe horizontalement. Par conséquent, lorsque nous utilisons NumPy max avec axis = 1, nous disons à NumPy de calculer les maxima horizontalement, dans la direction de l’axe 1.

Ceci calcule effectivement les maxima de ligne.

Je vous montrerai des exemples concrets de code pour faire cela, plus tard dans la section des exemples.

N’oubliez pas que le paramètre axis est facultatif. Si vous ne spécifiez pas d’axe, NumPy max trouvera la valeur maximale dans l’ensemble du tableau NumPy.

out (facultatif)

Le paramètre out vous permet de spécifier un tableau de sortie spécial où vous pouvez stocker la sortie de np.max.

Il n’est pas courant d’utiliser ce paramètre (surtout si vous êtes un débutant), donc nous n’allons pas en parler dans le tutoriel.

out est un paramètre facultatif.

keepdims (optional)

Le paramètre keepdims est un peu confus, il faudra donc faire un petit effort pour le comprendre.

En fin de compte, le paramètre keepdims garde les dimensions de la sortie identiques à celles de l’entrée.

Pour comprendre pourquoi cela peut être nécessaire, regardons comment la fonction numpy.max fonctionne typiquement.

Lorsque vous utilisez np.max sur un tableau NumPy typique, la fonction réduit le nombre de dimensions. Elle résume les données.

Par exemple, disons que vous avez un tableau NumPy à 1 dimension. Vous utilisez NumPy max sur le tableau.

Lorsque vous utilisez np.max sur un tableau à 1 dimension, la sortie sera un seul nombre. Une valeur scalaire … pas un tableau 1-d.

Essentiellement, les fonctions comme NumPy max (ainsi que numpy.median, numpy.mean, etc) résument les données, et en résumant les données, ces fonctions produisent des sorties qui ont un nombre réduit de dimensions.

Parfois cependant, vous voulez que la sortie ait le même nombre de dimensions. Il y a des moments où si l’entrée est un tableau à 1-d, vous voulez que la sortie soit un tableau à 1-d (même si le tableau de sortie a une seule valeur).

Vous pouvez faire cela le paramètre keepdims.

Par défaut, keepdims est défini à False. Donc, par défaut (comme discuté ci-dessus), les dimensions de la sortie ne seront pas les mêmes que les dimensions de l’entrée. Par défaut, les dimensions de la sortie seront plus petites (parce que np.max résume les données).

Mais si vous définissez keepdims = True, la sortie aura les mêmes dimensions que l’entrée.

C’est un peu abstrait sans exemple concret, donc je vous montrerai un exemple de ce comportement plus tard dans la section des exemples.

Et en fait, maintenant que nous avons passé en revue les paramètres, c’est un bon endroit pour commencer à regarder les exemples de NumPy max.

Exemples : comment utiliser la fonction numpy max

Dans cette section, je vais vous montrer des exemples concrets de l’utilisation de la fonction NumPy max.

Je vais vous montrer plusieurs variantes de la façon de trouver la valeur maximale d’un tableau. Je vous montrerai comment trouver la valeur maximale d’un tableau à 1-d, comment trouver la valeur maximale d’un tableau à 2-d, et comment travailler avec plusieurs des paramètres importants de numpy.max.

Exécutez d’abord ce code

Avant de commencer, il y a quelques choses préliminaires que vous devez faire pour vous installer correctement.

Premièrement, vous devez avoir NumPy installé correctement sur votre ordinateur.

Import numpy

Deuxièmement, vous devez avoir NumPy importé dans votre environnement de travail.

Vous pouvez importer NumPy avec le code suivant:

import numpy as np

Notez que nous avons importé NumPy en tant que np. Cela signifie que nous ferons référence à NumPy dans notre code avec l’alias np.

Ok, maintenant que c’est terminé, regardons quelques exemples.

Calculer le max d’un tableau à 1 dimension

Nous allons commencer simplement.

Ici, nous allons calculer la valeur maximale d’un tableau NumPy à 1 dimension.

Pour ce faire, nous allons d’abord simplement créer un tableau à 1 dimension qui contient quelques entiers aléatoires. Pour créer ce tableau, nous allons utiliser la fonction numpy.random.randint(). Gardez à l’esprit que vous devez utiliser la fonction np.random.seed() pour que votre tableau NumPy contienne les mêmes entiers que ceux de cet exemple.

np.random.seed(22)np_array_1d = np.random.randint(size = 5, low = 0, high = 99)

Cette syntaxe créera un tableau à 1 dimension appelé np_array_1d.

Nous pouvons imprimer np_array_1d en utilisant la fonction print().

print(np_array_1d)

Et voici la sortie:

Visuellement, nous pouvons identifier la valeur maximale, qui est 84.

Mais faisons cela avec du code.

Ici, nous allons calculer la valeur maximale de notre tableau NumPy en utilisant la fonction np.max().

np.max(np_array_1d)

Ce qui produit la sortie suivante:

84

C’est un exemple extrêmement simple, mais il illustre la technique. Évidemment, lorsque le tableau ne compte que 5 éléments, vous pouvez inspecter visuellement le tableau et trouver la valeur maximale. Mais cette technique fonctionnera si vous avez un tableau avec des milliers de valeurs (ou plus !).

Calculer le maximum d’un tableau à 2 dimensions

Puis, calculons le maximum d’un tableau à 2 dimensions.

Pour ce faire, nous avons évidemment besoin d’un tableau à 2 dimensions pour travailler, nous allons donc d’abord créer un tableau NumPy à 2 dimensions.

Pour créer notre tableau à 2 dimensions, nous allons utiliser la fonction np.random.choice(). Essentiellement, cette fonction va tirer un échantillon aléatoire parmi les entiers entre 0 et 8, sans remplacement. Après l’exécution de la fonction np.random.choice(), nous allons utiliser la méthode reshape() pour remodeler les entiers en un tableau à 2 dimensions avec 3 lignes et 3 colonnes.

np.random.seed(1)np_array_2d = np.random.choice(9, 9, replace = False).reshape((3,3))

Regardons en imprimant le tableau, np_array_2d.

print(np_array_2d)

 ]

Comme vous pouvez le voir, c’est un tableau à 2 dimensions avec 3 lignes et 3 colonnes. Il contient les entiers de 0 à 8, disposés aléatoirement dans le tableau.

Maintenant, calculons la valeur maximale du tableau:

np.max(np_array_2d)

Ce qui produit la sortie suivante:

8

De nouveau, c’est un exemple très simple, mais vous pouvez utiliser ceci avec un tableau à 2 dimensions beaucoup plus grand et cela fonctionnera de la même manière. Une fois que vous aurez appris à utiliser cette technique, essayez-la avec des tableaux plus grands !

Après, faisons quelque chose de plus compliqué.

… dans les prochains exemples, nous allons calculer les maxima des colonnes et les maxima des lignes.

Calculer la valeur maximale des colonnes d’un tableau à 2 dimensions

Première étape : nous allons calculer les valeurs maximales des colonnes d’un tableau.

Pour ce faire, nous devons utiliser le paramètre axis. Plus précisément, nous devons définir axis = 0 à l’intérieur de la fonction numpy.max.

Regardons rapidement pourquoi.

Le paramètre axis spécifie quel axe vous voulez résumer

Rappellez-vous que les tableaux NumPy ont des axes, et que les axes sont comme des directions le long du tableau. Dans un tableau à 2 dimensions, l’axe 0 est celui qui pointe vers le bas, et l’axe 1 est celui qui pointe horizontalement.

Nous pouvons utiliser ces axes pour définir la direction le long de laquelle utiliser np.max.

Disons donc que nous voulons calculer les valeurs maximales des colonnes. Cela revient à calculer les moyennes vers le bas.

Essentiellement, pour calculer les maxima des colonnes, nous devons calculer les maxima dans la direction de l’axe-0.

Calculer max avec axe = 0

Laissez-moi vous montrer comment.

Ici, nous allons recréer notre tableau NumPy à 2 dimensions. C’est le même tableau NumPy 2-d que nous avons créé dans un exemple précédent, donc si vous avez déjà exécuté ce code, vous n’avez pas besoin de l’exécuter à nouveau.

np.random.seed(1)np_array_2d = np.random.choice(9, 9, replace = False).reshape((3,3))

Et nous pouvons l’imprimer :

print(np_array_2d)

 ]

Une fois de plus, c’est un tableau 2-d avec 3 lignes et 3 colonnes. Il contient les entiers de 0 à 8, disposés aléatoirement dans le tableau.

Maintenant, calculons les maxima des colonnes en utilisant numpy.max avec axis = 0.

# CALCULATE COLUMN MAXIMAnp.max(np_array_2d, axis = 0)

Ce qui produit le tableau de sortie suivant :

array()

Evaluons ce qui s’est passé ici.

En définissant axis = 0, nous avons spécifié que nous voulons que la fonction NumPy max calcule les valeurs maximales vers le bas le long de l’axe 0.

C’est assez simple tant que vous comprenez les axes NumPy et comment ils fonctionnent dans les fonctions NumPy.

Calculer le max de la ligne avec axis = 1

De même, nous pouvons calculer les maxima de la ligne en réglant le paramètre axis sur axis = 1.

Voici le code pour créer à nouveau l’ensemble de données 2-d :

np.random.seed(1)np_array_2d = np.random.choice(9, 9, replace = False).reshape((3,3))

print(np_array_2d)

 ]

Et maintenant calculons les maxima de rangée :

np.max(np_array_2d, axis = 1)

Avec la sortie suivante :

array()

Cela devrait avoir du sens si vous avez déjà lu et compris les exemples précédents.

Lorsque nous définissons axis = 1, nous indiquons à numpy.max de calculer les valeurs maximales dans la direction de l’axe 1. Puisque l’axe 1 est l’axe qui s’étend horizontalement le long du tableau, cela calcule effectivement les valeurs maximales le long des rangées d’un tableau à 2 dimensions :

A nouveau, c’est assez simple, tant que vous comprenez vraiment les axes des tableaux NumPy. Si vous avez encore du mal à comprendre les axes, je vous recommande de revoir notre tutoriel sur les axes de tableaux NumPy.

Comment utiliser le paramètre keepdims avec np.max

Enfin, jetons un coup d’œil au paramètre keepdims.

Avant de le faire, laissez-moi vous expliquer pourquoi nous en avons besoin.

Comme je l’ai noté précédemment, la fonction NumPy max résume les données lorsque vous l’utilisez. En fait, de nombreuses fonctions NumPy qui calculent des statistiques sommaires (comme np.mean, np.median, np.min, etc) résument les données par leur nature même. Lorsque vous calculez une statistique sommaire, vous résumez par définition les données.

Cela a des conséquences importantes liées aux dimensions des données.

Lorsque vous résumez vos données avec une fonction comme numpy.max, la sortie de la fonction aura un nombre réduit de dimensions.

Par exemple, disons que vous calculez la valeur maximale d’un tableau à 2 dimensions. Si vous utilisez numpy.max sur ce tableau à 2 dimensions (sans le paramètre axis), alors la sortie sera un seul nombre, un scalaire. Les scalaires ont des dimensions nulles. Deux dimensions en entrée, zéro dimension en sortie.

La fonction NumPy max réduit effectivement les dimensions entre l’entrée et la sortie.

Parfois cependant, vous ne voulez pas un nombre réduit de dimensions. Il peut y avoir des situations où vous avez besoin que la sortie ait techniquement les mêmes dimensions que l’entrée (même si la sortie est un seul nombre).

Vous pouvez forcer ce comportement en utilisant le paramètre keepdims.

Définir keepdims égal à true (et garder les mêmes dimensions)

Par défaut, le paramètre keepdims est défini à False. Comme je viens de l’expliquer, cela signifie que la sortie n’a pas besoin d’avoir les mêmes dimensions que l’entrée, par défaut.

Mais si vous définissez keepdims = True, cela forcera la sortie à avoir le même nombre de dimensions que l’entrée.

Cela peut vous dérouter, alors regardons un exemple solide.

D’abord, créons simplement un tableau à 2 dimensions.

C’est le même tableau que nous avons créé précédemment, donc si vous avez déjà exécuté ce code, vous n’avez pas besoin de le ré-exécuter. Essentiellement, ce code crée un tableau 2-d avec les chiffres de 0 à 8, disposés aléatoirement dans un tableau 3 par 3.

np.random.seed(1)np_array_2d = np.random.choice(9, 9, replace = False).reshape((3,3))

Par souci de clarté, jetons un coup d’oeil en l’imprimant:

print(np_array_2d)

Et voici le tableau:

 ]

Encore, ce tableau contient juste les nombres entiers de 0 à 8, disposés aléatoirement dans un tableau NumPy 3 par 3.

Et combien de dimensions a-t-il ?

C’est probablement évident pour vous, mais nous pouvons directement récupérer le nombre de dimensions en extrayant l’attribut ndim du tableau.

np_array_2d.ndim

Et cela nous indique le nombre de dimensions :

2

Donc, np_array_2d est un tableau à 2 dimensions.

Maintenant, utilisons np.max pour calculer la valeur maximale du tableau.

np.max(np_array_2d)

La valeur maximale est 8.

Et combien de dimensions a la sortie ? Nous pouvons vérifier en référençant l’attribut ndim à la fin de la fonction np.max():

np.max(np_array_2d).ndim

Combien de dimensions a la sortie?

0.

La sortie de np.max est la valeur maximale (8), qui est un scalaire. Ce scalaire a zéro dimension.

Ré-exécutons np.max avec keepdims = True

Maintenant, ré-exécutons le code avec keepdims = True.

np.max(np_array_2d, keepdims = True)

Ce qui produit la sortie suivante:

array(])

Et vérifions les dimensions:

np.max(np_array_2d, keepdims = True).ndim

2

Ici, lorsque nous exécutons np.max sur np_array_2d avec keepdims = True, la sortie a 2 dimensions.

N’oubliez pas que la valeur maximale est la même : 8. C’est juste que les dimensions de la sortie sont différentes. En définissant keepdims = True, nous changeons la structure de la sortie … au lieu d’être un scalaire, la sortie est en fait un tableau NumPy à 2 dimensions avec une seule valeur (8).

Si vous voulez apprendre la science des données en Python, apprenez NumPy

Si vous avez lu d’autres tutoriels ici sur le blog de science des données Sharp Sight, vous savez à quel point la manipulation des données est importante.

Si vous voulez sérieusement apprendre la science des données, vous devez vraiment maîtriser les bases de la manipulation des données. Une énorme partie du flux de travail de la science des données consiste simplement à nettoyer et à manipuler les données d’entrée.

Si vous travaillez en Python, l’une des compétences essentielles que vous devez alors connaître est NumPy. Numpy est essentiel pour nettoyer, manipuler et explorer vos données.

Si vous voulez apprendre la science des données en Python, apprenez NumPy et apprenez-le bien.

Pour plus de tutoriels de science des données en Python, inscrivez-vous à notre liste de diffusion

Ayant dit cela, si vous voulez apprendre NumPy et la science des données en Python, alors inscrivez-vous à notre liste de diffusion.

Ici, au blog Sharp Sight, nous publions régulièrement des tutoriels de science des données.

En vous inscrivant, vous recevrez des tutoriels gratuits sur :

• NumPy
• Pandas
• Base Python
• Scikit learn
• Apprentissage machine
• Deep learning
• … et plus encore.

Lorsque nous publierons des tutoriels, nous les enverrons directement dans votre boîte de réception.

Vous voulez apprendre la science des données en Python ? Inscrivez-vous dès maintenant.

.