Wie verwendet man einen dezimalen Bereich()-Schrittwert?

Question

Gibt es eine Möglichkeit, zwischen 0 und 1 um 0,1 zu wechseln?

Ich dachte, ich könnte es wie folgt machen, aber es hat nicht geklappt:

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

Stattdessen heißt es, dass das Schrittargument nicht Null sein kann, was ich nicht erwartet hatte.

Answer 1

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

Answer 2

Beste Lösung: kein Rundungsfehler

>>> step = .1
>>> N = 10     # number of data points
>>> [ x / pow(step, -1) for x in range(0, N + 1) ]

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]

Oder verwenden Sie für einen festgelegten Bereich anstelle von festgelegten Datenpunkten (z. B. eine kontinuierliche Funktion):

>>> step = .1
>>> rnge = 1     # NOTE range = 1, i.e. span of data points
>>> N = int(rnge / step
>>> [ x / pow(step,-1) for x in range(0, N + 1) ]

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]

Um eine Funktion zu implementieren: ersetzen Sie x / pow(step, -1) avec f( x / pow(step, -1) ) und definieren f .
Zum Beispiel:

>>> import math
>>> def f(x):
        return math.sin(x)

>>> step = .1
>>> rnge = 1     # NOTE range = 1, i.e. span of data points
>>> N = int(rnge / step)
>>> [ f( x / pow(step,-1) ) for x in range(0, N + 1) ]

[0.0, 0.09983341664682815, 0.19866933079506122, 0.29552020666133955, 0.3894183423086505, 
 0.479425538604203, 0.5646424733950354, 0.644217687237691, 0.7173560908995228,
 0.7833269096274834, 0.8414709848078965]

Answer 3

more_itertools ist eine Bibliothek eines Drittanbieters, die eine numeric_range Werkzeug:

import more_itertools as mit

for x in mit.numeric_range(0, 1, 0.1):
    print("{:.1f}".format(x))

Ausgabe

0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9

Dieses Tool funktioniert auch für Decimal y Fraction .

Answer 4

Und wenn Sie dies häufig tun, sollten Sie die erzeugte Liste speichern r

r=map(lambda x: x/10.0,range(0,10))
for i in r:
    print i

Answer 5

Es überrascht, dass noch niemand die empfohlene Lösung erwähnt hat in den Python 3-Dokumenten :

Siehe auch:

• El Linspace-Rezept zeigt, wie man eine träge Version von range implementiert, die für Fließkomma-Anwendungen geeignet ist.

Einmal definiert, ist das Rezept einfach zu verwenden und erfordert keine numpy oder andere externe Bibliotheken, sondern Funktionen wie numpy.linspace() . Beachten Sie, dass anstelle einer step Argument, das dritte num Argument gibt die Anzahl der gewünschten Werte an, zum Beispiel:

print(linspace(0, 10, 5))
# linspace(0, 10, 5)
print(list(linspace(0, 10, 5)))
# [0.0, 2.5, 5.0, 7.5, 10]

Im Folgenden zitiere ich eine modifizierte Version des vollständigen Python-3-Rezepts von Andrew Barnert:

import collections.abc
import numbers

class linspace(collections.abc.Sequence):
    """linspace(start, stop, num) -> linspace object

    Return a virtual sequence of num numbers from start to stop (inclusive).

    If you need a half-open range, use linspace(start, stop, num+1)[:-1].
    """
    def __init__(self, start, stop, num):
        if not isinstance(num, numbers.Integral) or num <= 1:
            raise ValueError('num must be an integer > 1')
        self.start, self.stop, self.num = start, stop, num
        self.step = (stop-start)/(num-1)
    def __len__(self):
        return self.num
    def __getitem__(self, i):
        if isinstance(i, slice):
            return [self[x] for x in range(*i.indices(len(self)))]
        if i < 0:
            i = self.num + i
        if i >= self.num:
            raise IndexError('linspace object index out of range')
        if i == self.num-1:
            return self.stop
        return self.start + i*self.step
    def __repr__(self):
        return '{}({}, {}, {})'.format(type(self).__name__,
                                       self.start, self.stop, self.num)
    def __eq__(self, other):
        if not isinstance(other, linspace):
            return False
        return ((self.start, self.stop, self.num) ==
                (other.start, other.stop, other.num))
    def __ne__(self, other):
        return not self==other
    def __hash__(self):
        return hash((type(self), self.start, self.stop, self.num))