Question Comment utiliser une valeur de pas décimale ()?


Y a-t-il un moyen de passer de 0 à 1 par 0,1?

Je pensais pouvoir le faire comme suit, mais cela a échoué:

for i in range(0, 1, 0.1):
    print i

Au lieu de cela, il dit que l'argument de l'étape ne peut pas être zéro, ce à quoi je ne m'attendais pas.


508
2018-01-25 10:20


origine


Réponses:


Vous pouvez également utiliser le NumPy bibliothèque (qui ne fait pas partie de la bibliothèque standard mais est relativement facile à obtenir) qui a le arange fonction:

>>> import numpy as np
>>> np.arange(0.0, 1.0, 0.1)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

aussi bien que linspace fonction qui vous permet de contrôler ce qui se passe au niveau du noeud final (non trivial pour les nombres à virgule flottante lorsque les éléments ne se divisent pas toujours en nombre correct de "tranches"):

>>> np.linspace(0,1,11)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9,  1. ])
>>> np.linspace(0,1,10,endpoint=False)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

624
2018-01-25 12:26



La plage de Python () ne peut faire que des entiers, pas des virgules flottantes. Dans votre cas spécifique, vous pouvez utiliser une compréhension de liste à la place:

[x * 0.1 for x in range(0, 10)]

(Remplacez l'appel par range avec cette expression.)

Pour le cas plus général, vous pouvez écrire une fonction ou un générateur personnalisé.


154
2018-01-25 10:35



Bâtir sur 'xrange ([start], stop [, step])', vous pouvez définir un générateur qui accepte et produit tout type que vous choisissez (coller aux types de support + et <):

>>> def drange(start, stop, step):
...     r = start
...     while r < stop:
...         yield r
...         r += step
...         
>>> i0=drange(0.0, 1.0, 0.1)
>>> ["%g" % x for x in i0]
['0', '0.1', '0.2', '0.3', '0.4', '0.5', '0.6', '0.7', '0.8', '0.9', '1']
>>> 

140
2018-01-25 11:57



Augmenter l'ampleur de i pour la boucle, puis réduisez-la quand vous en avez besoin.

for i * 100 in range(0, 100, 10):
    print i / 100.0

EDIT: Honnêtement, je ne me souviens pas pourquoi je pensais que cela fonctionnerait syntaxiquement

for i in range(0, 11, 1):
    print i / 10.0

Cela devrait avoir la sortie désirée.


30
2018-01-25 10:32



scipy a une fonction intégrée arange qui généralise Python range() constructeur pour satisfaire votre exigence de manutention de flotteur.

from scipy import arange


20
2018-05-17 20:50



NumPy est un peu exagéré, je pense.

[p/10 for p in range(0, 10)]
[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

D'une manière générale, faire un pas à pas1/x Jusqu'à y vous feriez

x=100
y=2
[p/x for p in range(0, int(x*y))]
[0.0, 0.01, 0.02, 0.03, ..., 1.97, 1.98, 1.99]

(1/x produit moins de bruit arrondi quand j'ai testé).


16
2018-02-28 02:06



Semblable à R's  seq fonction, celle-ci renvoie une séquence dans n'importe quel ordre, en fonction de la valeur de pas correcte. La dernière valeur est égale à la valeur d'arrêt.

def seq(start, stop, step=1):
    n = int(round((stop - start)/float(step)))
    if n > 1:
        return([start + step*i for i in range(n+1)])
    elif n == 1:
        return([start])
    else:
        return([])

Résultats

seq(1, 5, 0.5)

[1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0]

seq(10, 0, -1)

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

seq(10, 0, -2)

[10, 8, 6, 4, 2, 0]

seq(1, 1)

[ 1 ]


16
2018-06-11 19:10



La fonction intégrée range () renvoie une séquence de valeurs entières, je le crains, donc vous ne pouvez pas l'utiliser pour faire un pas décimal.

Je dirais juste utiliser une boucle while:

i = 0.0
while i <= 1.0:
    print i
    i += 0.1

Si vous êtes curieux, Python convertit votre 0.1 à 0, c'est pourquoi il vous dit que l'argument ne peut pas être nul.


10
2018-01-25 10:32



import numpy as np
for i in np.arange(0, 1, 0.1): 
    print i 

9
2017-09-07 02:01



Voici une solution utilisant itertools:

import itertools

def seq(start, end, step):
    assert(step != 0)
    sample_count = abs(end - start) / step
    return itertools.islice(itertools.count(start, step), sample_count)

Exemple d'utilisation:

for i in seq(0, 1, 0.1):
    print i

Sortie:

0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9

9
2017-11-08 10:00



[x * 0.1 for x in range(0, 10)] 

en Python 2.7x vous donne le résultat de:

[0.0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9]

mais si vous utilisez:

[ round(x * 0.1, 1) for x in range(0, 10)]

vous donne le désir:

[0,0, 0,1, 0,2, 0,3, 0,4, 0,5, 0,6, 0,7, 0,8, 0,9]


7
2018-05-13 23:20