range () pour les flotteurs

Existe-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

Je ne connais pas de fonction intégrée, mais en écrire une comme celle- ci 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 tels que:

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

Pour obtenir le résultat attendu, vous pouvez utiliser l'une des autres réponses de cette question, ou comme @Tadhg l'a mentionné, vous pouvez utiliser decimal.Decimalcomme jumpargument. Assurez-vous de l'initialiser avec une chaîne plutôt qu'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)

Puis:

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

Vous pouvez soit utiliser:

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

ou utilisez lambda / map:

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

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

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

Pylab a frange(un wrapper, 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. ])

É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.

en utilisant itertools: plage de virgule flottante évaluée paresseusement:

>>> from itertools import count, takewhile
>>> def frange(start, stop, step):
        return takewhile(lambda x: x< stop, count(start, step))

>>> list(frange(0.5, 5, 1.5))
# [0.5, 2.0, 3.5]

J'ai aidé à ajouter la fonction numeric_range au package more-itertools .

more_itertools.numeric_range(start, stop, step) agit comme la plage de fonctions intégrée mais peut gérer les types floats, Decimal et Fraction.

>>> from more_itertools import numeric_range
>>> tuple(numeric_range(.1, 5, 1))
(0.1, 1.1, 2.1, 3.1, 4.1)

Il n'existe pas de fonction intégrée de ce type, mais vous pouvez utiliser ce qui suit (code Python 3) pour effectuer le travail de la manière la plus sûre que Python vous permet.

from fractions import Fraction

def frange(start, stop, jump, end=False, via_str=False):
    """
    Equivalent of Python 3 range for decimal numbers.

    Notice that, because of arithmetic errors, it is safest to
    pass the arguments as strings, so they can be interpreted to exact fractions.

    >>> assert Fraction('1.1') - Fraction(11, 10) == 0.0
    >>> assert Fraction( 0.1 ) - Fraction(1, 10) == Fraction(1, 180143985094819840)

    Parameter `via_str` can be set to True to transform inputs in strings and then to fractions.
    When inputs are all non-periodic (in base 10), even if decimal, this method is safe as long
    as approximation happens beyond the decimal digits that Python uses for printing.


    For example, in the case of 0.1, this is the case:

    >>> assert str(0.1) == '0.1'
    >>> assert '%.50f' % 0.1 == '0.10000000000000000555111512312578270211815834045410'


    If you are not sure whether your decimal inputs all have this property, you are better off
    passing them as strings. String representations can be in integer, decimal, exponential or
    even fraction notation.

    >>> assert list(frange(1, 100.0, '0.1', end=True))[-1] == 100.0
    >>> assert list(frange(1.0, '100', '1/10', end=True))[-1] == 100.0
    >>> assert list(frange('1', '100.0', '.1', end=True))[-1] == 100.0
    >>> assert list(frange('1.0', 100, '1e-1', end=True))[-1] == 100.0
    >>> assert list(frange(1, 100.0, 0.1, end=True))[-1] != 100.0
    >>> assert list(frange(1, 100.0, 0.1, end=True, via_str=True))[-1] == 100.0

    """
    if via_str:
        start = str(start)
        stop = str(stop)
        jump = str(jump)
    start = Fraction(start)
    stop = Fraction(stop)
    jump = Fraction(jump)
    while start < stop:
        yield float(start)
        start += jump
    if end and start == stop:
        yield(float(start))

Vous pouvez tout vérifier en exécutant quelques assertions:

assert Fraction('1.1') - Fraction(11, 10) == 0.0
assert Fraction( 0.1 ) - Fraction(1, 10) == Fraction(1, 180143985094819840)

assert str(0.1) == '0.1'
assert '%.50f' % 0.1 == '0.10000000000000000555111512312578270211815834045410'

assert list(frange(1, 100.0, '0.1', end=True))[-1] == 100.0
assert list(frange(1.0, '100', '1/10', end=True))[-1] == 100.0
assert list(frange('1', '100.0', '.1', end=True))[-1] == 100.0
assert list(frange('1.0', 100, '1e-1', end=True))[-1] == 100.0
assert list(frange(1, 100.0, 0.1, end=True))[-1] != 100.0
assert list(frange(1, 100.0, 0.1, end=True, via_str=True))[-1] == 100.0

assert list(frange(2, 3, '1/6', end=True))[-1] == 3.0
assert list(frange(0, 100, '1/3', end=True))[-1] == 100.0

Code disponible sur GitHub

Pourquoi n'y a-t-il pas d'implémentation de plage de virgule flottante dans la bibliothèque standard?

