Comment utiliser np.arange () – Real Python

NumPy est la bibliothèque Python fondamentale pour l'informatique numérique. Son type le plus important est un type de tableau appelé Ndarray. NumPy offre de nombreuses routines de création de tableaux pour différentes circonstances. arange () est l'une de ces fonctions basée sur plages numériques. On parle souvent de np.arange () parce que np est une abréviation largement utilisée pour NumPy.

La création de tableaux NumPy est importante lorsque vous travaillez avec d'autres bibliothèques Python qui en dépendent, telles que SciPy, Pandas, Matplotlib, scikit-learn, etc. NumPy convient à la création et à l'utilisation de tableaux, car il offre des routines utiles, permet d'améliorer les performances et vous permet d'écrire un code concis.

À la fin de cet article, vous saurez:

• Quoi np.arange () est
• Comment utiliser np.arange ()
• Comment np.arange () se compare à la classe intégrée Python intervalle
• Quelles routines sont similaires à np.arange ()

Voyons voir np.arange () en action!

Valeur de retour et paramètres de np.arange ()

NumPy arange () est l’une des routines de création de tableaux basée sur des plages numériques. Il crée une instance de Ndarray avec valeurs uniformément espacées et retourne la référence.

Vous pouvez définir l'intervalle des valeurs contenues dans un tableau, leur espace et leur type avec quatre paramètres de arange ():

numpy.s'organiser([[[[début, ]Arrêtez, [[[[étape, ], type=Aucun) -> numpy.Ndarray

Les trois premiers paramètres déterminent la plage des valeurs, tandis que le quatrième spécifie le type des éléments:

1. début est le nombre (entier ou décimal) qui définit la première valeur du tableau.
2. Arrêtez est le nombre qui définit la fin du tableau et n’est pas inclus dans le tableau.
3. étape est le nombre qui définit l'espacement (différence) entre chaque deux valeurs consécutives dans le tableau et par défaut à 1.
4. type est le type des éléments du tableau de sortie et par défaut, Aucun.

étape ne peut pas être zéro. Sinon, vous aurez un ZeroDivisionError. Vous ne pouvez pas partir ailleurs début si l'incrément ou le décrément est 0.

Si type est omis, arange () va essayer de déduire le type des éléments du tableau des types de début, Arrêtez, et étape.

Vous pouvez trouver plus d’informations sur les paramètres et la valeur de retour de arange () dans la documentation officielle.

Arguments de la gamme de np.arange ()

Les arguments de NumPy arange () qui définissent les valeurs contenues dans le tableau correspondent aux paramètres numériques début, Arrêtez, et étape. Tu dois passer au moins un d'eux.

Les exemples suivants vont vous montrer comment arange () se comporte en fonction du nombre d'arguments et de leurs valeurs.

Fournir tous les arguments de gamme

Lorsque vous travaillez avec des routines NumPy, vous devez d'abord importer NumPy:

>>> importation numpy comme np

Maintenant, vous avez importé NumPy et vous êtes prêt à appliquer arange ().

Voyons un premier exemple d’utilisation de NumPy arange ():

>>> np.s'organiser(début=1, Arrêtez=dix, étape=3)
tableau ([1, 4, 7])

Dans cet exemple, début est 1. Par conséquent, le premier élément du tableau obtenu est 1. étape est 3, c’est pourquoi votre deuxième valeur est 1 + 3, c’est-à-dire 4, tandis que la troisième valeur du tableau est 4 + 3, ce qui équivaut à 7.

Suivant ce modèle, la valeur suivante serait dix (7 + 3), mais le comptage doit être terminé avant Arrêtez est atteint, donc celui-ci n'est pas inclus.

Tu peux passer début, Arrêtez, et étape comme arguments de position également:

>>> np.s'organiser(1, dix, 3)
tableau ([1, 4, 7])

Cet exemple de code est équivalent à, mais plus concis que le précédent.

La valeur de Arrêtez n'est pas inclus dans un tableau. C’est pourquoi vous pouvez obtenir des résultats identiques avec différents Arrêtez valeurs:

>>> np.s'organiser(1, 8, 3)
tableau ([1, 4, 7])

