range() pour les flottants

Question

Y a-t-il un range() équivalent pour les flottants en Python ?

>>> range(0.5,5,1.5)
[0, 1, 2, 3, 4]
>>> range(0.5,5,0.5)

Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    range(0.5,5,0.5)
ValueError: range() step argument must not be zero

Answer 1

Vous pouvez soit utiliser :

[x / 10.0 for x in range(5, 50, 15)]

ou utiliser lambda / map :

map(lambda x: x/10.0, range(5, 50, 15))

Answer 2

~~Je ne connais pas de fonction intégrée, mais en écrire une comme [this](https://stackoverflow.com/a/477610/623735) ne devrait pas être trop compliqué.

def frange(x, y, jump):
  while x < y:
    yield x
    x += jump~~ \---

Comme le mentionnent les commentaires, cela pourrait produire des résultats imprévisibles, comme par exemple :

>>> list(frange(0, 100, 0.1))[-1]
99.9999999999986

Pour obtenir le résultat attendu, vous pouvez utiliser l'une des autres réponses à cette question, ou comme @Tadhg l'a mentionné, vous pouvez utiliser decimal.Decimal comme le jump argument. Veillez à l'initialiser avec une chaîne de caractères plutôt qu'avec un flottant.

>>> import decimal
>>> list(frange(0, 100, decimal.Decimal('0.1')))[-1]
Decimal('99.9')

Ou même :

import decimal

def drange(x, y, jump):
  while x < y:
    yield float(x)
    x += decimal.Decimal(jump)

Et puis :

>>> list(drange(0, 100, '0.1'))[-1]
99.9

[Si vous n'utilisez que des mots positifs jump et un démarrage et un arrêt entiers ( x y y ), cela fonctionne bien. Pour une solution plus générale, voir aquí .]

Answer 3

J'avais l'habitude d'utiliser numpy.arange mais j'ai eu quelques complications pour contrôler le nombre d'éléments qu'il renvoie, en raison d'erreurs de virgule flottante. J'utilise donc maintenant linspace par exemple :

>>> import numpy
>>> numpy.linspace(0, 10, num=4)
array([  0.        ,   3.33333333,   6.66666667,  10.        ])

Answer 4

Pylab a frange (une enveloppe, en fait, pour matplotlib.mlab.frange ):

>>> import pylab as pl
>>> pl.frange(0.5,5,0.5)
array([ 0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5,  5. ])

Answer 5

Évalué avec impatience (2.x range ):

[x * .5 for x in range(10)]

évalué paresseusement (2.x xrange , 3.x range ):

itertools.imap(lambda x: x * .5, xrange(10)) # or range(10) as appropriate

Alternativement :

itertools.islice(itertools.imap(lambda x: x * .5, itertools.count()), 10)
# without applying the `islice`, we get an infinite stream of half-integers.