Comme le montrent tous les articles ici, il n'y a pas de version en virgule flottante de range(). Cela dit, l'omission a du sens si l'on considère que la range()fonction est souvent utilisée comme un générateur d' index (et bien sûr, cela signifie un accesseur ). Ainsi, lorsque nous appelons range(0,40), nous disons en fait que nous voulons 40 valeurs commençant à 0, jusqu'à 40, mais non compris 40 lui-même.

Lorsque nous considérons que la génération d'index concerne autant le nombre d'indices que leurs valeurs, l'utilisation d'une implémentation float de range()dans la bibliothèque standard a moins de sens. Par exemple, si nous appelions la fonction frange(0, 10, 0.25), nous nous attendrions à ce que 0 et 10 soient inclus, mais cela donnerait un vecteur avec 41 valeurs.

Ainsi, une frange()fonction dépendant de son utilisation présentera toujours un comportement contre-intuitif; il a trop de valeurs perçues du point de vue de l'indexation ou ne comprend pas un nombre qui devrait raisonnablement être renvoyé du point de vue mathématique.

Le cas d'utilisation mathématique

Cela dit, comme discuté, numpy.linspace()effectue bien la génération avec la perspective mathématique:

numpy.linspace(0, 10, 41)
array([  0.  ,   0.25,   0.5 ,   0.75,   1.  ,   1.25,   1.5 ,   1.75,
         2.  ,   2.25,   2.5 ,   2.75,   3.  ,   3.25,   3.5 ,   3.75,
         4.  ,   4.25,   4.5 ,   4.75,   5.  ,   5.25,   5.5 ,   5.75,
         6.  ,   6.25,   6.5 ,   6.75,   7.  ,   7.25,   7.5 ,   7.75,
         8.  ,   8.25,   8.5 ,   8.75,   9.  ,   9.25,   9.5 ,   9.75,  10.
])

Le cas d'utilisation de l'indexation

Et pour la perspective de l'indexation, j'ai écrit une approche légèrement différente avec une magie de chaîne astucieuse qui nous permet de spécifier le nombre de décimales.

# Float range function - string formatting method
def frange_S (start, stop, skip = 1.0, decimals = 2):
    for i in range(int(start / skip), int(stop / skip)):
        yield float(("%0." + str(decimals) + "f") % (i * skip))

De même, nous pouvons également utiliser la roundfonction intégrée et spécifier le nombre de décimales:

# Float range function - rounding method
def frange_R (start, stop, skip = 1.0, decimals = 2):
    for i in range(int(start / skip), int(stop / skip)):
        yield round(i * skip, ndigits = decimals)

Une comparaison rapide et des performances

Bien entendu, compte tenu de la discussion ci-dessus, ces fonctions ont un cas d'utilisation assez limité. Néanmoins, voici une comparaison rapide:

def compare_methods (start, stop, skip):

    string_test  = frange_S(start, stop, skip)
    round_test   = frange_R(start, stop, skip)

    for s, r in zip(string_test, round_test):
        print(s, r)

compare_methods(-2, 10, 1/3)

Les résultats sont identiques pour chacun:

-2.0 -2.0
-1.67 -1.67
-1.33 -1.33
-1.0 -1.0
-0.67 -0.67
-0.33 -0.33
0.0 0.0
...
8.0 8.0
8.33 8.33
8.67 8.67
9.0 9.0
9.33 9.33
9.67 9.67

Et quelques horaires:

>>> import timeit

>>> setup = """
... def frange_s (start, stop, skip = 1.0, decimals = 2):
...     for i in range(int(start / skip), int(stop / skip)):
...         yield float(("%0." + str(decimals) + "f") % (i * skip))
... def frange_r (start, stop, skip = 1.0, decimals = 2):
...     for i in range(int(start / skip), int(stop / skip)):
...         yield round(i * skip, ndigits = decimals)
... start, stop, skip = -1, 8, 1/3
... """

>>> min(timeit.Timer('string_test = frange_s(start, stop, skip); [x for x in string_test]', setup=setup).repeat(30, 1000))
0.024284090992296115

>>> min(timeit.Timer('round_test = frange_r(start, stop, skip); [x for x in round_test]', setup=setup).repeat(30, 1000))
0.025324633985292166

On dirait que la méthode de formatage de chaîne gagne par un cheveu sur mon système.

Les limites

Et enfin, une démonstration du point de la discussion ci-dessus et une dernière limitation:

# "Missing" the last value (10.0)
for x in frange_R(0, 10, 0.25):
    print(x)

