range () dla pływaków

Czy istnieje range()odpowiednik dla pływaków w Pythonie?

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

Nie znam wbudowanej funkcji, ale napisanie takiej nie powinno być zbyt skomplikowane.

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

Jak wspominają komentarze, może to spowodować nieprzewidywalne wyniki, takie jak:

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

Aby uzyskać oczekiwany wynik, możesz użyć jednej z pozostałych odpowiedzi w tym pytaniu lub, jak wspomniał @Tadhg, możesz użyć decimal.Decimaljako jumpargumentu. Pamiętaj, aby zainicjować go za pomocą łańcucha, a nie liczby zmiennoprzecinkowej.

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

Lub nawet:

import decimal

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

I wtedy:

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

Możesz użyć:

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

lub użyj lambda / map:

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

Kiedyś używałem, numpy.arangeale miałem pewne komplikacje w kontrolowaniu liczby elementów, które zwraca, z powodu błędów zmiennoprzecinkowych. Więc teraz używam linspacenp:

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

Pylab ma frange(właściwie opakowanie 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. ])

Chętnie oceniane (2.x range):

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

Oceniane leniwie (2.x xrange, 3.x range):

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

Na przemian:

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

używanie itertools: leniwie obliczany zakres zmiennoprzecinkowy:

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

Pomogłem dodać funkcję numeric_range do pakietu more-itertools .

more_itertools.numeric_range(start, stop, step) działa jak wbudowany zakres funkcji, ale może obsługiwać typy zmiennoprzecinkowe, dziesiętne i ułamkowe.

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

Nie ma takiej wbudowanej funkcji, ale możesz użyć następującego (kod Python 3), aby wykonać zadanie tak bezpiecznie, jak pozwala na to Python.

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

Możesz to wszystko zweryfikować, uruchamiając kilka asercji:

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

Kod dostępny na GitHub

Dlaczego w bibliotece standardowej nie ma implementacji zakresu zmiennoprzecinkowego?

Jak wyjaśniono we wszystkich zamieszczonych tutaj postach, nie ma wersji zmiennoprzecinkowej range(). To powiedziawszy, pominięcie ma sens, jeśli weźmiemy pod uwagę, że range()funkcja jest często używana jako generator indeksu (i oczywiście oznacza to akcesor ). Tak więc, kiedy wywołujemy range(0,40), w efekcie mówimy, że chcemy 40 wartości zaczynających się od 0, do 40, ale bez wartości 40.

Kiedy weźmiemy pod uwagę, że generowanie indeksu dotyczy w takim samym stopniu liczby indeksów, jak ich wartości, użycie implementacji typu float range()w bibliotece standardowej ma mniejszy sens. Na przykład, jeśli nazwiemy funkcjęfrange(0, 10, 0.25) , spodziewalibyśmy się uwzględnienia zarówno 0, jak i 10, ale dałoby to wektor z 41 wartościami.

Zatem frange()funkcja zależna od jej użycia zawsze będzie wykazywać sprzeczne z intuicją zachowanie; albo ma zbyt wiele wartości postrzeganych z perspektywy indeksowania, albo nie obejmuje liczby, która powinna zostać zwrócona z matematycznego punktu widzenia.

Matematyczny przypadek użycia

Powiedziawszy to, jak omówiono, numpy.linspace()ładnie wypada generowanie z perspektywy matematycznej:

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

Przypadek użycia indeksowania

A jeśli chodzi o perspektywę indeksowania, napisałem nieco inne podejście z pewną sztuczną magią ciągów, która pozwala nam określić liczbę miejsc dziesiętnych.

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

Podobnie możemy również skorzystać z funkcji wbudowanej roundi określić liczbę miejsc po przecinku:

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

Szybkie porównanie i wydajność

Oczywiście, biorąc pod uwagę powyższe omówienie, funkcje te mają dość ograniczony przypadek użycia. Niemniej jednak, oto krótkie porównanie:

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)

Wyniki są identyczne dla każdego:

-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

I niektóre czasy:

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

Wygląda na to, że metoda formatowania ciągów wygrywa w moim systemie.

Ograniczenia

