range () para carros alegóricos

Existe um range()equivalente para carros alegóricos em 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

Não conheço uma função interna, mas escrever uma como essa não deve ser muito complicado.

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

Como os comentários mencionam, isso pode produzir resultados imprevisíveis, como:

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

Para obter o resultado esperado, você pode usar uma das outras respostas nesta pergunta ou, como @Tadhg mencionado, você pode usar decimal.Decimalcomo jumpargumento. Certifique-se de inicializá-lo com uma string em vez de um float.

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

Ou até:

import decimal

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

E depois:

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

Você pode usar:

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

ou use lambda / map:

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

Eu costumava usar, numpy.arangemas tive algumas complicações ao controlar o número de elementos que ele retorna, devido a erros de ponto flutuante. Então agora eu uso linspace, por exemplo:

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

O Pylab possui frange(um invólucro, na verdade, para 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. ])

Ansiosamente avaliado (2.x range):

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

Preguiçosamente avaliado (2.x xrange, 3.x range):

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

Alternativamente:

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

usando itertools: faixa de ponto flutuante avaliada preguiçosamente:

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

Ajudei a adicionar a função numeric_range ao pacote more-itertools .

more_itertools.numeric_range(start, stop, step) age como o intervalo de funções interno, mas pode lidar com tipos de flutuação, decimal e fração.

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

Não existe essa função interna, mas você pode usar o seguinte (código Python 3) para fazer o trabalho tão seguro quanto o Python permitir.

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

Você pode verificar tudo executando algumas asserções:

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

Código disponível no GitHub

Por que não há implementação de intervalo de ponto flutuante na biblioteca padrão?

Como ficou claro por todas as postagens aqui, não há versão de ponto flutuante range(). Dito isso, a omissão faz sentido se considerarmos que a range()função é frequentemente usada como um gerador de índice (e, claro, isso significa um acessador ). Portanto, quando chamamos range(0,40), estamos dizendo que queremos 40 valores começando em 0, até 40, mas não inclusivos em 40.

Quando consideramos que a geração de índice é tanto sobre o número de índices quanto sobre seus valores, o uso de uma implementação de float range()na biblioteca padrão faz menos sentido. Por exemplo, se chamarmos a função frange(0, 10, 0.25), esperaríamos que 0 e 10 fossem incluídos, mas isso renderia um vetor com 41 valores.

Assim, uma frange()função que depende de seu uso sempre exibirá um comportamento contra-intuitivo; possui valores demais percebidos da perspectiva da indexação ou não inclui um número que razoavelmente deve ser retornado da perspectiva matemática.

O caso de uso matemático

Com isso dito, conforme discutido, numpy.linspace()executa a geração com a perspectiva matemática bem:

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.
])

O caso de uso de indexação

E para a perspectiva da indexação, escrevi uma abordagem um pouco diferente com algumas mágicas complicadas de string que nos permitem especificar o número de casas decimais.

# 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))

Da mesma forma, também podemos usar a roundfunção interna e especificar o número de casas decimais:

# 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)

Uma rápida comparação e desempenho

Obviamente, dada a discussão acima, essas funções têm um caso de uso bastante limitado. No entanto, aqui está uma comparação rápida:

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)

Os resultados são idênticos para cada um:

-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

E alguns horários:

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

Parece que o método de formatação de strings vence por um fio no meu sistema.

As limitações

E, finalmente, uma demonstração do ponto da discussão acima e uma última limitação:

# "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

Além disso, quando o skipparâmetro não é divisível pelo stopvalor, pode haver uma lacuna de bocejo devido ao último problema:

# 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

Existem maneiras de resolver esse problema, mas no final do dia, a melhor abordagem provavelmente seria usar o Numpy.

Uma solução sem dependências numpy etc foi fornecida pelo kichik, mas devido à aritmética do ponto flutuante , ela geralmente se comporta inesperadamente. Conforme observado por mim e pelo blubberdiblub , elementos adicionais se infiltram facilmente no resultado. Por exemplo naive_frange(0.0, 1.0, 0.1), renderia 0.999...como seu último valor e, portanto, renderia 11 valores no total.

Uma versão robusta é fornecida aqui:

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

Devido à multiplicação, os erros de arredondamento não se acumulam. O uso de epsiloncuida de um possível erro de arredondamento da multiplicação, mesmo que as questões possam, obviamente, aumentar nos extremos muito pequeno e muito grande. Agora, como esperado:

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

E com números um pouco maiores:

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

O código também está disponível como GistHub Gist .

Uma versão mais simples sem biblioteca

Aw, heck - vou jogar em uma versão simples sem biblioteca. Sinta-se livre para melhorar [*]:

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)]

A idéia principal é que nstepsé o número de etapas para você começar do começo ao fim e range(nsteps)sempre emite números inteiros, para que não haja perda de precisão. O passo final é mapear [0..nsteps] linearmente para [start..stop].

editar

Se, como alancalvitti, você gostaria que a série tivesse uma representação racional exata, sempre poderá usar Frações :

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)]

[*] Em particular, frange()retorna uma lista, não um gerador. Mas bastava para as minhas necessidades.