0.25
0.5
0.75
1.0
...
9.0
9.25
9.5
9.75

De plus, lorsque le skipparamètre n'est pas divisible par la stopvaleur, il peut y avoir un écart béant compte tenu de ce dernier problème:

# Clearly we know that 10 - 9.43 is equal to 0.57
for x in frange_R(0, 10, 3/7):
    print(x)

0.0
0.43
0.86
1.29
...
8.14
8.57
9.0
9.43

Il existe des moyens de résoudre ce problème, mais en fin de compte, la meilleure approche serait probablement d'utiliser simplement Numpy.

Une solution sans dépendances numpy etc a été fournie par kichik mais en raison de l'arithmétique en virgule flottante , elle se comporte souvent de manière inattendue. Comme je l' ai noté et blubberdiblub , des éléments supplémentaires se faufilent facilement dans le résultat. Par exemple, naive_frange(0.0, 1.0, 0.1)il donnerait 0.999...comme dernière valeur et donnerait ainsi 11 valeurs au total.

Une version robuste est fournie ici:

def frange(x, y, jump=1.0):
    '''Range for floats.'''
    i = 0.0
    x = float(x)  # Prevent yielding integers.
    x0 = x
    epsilon = jump / 2.0
    yield x  # yield always first value
    while x + epsilon < y:
        i += 1.0
        x = x0 + i * jump
        yield x

Parce que la multiplication, les erreurs d'arrondi ne s'accumulent pas. L'utilisation de epsilonprend en compte les éventuelles erreurs d'arrondi de la multiplication, même si des problèmes peuvent bien sûr surgir dans les très petites et très grandes extrémités. Maintenant, comme prévu:

> a = list(frange(0.0, 1.0, 0.1))
> a[-1]
0.9
> len(a)
10

Et avec des nombres un peu plus grands:

> b = list(frange(0.0, 1000000.0, 0.1))
> b[-1]
999999.9
> len(b)
10000000

Le code est également disponible sous forme de GitHub Gist .

Une version plus simple sans bibliothèque

Oh, diable - je vais jeter dans une version simple sans bibliothèque. N'hésitez pas à l'améliorer [*]:

def frange(start=0, stop=1, jump=0.1):
    nsteps = int((stop-start)/jump)
    dy = stop-start
    # f(i) goes from start to stop as i goes from 0 to nsteps
    return [start + float(i)*dy/nsteps for i in range(nsteps)]

L'idée principale est que nstepsc'est le nombre d'étapes pour vous amener du début à la fin etrange(nsteps) émet toujours des entiers afin qu'il n'y ait pas de perte de précision. La dernière étape consiste à mapper [0..nsteps] linéairement sur [start..stop].

Éditer

Si, comme alancalvitti, vous souhaitez que la série ait une représentation rationnelle exacte, vous pouvez toujours utiliser des fractions :

from fractions import Fraction

def rrange(start=0, stop=1, jump=0.1):
    nsteps = int((stop-start)/jump)
    return [Fraction(i, nsteps) for i in range(nsteps)]

[*] En particulier, frange()renvoie une liste, pas un générateur. Mais cela suffisait à mes besoins.

Cela peut être fait avec numpy.arange (start, stop, stepsize)

import numpy as np

np.arange(0.5,5,1.5)
>> [0.5, 2.0, 3.5, 5.0]

# OBS you will sometimes see stuff like this happening, 
# so you need to decide whether that's not an issue for you, or how you are going to catch it.
>> [0.50000001, 2.0, 3.5, 5.0]

Remarque 1: D'après la discussion dans la section des commentaires ici, "ne jamais utiliser numpy.arange()(la documentation numpy elle-même le recommande contre). Utilisez numpy.linspace comme recommandé par wim, ou l'une des autres suggestions de cette réponse"

Note 2: J'ai lu la discussion dans quelques commentaires ici, mais après être revenu sur cette question pour la troisième fois maintenant, je pense que cette information devrait être placée dans une position plus lisible.

Comme l'a écrit Kichik , cela ne devrait pas être trop compliqué. Cependant ce code:

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

Est inapproprié en raison de l' effet cumulatif des erreurs lors de l'utilisation de flotteurs. C'est pourquoi vous recevez quelque chose comme:

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

Alors que le comportement attendu serait:

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

Solution 1

L'erreur cumulative peut simplement être réduite en utilisant une variable d'index. Voici l'exemple:

from math import ceil

    def frange2(start, stop, step):
        n_items = int(ceil((stop - start) / step))
        return (start + i*step for i in range(n_items))

Cet exemple fonctionne comme prévu.