Na koniec zademonstrowanie punktu z powyższej dyskusji i ostatnie ograniczenie:

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

Ponadto, gdy skipparametr nie jest podzielny przez stopwartość, może wystąpić luka ziewania, biorąc pod uwagę ten drugi problem:

# 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

Istnieją sposoby rozwiązania tego problemu, ale ostatecznie najlepszym podejściem byłoby po prostu użycie Numpy.

Rozwiązanie bez NumPy itp zależnościami były dostarczone przez Kichik ale ze względu na pływających arytmetyki punktowych , często zachowuje się niespodziewanie. Jak zauważyłem przeze mnie i blubberdiblub , dodatkowe elementy łatwo wkradają się do wyniku. Na przykład naive_frange(0.0, 1.0, 0.1)dałby 0.999...jako ostatnią wartość, a tym samym dałby łącznie 11 wartości.

Solidna wersja jest dostępna tutaj:

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

Ponieważ mnożenie, błędy zaokrąglania nie kumulują się. Użycie epsilonznaku eliminuje ewentualny błąd zaokrąglenia mnożenia, chociaż oczywiście mogą pojawić się problemy na bardzo małych i bardzo dużych końcach. Teraz, zgodnie z oczekiwaniami:

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

I z nieco większymi liczbami:

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

Kod jest również dostępny jako GitHub Gist .

Prostsza wersja bez biblioteki

Do diabła - dorzucę prostą wersję bez biblioteki. Zapraszam do ulepszania go [*]:

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

Podstawową ideą jest nstepsliczba kroków, które prowadzą od początku do końca i range(nsteps)zawsze emituje liczby całkowite, więc nie ma utraty dokładności. Ostatnim krokiem jest liniowe odwzorowanie [0..nsteps] na [start..stop].

edytować

Jeśli, tak jak alancalvitti, chcesz, aby szereg miał dokładną racjonalną reprezentację, zawsze możesz użyć ułamków :

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

[*] W szczególności frange()zwraca listę, a nie generator. Ale to wystarczyło na moje potrzeby.

Można to zrobić za pomocą 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]

Uwaga 1: Z dyskusji w sekcji komentarzy tutaj: „nigdy nie używaj numpy.arange()(sama dokumentacja numpy odradza). Użyj numpy.linspace zgodnie z zaleceniami wim lub jednej z innych sugestii w tej odpowiedzi”

Uwaga 2: Przeczytałem dyskusję w kilku komentarzach tutaj, ale po powrocie do tego pytania po raz trzeci uważam, że ta informacja powinna zostać umieszczona w bardziej czytelnym miejscu.

Jak napisał Kichik , nie powinno to być zbyt skomplikowane. Jednak ten kod:

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

Jest nieodpowiedni ze względu na skumulowany efekt błędów podczas pracy z pływakami. Dlatego otrzymujesz coś takiego:

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

Chociaż oczekiwane zachowanie byłoby:

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

Rozwiązanie 1

Skumulowany błąd można po prostu zmniejszyć za pomocą zmiennej indeksującej. Oto przykład:

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

Ten przykład działa zgodnie z oczekiwaniami.

Rozwiązanie 2

Brak funkcji zagnieżdżonych. Tylko chwila i zmienna licznika:

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

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

Ta funkcja również będzie działać dobrze, z wyjątkiem przypadków, w których chcesz odwrócić zakres. Na przykład:

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

Rozwiązanie 1 w tym przypadku będzie działać zgodnie z oczekiwaniami. Aby ta funkcja działała w takich sytuacjach, musisz zastosować hack, podobny do następującego:

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

Dzięki temu hackowi możesz używać tych funkcji z negatywnymi krokami:

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

Rozwiązanie 3

Możesz pójść jeszcze dalej dzięki zwykłej bibliotece standardowej i skomponować funkcję zakresu dla większości typów liczbowych:

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

Ten generator jest zaadaptowany z książki Fluent Python (Rozdział 14. Iterables, Iterators and Generators). Nie będzie działać przy malejących zakresach. Musisz zastosować hack, podobnie jak w poprzednim rozwiązaniu.

Możesz użyć tego generatora w następujący sposób, na przykład:

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