Cet exemple de code renvoie le tableau avec les mêmes valeurs que les deux précédents. Vous pouvez obtenir le même résultat avec n'importe quelle valeur de Arrêtez strictement supérieur à 7 et inférieur ou égal à dix.

Cependant, si vous faites Arrêtez plus grand que dix, puis compter va se terminer après dix est atteint:

>>> np.s'organiser(1, 10.1, 3)
tableau ([ 1.,  4.,  7., 10.])

Dans ce cas, vous obtenez le tableau avec quatre éléments qui inclut dix.

Notez que cet exemple crée un tableau de nombres à virgule flottante, contrairement au précédent. C’est parce que vous n’avez pas défini type, et arange () en a déduit pour vous. Vous en apprendrez plus à ce sujet plus tard dans l’article.

Vous pouvez voir les représentations graphiques de ces trois exemples dans la figure ci-dessous:

début est indiqué en vert, Arrêtez en rouge, tandis que étape et les valeurs contenues dans les tableaux sont en bleu.

Comme vous pouvez le voir sur la figure ci-dessus, les deux premiers exemples ont trois valeurs (1, 4, et 7) compté. Ils ne permettent pas dix pour être inclus. Dans le troisième exemple, Arrêtez est plus grand que dix, et il est contenu dans le tableau résultant.

Fournir deux arguments de gamme

Vous pouvez omettre étape. Dans ce cas, arange () utilise sa valeur par défaut de 1. Les deux déclarations suivantes sont équivalentes:

>>> np.s'organiser(début=1, Arrêtez=dix, étape=1)
tableau ([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.s'organiser(début=1, Arrêtez=dix)
tableau ([1, 2, 3, 4, 5, 6, 7, 8, 9])

La deuxième déclaration est plus courte. étape, qui par défaut est 1, est ce que l’on attend habituellement de manière intuitive.

En utilisant arange () avec l'incrément 1 est un cas très courant dans la pratique. Encore une fois, vous pouvez écrire l'exemple précédent de manière plus concise avec les arguments de position début et Arrêtez:

>>> np.s'organiser(1, dix)
tableau ([1, 2, 3, 4, 5, 6, 7, 8, 9])

C’est un moyen intuitif et concis d’invoquer arange (). L’utilisation des arguments de mots-clés dans cet exemple n’améliore pas vraiment la lisibilité.

Fournir un argument de plage

Vous devez fournir au moins un argument à arange (). Pour être plus précis, vous devez fournir début.

Mais qu'advient-il si vous omettez Arrêtez? Comment arange () sait quand arrêter de compter? Dans ce cas, le tableau commence à 0 et se termine avant la valeur de début est atteint! Encore une fois, la valeur par défaut de étape est 1.

En d'autres termes, arange () suppose que vous avez fourni Arrêtez (au lieu de début) et cela début est 0 et étape est 1.

Voyons un exemple où vous voulez commencer un tableau avec 0, augmentant les valeurs de 1et arrêter avant dix:

>>> np.s'organiser(début=0, Arrêtez=dix, étape=1)
tableau ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.s'organiser(0, dix, 1)
tableau ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.s'organiser(début=0, Arrêtez=dix)
tableau ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.s'organiser(0, dix)
tableau ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Ces exemples de code sont corrects. Ils fonctionnent comme indiqué dans les exemples précédents. Il existe un moyen encore plus court et plus propre, mais toujours intuitif, de faire la même chose. Vous pouvez simplement fournir un argument de position unique:

>>> np.s'organiser(dix)  # Stop est 10, start est 0 et étape est 1!
tableau ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

C'est le moyen le plus courant de créer un tableau NumPy qui commence à zéro et a un incrément de un.

Si vous essayez de fournir explicitement Arrêtez sans pour autant débutalors vous aurez un Erreur-type:

>>> np.s'organiser(Arrêtez=dix)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
Erreur-type: arange () manque l'argument requis 'start' (pos 1)

Vous avez l'erreur parce que arange () ne vous permet pas de explicitement éviter le premier argument qui correspond à début. Si vous fournissez un seul argument, alors il doit être début, mais arange () l'utilisera pour définir où s'arrête le comptage.

Fournir des arguments négatifs

Si vous fournissez des valeurs négatives pour début ou les deux début et Arrêtezet avoir un effet positif étape, puis arange () fonctionnera de la même manière qu'avec tous les arguments positifs:

>>> np.s'organiser(-5, -1)
tableau ([-5, -4, -3, -2])
>>> np.s'organiser(-8, -2, 2)
tableau ([-8, -6, -4])
>>> np.s'organiser(-5, 6, 4)
tableau ([-5, -1,  3])

Ce comportement est entièrement compatible avec les exemples précédents. Le comptage commence par la valeur de début, incrémentant à plusieurs reprises par étapeet se terminant avant Arrêtez est atteint.

Compter en arrière

Parfois, vous voudrez un tableau avec les valeurs décrémentant de gauche à droite. Dans de tels cas, vous pouvez utiliser arange () avec une valeur négative pour étapeet avec un début plus grand que Arrêtez:

>>> np.s'organiser(5, 1, -1)
tableau ([5, 4, 3, 2])
>>> np.s'organiser(7, 0, -3)
tableau ([7, 4, 1])

Dans cet exemple, notez le motif suivant: le tableau obtenu commence par la valeur du premier argument et décrée pour étape vers la valeur du deuxième argument.

Dans la dernière déclaration, début est 7et le tableau résultant commence par cette valeur. étape est -3 donc la deuxième valeur est 7 + (- 3), c'est-à-dire 4. La troisième valeur est 4 + (- 3), ou 1. Compter s'arrête ici depuis Arrêtez (0) est atteint avant la valeur suivante (-2).

Vous pouvez voir les représentations graphiques de cet exemple dans la figure ci-dessous:

Encore, début est indiqué en vert, Arrêtez en rouge, tandis que étape et les valeurs contenues dans le tableau sont en bleu.

Cette fois, les flèches indiquent la direction de droite à gauche. C'est parce que début est supérieur à Arrêtez, étape est négatif, et vous comptez essentiellement à rebours.

L'exemple précédent produit le même résultat que le suivant:

>>> np.s'organiser(1, 8, 3)[::[::[::[::-1]
tableau ([7, 4, 1])
>>> np.retourner(np.s'organiser(1, 8, 3))
tableau ([7, 4, 1])

Cependant, la variante avec la valeur négative de étape est plus élégant et concis.

Se vider des tableaux

Il existe plusieurs cas où vous pouvez obtenir des matrices NumPy vides avec arange (). Ce sont des instances régulières de numpy.ndarray sans aucun élément.

Si vous fournissez des valeurs égales pour début et Arrêtez, alors vous aurez un tableau vide:

>>> np.s'organiser(2, 2)
tableau ([], type = int64)

En effet, le comptage se termine avant la valeur de Arrêtez est atteint. Depuis la valeur de début est égal à Arrêtez, il ne peut pas être atteint et inclus dans le tableau résultant.

Un des cas inhabituels est quand début est supérieur à Arrêtez et étape est positif, ou quand début est inférieur à Arrêtez et étape est négatif:

>>> np.s'organiser(8, 2, 1)
tableau ([], type = int64)
>>> np.s'organiser(2, 8, -1)
tableau ([], type = int64)

Comme vous pouvez le constater, ces exemples donnent des tableaux vides, ne pas avec des erreurs.

Types de données de np.arange ()

Les types d'éléments dans les tableaux NumPy constituent un aspect important de leur utilisation. Quand on travaille avec arange (), vous pouvez spécifier le type d’éléments avec le paramètre type.

Vous êtes libre d'omettre type. Dans ce cas, arange () essaiera de déduire le type de la matrice résultante. Cela dépend des types de début, Arrêtez, et étape, comme vous pouvez le voir dans l'exemple suivant:

>>> X = np.s'organiser(5)
>>> X
tableau ([0, 1, 2, 3, 4])
>>> X.type
dtype ('int64')
>>> X.articlesize  # En octets
8

Ici, il y a un argument (5) qui définit la plage de valeurs. Son type est int. C’est pourquoi le type de la matrice X sera l'un des types entiers fournis par NumPy. Dans ce cas, NumPy choisit la int64 dtype par défaut. Il s'agit d'un type entier de 64 bits (8 octets).

Le tableau de l'exemple précédent est équivalent à celui-ci:

>>> X = np.s'organiser(5, type=int)
>>> X
tableau ([0, 1, 2, 3, 4])
>>> X.type
dtype ('int64')

L'argument dtype = int n'est pas se référer à Python int. Cela se traduit par NumPy int64 ou simplement np.int.

NumPy vous propose plusieurs types d'entiers de taille fixe dont la mémoire et les limites diffèrent:

• np.int8: Entier signé de 8 bits (de -128 à 127)
• np.uint8: Entier non signé de 8 bits (de 0 à 255)
• np.int16: Entier signé de 16 bits (de -32768 à 32767)
• np.uint16: Entier non signé de 16 bits (de 0 à 65535)
• np.int32: Entier signé 32 bits (de -2 ** 31 à 2 ** 31-1)
• np.uint32: Entier non signé 32 bits (de 0 à 2 ** 32-1)
• np.int64: Entier signé de 64 bits (de -2 ** 63 à 2 ** 63-1)
• np.uint64: Entier non signé de 64 bits (de 0 à 2 ** 64-1)

Si vous voulez d'autres types entiers pour les éléments de votre tableau, spécifiez simplement type:

>>> X = np.s'organiser(5, type=np.int32)
>>> X
tableau ([0, 1, 2, 3, 4], dtype = int32)
>>> X.type
dtype ('int32')
>>> X.articlesize  # En octets
4

Le tableau résultant a maintenant les mêmes valeurs que dans le cas précédent, mais les types et les tailles des éléments diffèrent. L'argument dtype = np.int32 (ou dtype = 'int32') force la taille de chaque élément de X être 32 bits (8 octets).

Lorsque votre argument est un nombre décimal au lieu d'un entier, le type sera un type à virgule flottante NumPy, dans ce cas float64:

>>> y = np.s'organiser(5.0)
>>> y
tableau ([0., 1., 2., 3., 4.])
>>> y.type
dtype ('float64')

Les valeurs des éléments sont les mêmes dans les quatre derniers exemples, mais les types sont différents.

En règle générale, lorsque vous fournissez au moins un argument en virgule flottante à arange (), le tableau résultant aura des éléments à virgule flottante, même si les autres arguments sont des entiers:

>>> np.s'organiser(1, 5.1)
tableau ([1., 2., 3., 4., 5.])
>>> np.s'organiser(1, 5.1).type
dtype ('float64')
>>> np.s'organiser(0, 9, 1,5)
tableau ([0. , 1.5, 3. , 4.5, 6. , 7.5])
>>> np.s'organiser(0, 9, 1,5).type
dtype ('float64')

Dans les exemples ci-dessus, début est un entier, mais le type est np.float64 parce que Arrêtez ou étape sont des nombres à virgule flottante.

Si vous spécifiez type, puis arange () essaiera de produire un tableau avec les éléments du type de données fourni:

>>> y = np.s'organiser(5, type=flotte)
>>> y
tableau ([0., 1., 2., 3., 4.])
>>> y.type
dtype ('float64')

L'argument dtype = float ici se traduit par NumPy float64, C'est np.float. Il n'est pas se référer à Python flotte. Alias ​​de taille fixe pour float64 sont np.float64 et np.float_.

Lorsque vous avez besoin d'un type de type à virgule flottante avec une précision et une taille inférieures (en octets), vous pouvez spécifier explicitement que:

>>> z = np.s'organiser(5, type=np.float32)
>>> z
tableau ([0., 1., 2., 3., 4.], dtype = float32)
>>> z.type
dtype ('float32')

En utilisant dtype = np.float32 (ou dtype = 'float32') rend chaque élément du tableau z 32 bits (4 octets) de grande taille. La taille de chaque élément de y est de 64 bits (8 octets):

>>> y.articlesize  # En octets
8
>>> z.articlesize  # En octets
4

La différence entre les éléments de y et zet généralement entre np.float64 et np.float32, est la mémoire utilisée et la précision: la première est plus grande et plus précise que la seconde.

Dans de nombreux cas, vous ne remarquerez pas cette différence. Cependant, parfois, c'est important. Par exemple, TensorFlow utilise float32 et int32. De même, lorsque vous travaillez avec des images, même des types plus petits, tels que uint8 sont utilisés.

Quand étape n'est pas un entier, les résultats peuvent être incohérents en raison des limitations de l'arithmétique en virgule flottante.

Au-delà des gammes simples avec np.arange ()

Vous pouvez facilement combiner arange () avec des opérateurs (comme +, -, *, /, **, etc.) et d’autres routines NumPy (telles que abdos() ou péché()) pour produire les plages de valeurs de sortie:

>>> X = np.s'organiser(5)
>>> X
tableau ([0, 1, 2, 3, 4])
>>> 2**X
tableau ([ 1,  2,  4,  8, 16])
>>> y = np.s'organiser(-1, 1.1, 0.5)
>>> y
tableau ([-1. , -0.5,  0. ,  0.5,  1. ])
>>> np.abdos(y)
tableau ([1. , 0.5, 0. , 0.5, 1. ])
>>> z = np.s'organiser(dix)
>>> np.péché(z)
tableau ([0084147098090929743014112001-07568025[0084147098090929743014112001-07568025[0084147098090929743014112001-07568025[0084147098090929743014112001-07568025
                            -0.95892427, -0.2794155, 0.6569866, 0.98935825, 0.41211849])

Ceci est particulièrement approprié lorsque vous souhaitez créer un tracé dans Matplotlib.

Si vous avez besoin d’un tableau multidimensionnel, vous pouvez combiner arange () avec .reshape () ou fonctions et méthodes similaires:

>>> une = np.s'organiser(6).remodeler((2, 3))
>>> une
tableau ([[0, 1, 2],
       [3, 4, 5]])
>>> une.forme
(2, 3)
>>> une.ndim
2

C’est ainsi que vous pouvez obtenir le Ndarray exemple avec les éléments [0, 1, 2, 3, 4, 5] et le remodeler en un tableau à deux dimensions.

Comparaison de intervalle et np.arange ()

Python a une classe intégrée intervalle, similaire à NumPy arange () dans une certaine mesure. intervalle et np.arange () avoir d'importantes distinctions liées à l'application et à la performance. Vous verrez leurs différences et leurs similitudes.

La principale différence entre les deux est que intervalle est une classe Python intégrée, alors que arange () est une fonction qui appartient à une bibliothèque tierce (NumPy).

En outre, leurs objectifs sont différents! Généralement, intervalle est plus approprié quand vous avez besoin de répéter en utilisant le python pour boucle. Si vous souhaitez créer un tableau NumPy et appliquer des boucles rapides sous le capot, arange () est une bien meilleure solution.

Paramètres et sorties

Tous les deux intervalle et arange () ont les mêmes paramètres qui définissent les plages des nombres obtenus:

Vous appliquez ces paramètres de la même manière, même dans les cas où début et Arrêtez sont égaux.

Cependant, lorsque vous travaillez avec intervalle:

• Vous devez fournir des arguments entiers. Sinon, vous aurez un Erreur-type.
• Vous ne pouvez pas spécifier le type des nombres cédés. C'est toujours int.

intervalle et arange () diffèrent également dans leurs types de retour:

• intervalle crée une instance de cette classe qui a les mêmes caractéristiques que d’autres séquences (comme liste et tuple), tels que l'appartenance, la concaténation, la répétition, le découpage en tranches, la comparaison, la vérification de la longueur, etc.
• arange () retourne une instance de NumPy Ndarray.

Créer des séquences

Vous pouvez appliquer intervalle créer une instance de liste ou tuple avec des nombres régulièrement espacés dans une plage prédéfinie. Vous pourriez trouver des compréhensions particulièrement appropriées à cette fin.

Cependant, créer et manipuler des tableaux NumPy est souvent plus rapide et plus élégant que de travailler avec des listes ou des n-uplets.

Comparons les performances de création d’un liste en utilisant la compréhension contre un NumPy équivalent Ndarray avec arange ():

>>> importation temps
>>> n = 1
>>> temps.temps(F'x =[i**2foriinrange([i**2foriinrange([i**2foriinrange([i**2foriinrange(n)]')
>>> temps.temps(F'x = np.arange (n) ** 2 ', installer='import numpy en tant que np')

Répéter ce code pour faire varier les valeurs de n a donné les résultats suivants sur ma machine:

Ces résultats peuvent varier, mais vous pouvez clairement créer un tableau NumPy beaucoup plus rapidement qu'une liste, à l'exception des séquences de très petites longueurs. (L'application apporte souvent des avantages supplémentaires en termes de performances!)

En effet, NumPy effectue de nombreuses opérations, y compris la mise en boucle, sur le niveau C. De plus, NumPy est optimisé pour travailler avec des vecteurs et évite certains surcoûts liés à Python.

Python pour Boucles

Si vous avez besoin de valeurs à parcourir dans un Python pour boucle, puis intervalle est généralement une meilleure solution. Selon la documentation officielle de Python:

L'avantage de la intervalle tapez sur une régulière liste ou tuple est-ce un intervalle L’objet utilisera toujours la même (petite) quantité de mémoire, quelle que soit la taille de la plage qu’il représente (car il ne stocke que le début, Arrêtez et étape valeurs calculant des éléments individuels et des sous-gammes selon les besoins). (La source)

intervalle est souvent plus rapide que arange () lorsqu'il est utilisé en Python pour boucles, surtout quand il est possible de sortir rapidement d’une boucle. Ceci est dû au fait intervalle génère des nombres de manière paresseuse, car ils sont nécessaires, un à la fois.

En revanche, arange () génère tous les nombres au début.

Pour plus d'informations sur intervalle, vous pouvez consulter la fonction range () de Python () et la documentation officielle.

Autres routines basées sur des plages numériques

En plus de arange (), vous pouvez appliquer d’autres routines de création de tableaux NumPy basées sur des plages numériques:

• linspace () est similaire à arange () en ce sens qu'il renvoie des nombres régulièrement espacés. Toutefois, vous pouvez spécifier le nombre de valeurs à générer, indiquer si vous souhaitez inclure le noeud final et créer plusieurs baies simultanément.
• logspace () et geomspace () sont similaires à linspace (), sauf que les nombres renvoyés sont répartis uniformément sur l’échelle logarithmique.
• meshgrid (), ogrid (), et mgrid () retourner les grilles de points représentés sous forme de tableaux.

Toutes ces fonctions ont leurs spécificités et leurs cas d'utilisation. Vous pouvez choisir celui qui convient en fonction de vos besoins.

Comme vous l'avez déjà vu, NumPy contient plus de routines pour créer des instances de Ndarray.

Résumé rapide

Pour utiliser NumPy arange (), vous devez importer numpy premier:

>>> importation numpy comme np

Voici un tableau avec quelques exemples qui résument comment utiliser NumPy arange (). Il pourrait être utile de mémoriser diverses utilisations:

N’oubliez pas que vous pouvez également influer sur la mémoire utilisée par vos tableaux en spécifiant les types NumPy avec le paramètre type.

Conclusion

Vous savez maintenant comment utiliser NumPy arange (). La fonction np.arange () est l'une des routines fondamentales de NumPy souvent utilisées pour créer des instances de NumPy Ndarray. Il a quatre arguments:

1. début: la première valeur du tableau
2. Arrêtez: où le tableau se termine
3. étape: l'incrément ou décrément
4. type: le type des éléments du tableau

Vous avez également appris comment NumPy arange () compare avec la classe intégrée Python intervalle lorsque vous créez des séquences et que vous générez des valeurs à parcourir.

Vous avez constaté qu'il existe d'autres routines de création de tableaux NumPy basées sur des plages numériques, telles que linspace (), logspace (), meshgrid (), etc.

Si vous avez des questions ou des commentaires, veuillez les insérer dans la section commentaires ci-dessous.