Solution 2

Aucune fonction imbriquée. Seulement un moment et une variable de compteur:

def frange3(start, stop, step):
    res, n = start, 1

    while res < stop:
        yield res
        res = start + n * step
        n += 1

Cette fonction fonctionnera également bien, sauf dans les cas où vous souhaitez inverser la plage. Par exemple:

>>>list(frange3(1, 0, -.1))
[]

La solution 1 dans ce cas fonctionnera comme prévu. Pour que cette fonction fonctionne dans de telles situations, vous devez appliquer un hack, semblable à ce qui suit:

from operator import gt, lt

def frange3(start, stop, step):
    res, n = start, 0.
    predicate = lt if start < stop else gt
    while predicate(res, stop):
        yield res
        res = start + n * step
        n += 1

Avec ce hack, vous pouvez utiliser ces fonctions avec des étapes négatives:

>>>list(frange3(1, 0, -.1))
[1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.3999999999999999, 0.29999999999999993, 0.19999999999999996, 0.09999999999999998]

Solution 3

Vous pouvez aller encore plus loin avec la bibliothèque standard simple et composer une fonction de plage pour la plupart des types numériques:

from itertools import count
from itertools import takewhile

def any_range(start, stop, step):
    start = type(start + step)(start)
    return takewhile(lambda n: n < stop, count(start, step))

Ce générateur est adapté du livre Fluent Python (Chapitre 14. Itérables, itérateurs et générateurs). Cela ne fonctionnera pas avec des plages décroissantes. Vous devez appliquer un hack, comme dans la solution précédente.

Vous pouvez utiliser ce générateur comme suit, par exemple:

>>>list(any_range(Fraction(2, 1), Fraction(100, 1), Fraction(1, 3)))[-1]
299/3
>>>list(any_range(Decimal('2.'), Decimal('4.'), Decimal('.3')))
[Decimal('2'), Decimal('2.3'), Decimal('2.6'), Decimal('2.9'), Decimal('3.2'), Decimal('3.5'), Decimal('3.8')]

Et bien sûr, vous pouvez également l'utiliser avec float et int .

Faites attention

Si vous souhaitez utiliser ces fonctions avec des étapes négatives, vous devez ajouter une vérification pour le signe de l'étape, par exemple:

no_proceed = (start < stop and step < 0) or (start > stop and step > 0)
if no_proceed: raise StopIteration

La meilleure option ici est d'augmenter StopIteration, si vous voulez imiter la rangefonction elle-même.

Gamme Mimic

Si vous souhaitez imiter l' rangeinterface de la fonction, vous pouvez fournir des vérifications d'argument:

def any_range2(*args):
    if len(args) == 1:
        start, stop, step = 0, args[0], 1.
    elif len(args) == 2:
        start, stop, step = args[0], args[1], 1.
    elif len(args) == 3:
        start, stop, step = args
    else:
        raise TypeError('any_range2() requires 1-3 numeric arguments')

    # here you can check for isinstance numbers.Real or use more specific ABC or whatever ...

    start = type(start + step)(start)
    return takewhile(lambda n: n < stop, count(start, step))

Je pense que vous avez compris. Vous pouvez utiliser l'une de ces fonctions (sauf la toute première) et tout ce dont vous avez besoin est une bibliothèque standard python.

J'ai écrit une fonction qui renvoie un tuple d'une plage de nombres à virgule flottante double précision sans décimales au-delà des centièmes. il s'agissait simplement d'analyser les valeurs de plage telles que les chaînes et de séparer l'excédent. Je l'utilise pour afficher des plages à sélectionner dans une interface utilisateur. J'espère que quelqu'un d'autre le trouvera utile.

def drange(start,stop,step):
    double_value_range = []
    while start<stop:
        a = str(start)
        a.split('.')[1].split('0')[0]
        start = float(str(a))
        double_value_range.append(start)
        start = start+step
    double_value_range_tuple = tuple(double_value_range)
   #print double_value_range_tuple
    return double_value_range_tuple

Usage

# Counting up
drange(0, 0.4, 0.1)
[0, 0.1, 0.2, 0.30000000000000004, 0.4]

# Counting down
drange(0, -0.4, -0.1)
[0, -0.1, -0.2, -0.30000000000000004, -0.4]

Pour arrondir chaque pas à N décimales

drange(0, 0.4, 0.1, round_decimal_places=4)
[0, 0.1, 0.2, 0.3, 0.4]

drange(0, -0.4, -0.1, round_decimal_places=4)
[0, -0.1, -0.2, -0.3, -0.4]

Code

