numpy.arange() et numpy.linspace() génèrent numpy.ndarray avec des valeurs régulièrement espacées.
La différence est que l’intervalle est spécifié pour np.arange() et le nombre d’éléments est spécifié pour np.linspace().
Cet article décrit les éléments suivants :
- Spécifiez l’intervalle :
numpy.arange() - Spécifiez le nombre d’éléments :
numpy.linspace()- Utilisation de base
- Inclure stop ou non :
endpoint - Obtenez l’intervalle :
retstep
- Convertir en ordre inverse
- Convertir en un tableau multidimensionnel
Spécifiez l’intervalle :numpy.arange()
numpy.arange() est similaire à la fonction intégrée range() de Python. Voir l’article suivant pour range().
numpy.arange() génère numpy.ndarray avec des valeurs régulièrement espacées comme suit en fonction du nombre d’arguments spécifiés.
- numpy.arange (arrêter)
- numpy.arange (démarrer, arrêter)
- numpy.arange (démarrer, arrêter, étape)
- start <= n < stop (augmentation par pas)
import numpy as np
print(np.arange(3))
# [0 1 2]
print(np.arange(3, 10))
# [3 4 5 6 7 8 9]
print(np.arange(3, 10, 2))
# [3 5 7 9]
Contrairement à range(), vous pouvez spécifier float comme argument de numpy.arange().
print(np.arange(0.3, 1.0, 0.2))
# [0.3 0.5 0.7 0.9]
Le comportement avec des valeurs négatives est le même que celui de range(). De même, s’il n’y a pas de valeur correspondante, il génère un numpy.ndarray vide.
print(np.arange(-3, 3))
# [-3 -2 -1 0 1 2]
print(np.arange(10, 3))
# []
print(np.arange(10, 3, -2))
# [10 8 6 4]
Le type de données dtype est automatiquement sélectionné, mais vous pouvez le spécifier avec l’argument dtype.
print(np.arange(3, dtype=float))
# [0. 1. 2.]
print(np.arange(3, 10, dtype=float))
# [3. 4. 5. 6. 7. 8. 9.]
print(np.arange(3, 10, 2, dtype=float))
# [3. 5. 7. 9.]
Consultez l’article suivant pour plus d’informations sur le type de données dtype dans NumPy.
Spécifiez le nombre d’éléments :numpy.linspace()
Utilisation de base
Avec numpy.linspace(), vous pouvez spécifier le nombre d’éléments au lieu de l’intervalle.
Spécifiez la valeur de départ dans le premier argument start, la valeur de fin dans le deuxième argument stop et le nombre d’éléments dans le troisième argument num. L’intervalle est automatiquement calculé en fonction de ces valeurs.
import numpy as np
print(np.linspace(0, 10, 3))
# [ 0. 5. 10.]
print(np.linspace(0, 10, 4))
# [ 0. 3.33333333 6.66666667 10. ]
print(np.linspace(0, 10, 5))
# [ 0. 2.5 5. 7.5 10. ]
Il gère également le cas de start > stop correctement.
print(np.linspace(10, 0, 5))
# [10. 7.5 5. 2.5 0. ]
Le type de données dtype est automatiquement sélectionné, mais vous pouvez le spécifier avec l’argument dtype.
print(np.linspace(0, 10, 3, dtype=int))
# [ 0 5 10]
Inclure stop ou non :endpoint
Par défaut, la valeur de stop est incluse dans le résultat.
Si le point de terminaison de l’argument est défini sur False, le résultat n’inclut pas l’arrêt.
print(np.linspace(0, 10, 5))
# [ 0. 2.5 5. 7.5 10. ]
print(np.linspace(0, 10, 5, endpoint=False))
# [0. 2. 4. 6. 8.]
La relation entre le point de terminaison de l’argument et le pas d’intervalle est la suivante.
- endpoint=True (par défaut)
- étape = (arrêt – démarrage) / (num – 1)
- point de terminaison=Faux
- step = (stop – start) / num
Obtenez l’intervalle :retstep
Si vous voulez obtenir l’intervalle, définissez l’argument retstep sur True.
Dans ce cas, numpy.linspace() renvoie un tuple avec deux éléments, (numpy.ndarray, step).
result = np.linspace(0, 10, 5, retstep=True)
print(result)
# (array([ 0. , 2.5, 5. , 7.5, 10. ]), 2.5)
print(type(result))
# <class 'tuple'>
print(result[0])
# [ 0. 2.5 5. 7.5 10. ]
print(result[1])
# 2.5
Si vous souhaitez vérifier uniquement l’étape, récupérez le deuxième élément avec l’index.
print(np.linspace(0, 10, 5, retstep=True)[1])
# 2.5
print(np.linspace(0, 10, 5, retstep=True, endpoint=False)[1])
# 2.0
Convertir en ordre inverse
Avec numpy.arange(), vous pouvez obtenir un tableau dans l’ordre inverse si vous spécifiez correctement les arguments, mais c’est gênant.
print(np.arange(3, 10, 2))
# [3 5 7 9]
print(np.arange(9, 2, -2))
# [9 7 5 3]
Il est facile d’utiliser slice [::-1] ou numpy.flip().
print(np.arange(3, 10, 2)[::-1])
# [9 7 5 3]
print(np.flip(np.arange(3, 10, 2)))
# [9 7 5 3]
Dans le cas de numpy.linspace(), vous pouvez facilement inverser l’ordre en remplaçant le premier argument start et le deuxième argument stop. Le résultat est le même avec slice [::-1] et numpy.flip().
print(np.linspace(0, 10, 5))
# [ 0. 2.5 5. 7.5 10. ]
print(np.linspace(10, 0, 5))
# [10. 7.5 5. 2.5 0. ]
print(np.linspace(0, 10, 5)[::-1])
# [10. 7.5 5. 2.5 0. ]
print(np.flip(np.linspace(0, 10, 5)))
# [10. 7.5 5. 2.5 0. ]
Convertir en un tableau multidimensionnel
Ni numpy.arange() ni numpy.linspace() n’ont d’arguments pour spécifier la forme. Utilisez le reshape () pour convertir en un tableau multidimensionnel.
print(np.arange(12).reshape(3, 4))
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
print(np.arange(24).reshape(2, 3, 4))
# [[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
#
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]]
print(np.linspace(0, 10, 12).reshape(3, 4))
# [[ 0. 0.90909091 1.81818182 2.72727273]
# [ 3.63636364 4.54545455 5.45454545 6.36363636]
# [ 7.27272727 8.18181818 9.09090909 10. ]]
print(np.linspace(0, 10, 24).reshape(2, 3, 4))
# [[[ 0. 0.43478261 0.86956522 1.30434783]
# [ 1.73913043 2.17391304 2.60869565 3.04347826]
# [ 3.47826087 3.91304348 4.34782609 4.7826087 ]]
#
# [[ 5.2173913 5.65217391 6.08695652 6.52173913]
# [ 6.95652174 7.39130435 7.82608696 8.26086957]
# [ 8.69565217 9.13043478 9.56521739 10. ]]]