I oczywiście możesz go również używać z float i int .

Bądź ostrożny

Jeśli chcesz używać tych funkcji z krokami ujemnymi, powinieneś dodać czek na znak kroku, np:

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

Najlepszą opcją jest podbicie StopIteration, jeśli chcesz naśladować rangesamą funkcję.

Zasięg naśladowania

Jeśli chcesz naśladować rangeinterfejs funkcji, możesz zapewnić sprawdzanie argumentów:

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

Myślę, że masz rację. Możesz korzystać z dowolnej z tych funkcji (z wyjątkiem pierwszej) i wszystko, czego potrzebujesz do nich, to standardowa biblioteka Pythona.

Napisałem funkcję, która zwraca krotkę z zakresu liczb zmiennoprzecinkowych o podwójnej precyzji bez żadnych miejsc dziesiętnych poza częściami setnymi. chodziło po prostu o przeanalizowanie wartości zakresu, takich jak łańcuchy, i oddzielenie nadmiaru. Używam go do wyświetlania zakresów do wyboru w interfejsie użytkownika. Mam nadzieję, że ktoś inny uzna to za przydatne.

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

Stosowanie

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

Zaokrąglić każdy krok do N miejsc dziesiętnych

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]

Kod

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

Dlaczego wybrać tę odpowiedź?

• Wiele innych odpowiedzi zawiesza się po wyświetleniu prośby o odliczanie.
• Wiele innych odpowiedzi da nieprawidłowo zaokrąglone wyniki.
• Inne odpowiedzi oparte na np.linspacetrafieniach i chybieniach mogą, ale nie muszą, działać z powodu trudności w wyborze prawidłowej liczby dywizji. np.linspacenaprawdę zmaga się z przyrostami dziesiętnymi wynoszącymi 0,1, a kolejność podziałów w formule służąca do konwersji przyrostu na liczbę podziałów może skutkować poprawnym lub uszkodzonym kodem.
• Inne odpowiedzi na podstawie np.arangesą przestarzałe.

W razie wątpliwości wypróbuj cztery powyższe przypadki testowe.

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)

Należy pamiętać, że pierwsza litera zakresu jest duża. Ta metoda nazewnictwa nie jest zalecana dla funkcji w Pythonie. Jeśli chcesz, możesz zmienić zakres na coś takiego jak drange lub frange. Funkcja „Zakres” zachowuje się tak, jak tego chcesz. Możesz sprawdzić jego instrukcję tutaj [ http://reference.wolfram.com/language/ref/Range.html ].

Myślę, że istnieje bardzo prosta odpowiedź, która naprawdę emuluje wszystkie cechy zakresu, ale zarówno dla liczby zmiennoprzecinkowej, jak i całkowitej. W tym rozwiązaniu po prostu załóżmy, że twoje przybliżenie domyślnie to 1e-7 (lub takie, które wybierzesz) i możesz je zmienić, wywołując funkcję.

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)

Będą oczywiście pewne błędy zaokrągleń, więc nie jest to idealne, ale to jest to, co zwykle używam w aplikacjach, które nie wymagają dużej precyzji. Jeśli chcesz, aby to było dokładniejsze, możesz dodać dodatkowy argument, aby określić, jak postępować z błędami zaokrąglania. Być może przekazanie funkcji zaokrąglającej może uczynić ją rozszerzalną i pozwolić programiście określić, jak postępować z błędami zaokrąglania.

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

Jeśli napiszę:

arange(0, 1, 0.1)

Wyświetli:

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

Czy istnieje odpowiednik range () dla liczb zmiennoprzecinkowych w Pythonie? NIE Użyj tego:

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

Istnieje kilka odpowiedzi, które nie obsługują prostych przypadków skrajnych, takich jak krok ujemny, zły start, stop itp. Oto wersja, która obsługuje wiele z tych przypadków poprawnie, zachowując takie samo zachowanie jak natywny 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  

Zauważ, że spowoduje to błąd step = 0, tak jak native range. Jedna różnica polega na tym, że zakres natywny zwraca obiekt, który jest indeksowalny i odwracalny, podczas gdy powyższy nie.

Możesz bawić się tym kodem i testami tutaj.