def drange(start, end, increment, round_decimal_places=None):
    result = []
    if start < end:
        # Counting up, e.g. 0 to 0.4 in 0.1 increments.
        if increment < 0:
            raise Exception("Error: When counting up, increment must be positive.")
        while start <= end:
            result.append(start)
            start += increment
            if round_decimal_places is not None:
                start = round(start, round_decimal_places)
    else:
        # Counting down, e.g. 0 to -0.4 in -0.1 increments.
        if increment > 0:
            raise Exception("Error: When counting down, increment must be negative.")
        while start >= end:
            result.append(start)
            start += increment
            if round_decimal_places is not None:
                start = round(start, round_decimal_places)
    return result

Pourquoi choisir cette réponse?

• De nombreuses autres réponses se bloqueront lorsqu'on leur demandera de compter à rebours.
• De nombreuses autres réponses donneront des résultats incorrectement arrondis.
• D'autres réponses basées sur np.linspacesont aléatoires, elles peuvent ou non fonctionner en raison de la difficulté à choisir le nombre correct de divisions. np.linspacea vraiment du mal avec les incréments décimaux de 0,1, et l'ordre des divisions dans la formule pour convertir l'incrément en un certain nombre de fractionnements peut entraîner un code correct ou cassé.
• Les autres réponses basées sur np.arangesont obsolètes.

En cas de doute, essayez les quatre cas de tests ci-dessus.

def Range(*argSequence):
    if len(argSequence) == 3:
        imin = argSequence[0]; imax = argSequence[1]; di = argSequence[2]
        i = imin; iList = []
        while i <= imax:
            iList.append(i)
            i += di
        return iList
    if len(argSequence) == 2:
        return Range(argSequence[0], argSequence[1], 1)
    if len(argSequence) == 1:
        return Range(1, argSequence[0], 1)

Veuillez noter que la première lettre de Range est en majuscule. Cette méthode de dénomination n'est pas recommandée pour les fonctions en Python. Vous pouvez changer Range en quelque chose comme drange ou frange si vous le souhaitez. La fonction "Range" se comporte exactement comme vous le souhaitez. Vous pouvez consulter son manuel ici [ http://reference.wolfram.com/language/ref/Range.html ].

Je pense qu'il existe une réponse très simple qui émule vraiment toutes les fonctionnalités de la plage, mais pour les nombres flottants et entiers. Dans cette solution, vous supposez simplement que votre approximation par défaut est 1e-7 (ou celle que vous choisissez) et vous pouvez la modifier lorsque vous appelez la fonction.

def drange(start,stop=None,jump=1,approx=7): # Approx to 1e-7 by default
  '''
  This function is equivalent to range but for both float and integer
  '''
  if not stop: # If there is no y value: range(x)
      stop= start
      start= 0
  valor= round(start,approx)
  while valor < stop:
      if valor==int(valor):
          yield int(round(valor,approx))
      else:
          yield float(round(valor,approx))
      valor += jump
  for i in drange(12):
      print(i)

Il y aura bien sûr des erreurs d'arrondi, donc ce n'est pas parfait, mais c'est ce que j'utilise généralement pour les applications qui ne nécessitent pas de haute précision. Si vous souhaitez rendre cela plus précis, vous pouvez ajouter un argument supplémentaire pour spécifier comment gérer les erreurs d'arrondi. Peut-être que passer une fonction d'arrondi pourrait rendre cette fonction extensible et permettre au programmeur de spécifier comment gérer les erreurs d'arrondi.

arange = lambda start, stop, step: [i + step * i for i in range(int((stop - start) / step))]

Si j'écris:

arange(0, 1, 0.1)

Il produira:

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

Existe-t-il un équivalent range () pour les flottants en Python? NON Utilisez ceci:

def f_range(start, end, step):
    a = range(int(start/0.01), int(end/0.01), int(step/0.01))
    var = []
    for item in a:
        var.append(item*0.01)
    return var

Il a plusieurs réponses ici qui ne gère pas les cas de pointe simples comme pas négatif, mauvais départ, arrêt , etc. Voici la version qui gère de nombreux de ces cas donnent correctement même comportement que natif range():

def frange(start, stop=None, step=1):
  if stop is None:
    start, stop = 0, start
  steps = int((stop-start)/step)
  for i in range(steps):
    yield start
    start += step  

Notez que cela entraînerait une erreur de step = 0 tout comme native range. Une différence est que la plage native renvoie un objet indexable et réversible alors que ce n'est pas le cas ci-dessus.

Vous pouvez jouer avec ce code et des cas de test ici.