Isso pode ser feito com numpy.arange (iniciar, parar, tamanho da etapa)

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]

Nota 1: Na discussão na seção de comentários aqui, "nunca use numpy.arange()(a própria documentação numpy recomenda isso). Use numpy.linspace conforme recomendado por wim ou uma das outras sugestões nesta resposta"

Nota 2: Li a discussão em alguns comentários aqui, mas depois de voltar a esta pergunta pela terceira vez, sinto que essa informação deve ser colocada em uma posição mais legível.

Como escreveu Kichik , isso não deve ser muito complicado. No entanto, este código:

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

É inadequado devido ao efeito cumulativo de erros ao trabalhar com carros alegóricos. É por isso que você recebe algo como:

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

Enquanto o comportamento esperado seria:

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

Solução 1

O erro cumulativo pode simplesmente ser reduzido usando uma variável de índice. Aqui está o exemplo:

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

Este exemplo funciona conforme o esperado.

Solução 2

Nenhuma função aninhada. Apenas um tempo e uma variável de contador:

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

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

Essa função também funcionará bem, exceto nos casos em que você deseja a faixa invertida. Por exemplo:

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

A solução 1 neste caso funcionará conforme o esperado. Para fazer essa função funcionar nessas situações, você deve aplicar um hack, semelhante ao seguinte:

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

Com este hack, você pode usar estas funções com etapas negativas:

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

Solução 3

Você pode ir ainda mais longe com a biblioteca padrão simples e compor uma função de intervalo para a maioria dos tipos numéricos:

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

Este gerador é adaptado do livro Fluent Python (capítulo 14. Iteráveis, iteradores e geradores). Não funcionará com intervalos decrescentes. Você deve aplicar um hack, como na solução anterior.

Você pode usar este gerador da seguinte maneira, por exemplo:

>>>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')]

E é claro que você pode usá-lo com float e int também.

Seja cuidadoso

Se você deseja usar essas funções com etapas negativas, adicione uma verificação do sinal de etapa, por exemplo:

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

A melhor opção aqui é aumentar StopIteration, se você deseja imitar a rangeprópria função.

Intervalo de imitação

Se você deseja imitar a rangeinterface da função, pode fornecer algumas verificações de argumento:

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

Eu acho que você entendeu. Você pode usar qualquer uma dessas funções (exceto a primeira) e tudo o que precisa é da biblioteca padrão do python.

eu escrevi uma função que retorna uma tupla de um intervalo de números de ponto flutuante de precisão dupla sem casas decimais além dos centésimos. era simplesmente uma questão de analisar os valores do intervalo, como seqüências de caracteres, e dividir o excesso. Eu o uso para exibir intervalos para selecionar em uma interface do usuário. Espero que alguém ache útil.

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

Uso

# 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]

Para arredondar cada etapa para N casas decimais

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]

Código

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

Por que escolher esta resposta?

• Muitas outras respostas serão interrompidas quando solicitadas a contagem regressiva.
• Muitas outras respostas fornecerão resultados arredondados incorretamente.
• Outras respostas baseadas em np.linspaceacerto-e-erro, podem ou não funcionar devido à dificuldade em escolher o número correto de divisões. np.linspacerealmente enfrenta incrementos decimais de 0,1, e a ordem das divisões na fórmula para converter o incremento em várias divisões pode resultar em código correto ou quebrado.
• Outras respostas baseadas np.arangeestão obsoletas.

Em caso de dúvida, tente os quatro casos de teste acima.

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)

Observe que a primeira letra do intervalo é maiúscula. Esse método de nomeação não é incentivado para funções no Python. Você pode alterar Range para algo como drange ou frange, se quiser. A função "Range" se comporta exatamente como você deseja. Você pode verificar o manual aqui [ http://reference.wolfram.com/language/ref/Range.html ].

Eu acho que existe uma resposta muito simples que realmente emula todos os recursos do range, mas para float e integer. Nesta solução, você apenas supõe que sua aproximação por padrão seja 1e-7 (ou a que você escolher) e poderá alterá-la quando chamar a função.

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)

É claro que haverá alguns erros de arredondamento, portanto isso não é perfeito, mas é o que geralmente uso para aplicativos, que não exigem alta precisão. Se você quiser tornar isso mais preciso, adicione um argumento extra para especificar como lidar com erros de arredondamento. Talvez a passagem de uma função de arredondamento possa torná-lo extensível e permitir que o programador especifique como lidar com erros de arredondamento.

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

Se eu escrever:

arange(0, 1, 0.1)

Ele produzirá:

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

Existe um intervalo () equivalente para carros alegóricos em Python? NÃO Use isto:

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

Existem várias respostas aqui que não lidam com casos simples de borda, como etapa negativa, início errado, parada etc. Aqui está a versão que lida com muitos desses casos, dando corretamente o mesmo comportamento que o nativo 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  

Observe que isso resultaria em erro na etapa = 0, como na versão nativa range . Uma diferença é que o intervalo nativo retorna um objeto indexável e reversível, enquanto o anterior não.

Você pode jogar com esse código e testar casos aqui.