Bagaimana cara menggunakan nilai langkah rentang desimal ()?

Apakah ada cara untuk melangkah antara 0 dan 1 dengan 0,1?

Saya pikir saya bisa melakukannya seperti berikut, tetapi gagal:

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

Sebaliknya, ia mengatakan bahwa argumen langkah tidak boleh nol, yang tidak saya harapkan.

Daripada menggunakan langkah desimal secara langsung, jauh lebih aman untuk mengungkapkan ini dalam hal berapa banyak poin yang Anda inginkan. Jika tidak, kesalahan pembulatan floating-point cenderung memberi Anda hasil yang salah.

Anda dapat menggunakan fungsi linspace dari pustaka NumPy (yang bukan bagian dari pustaka standar tetapi relatif mudah diperoleh). linspacemengambil sejumlah poin untuk kembali, dan juga memungkinkan Anda menentukan apakah akan menyertakan titik akhir yang tepat atau tidak:

>>> np.linspace(0,1,11)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9,  1. ])
>>> np.linspace(0,1,10,endpoint=False)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

Jika Anda benar-benar ingin menggunakan nilai langkah floating-point, Anda bisa, dengan numpy.arange.

>>> import numpy as np
>>> np.arange(0.0, 1.0, 0.1)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

Kesalahan pembulatan titik-mengambang akan menyebabkan masalah. Inilah kasus sederhana di mana kesalahan pembulatan menyebabkan arangemenghasilkan array panjang-4 ketika seharusnya hanya menghasilkan 3 angka:

>>> numpy.arange(1, 1.3, 0.1)
array([1. , 1.1, 1.2, 1.3])

Rentang Python () hanya dapat melakukan bilangan bulat, bukan titik mengambang. Dalam kasus spesifik Anda, Anda dapat menggunakan pemahaman daftar sebagai gantinya:

[x * 0.1 for x in range(0, 10)]

(Ganti panggilan untuk menjangkau dengan ekspresi itu.)

Untuk kasus yang lebih umum, Anda mungkin ingin menulis fungsi atau generator khusus.

Membangun di 'xrange ([mulai], berhenti [, langkah])' , Anda dapat menentukan generator yang menerima dan menghasilkan jenis apa pun yang Anda pilih (tetap pada jenis yang mendukung +dan <):

>>> def drange(start, stop, step):
...     r = start
...     while r < stop:
...         yield r
...         r += step
...         
>>> i0=drange(0.0, 1.0, 0.1)
>>> ["%g" % x for x in i0]
['0', '0.1', '0.2', '0.3', '0.4', '0.5', '0.6', '0.7', '0.8', '0.9', '1']
>>> 

Tingkatkan besarnya iuntuk loop dan kemudian kurangi saat Anda membutuhkannya.

for i * 100 in range(0, 100, 10):
    print i / 100.0

EDIT: Jujur saya tidak ingat mengapa saya pikir itu akan bekerja secara sintaksis

for i in range(0, 11, 1):
    print i / 10.0

Itu harus memiliki output yang diinginkan.

scipymemiliki fungsi arangebawaan yang menyamaratakan range()konstruktor Python untuk memenuhi kebutuhan penanganan float Anda.

from scipy import arange

NumPy agak berlebihan, saya pikir.

[p/10 for p in range(0, 10)]
[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

Secara umum, untuk melakukan langkah-demi- 1/xsampai yAnda akan melakukan

x=100
y=2
[p/x for p in range(0, int(x*y))]
[0.0, 0.01, 0.02, 0.03, ..., 1.97, 1.98, 1.99]

( 1/xMenghasilkan kebisingan pembulatan kurang ketika saya diuji).

Mirip dengan fungsi R seq , yang ini mengembalikan urutan dalam urutan apa pun yang diberikan nilai langkah yang benar. Nilai terakhir sama dengan nilai stop.

def seq(start, stop, step=1):
    n = int(round((stop - start)/float(step)))
    if n > 1:
        return([start + step*i for i in range(n+1)])
    elif n == 1:
        return([start])
    else:
        return([])

Hasil

seq(1, 5, 0.5)

[1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0]

seq(10, 0, -1)

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

seq(10, 0, -2)

[10, 8, 6, 4, 2, 0]

seq(1, 1)

[1]

Rentang () fungsi bawaan mengembalikan urutan nilai integer, saya khawatir, jadi Anda tidak dapat menggunakannya untuk melakukan langkah desimal.

Saya akan mengatakan cukup gunakan loop sementara:

i = 0.0
while i <= 1.0:
    print i
    i += 0.1

Jika Anda penasaran, Python mengonversi 0,1 menjadi 0, itulah sebabnya ia memberi tahu Anda bahwa argumennya tidak boleh nol.

Inilah solusi menggunakan itertools :

import itertools

def seq(start, end, step):
    if step == 0:
        raise ValueError("step must not be 0")
    sample_count = int(abs(end - start) / step)
    return itertools.islice(itertools.count(start, step), sample_count)

Contoh Penggunaan:

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

[x * 0.1 for x in range(0, 10)] 

di Python 2.7x memberi Anda hasil:

[0,0, 0,1, 0,2, 0,30000000000000004, 0,4, 0,5, 0,6000000000000001, 0,700000000000000001, 0,8, 0,9]

tetapi jika Anda menggunakan:

[ round(x * 0.1, 1) for x in range(0, 10)]

memberi Anda yang diinginkan:

[0,0, 0,1, 0,2, 0,3, 0,4, 0,5, 0,6, 0,7, 0,8, 0,9]

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

Dan jika Anda sering melakukan ini, Anda mungkin ingin menyimpan daftar yang dihasilkan r

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

more_itertoolsadalah perpustakaan pihak ketiga yang mengimplementasikan numeric_rangealat:

import more_itertools as mit


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

Keluaran

0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9

Alat ini juga berfungsi untuk Decimaldan Fraction.

Versi saya menggunakan fungsi rentang asli untuk membuat indeks multiplikasi untuk perubahan tersebut. Ini memungkinkan sintaks yang sama ke fungsi rentang asli. Saya telah membuat dua versi, satu menggunakan float, dan satu menggunakan Decimal, karena saya menemukan bahwa dalam beberapa kasus saya ingin menghindari penyimpangan pembulatan yang diperkenalkan oleh aritmatika floating point.

Ini konsisten dengan hasil set kosong seperti dalam rentang / xrange.

Melewati hanya satu nilai numerik ke salah satu fungsi akan mengembalikan output rentang standar ke nilai langit-langit integer dari parameter input (jadi jika Anda memberikannya 5,5, itu akan mengembalikan kisaran (6).)

Sunting: kode di bawah ini sekarang tersedia sebagai paket di pypi: Franges

## frange.py
from math import ceil
# find best range function available to version (2.7.x / 3.x.x)
try:
    _xrange = xrange
except NameError:
    _xrange = range

def frange(start, stop = None, step = 1):
    """frange generates a set of floating point values over the 
    range [start, stop) with step size step

    frange([start,] stop [, step ])"""

    if stop is None:
        for x in _xrange(int(ceil(start))):
            yield x
    else:
        # create a generator expression for the index values
        indices = (i for i in _xrange(0, int((stop-start)/step)))  
        # yield results
        for i in indices:
            yield start + step*i

## drange.py
import decimal
from math import ceil
# find best range function available to version (2.7.x / 3.x.x)
try:
    _xrange = xrange
except NameError:
    _xrange = range

def drange(start, stop = None, step = 1, precision = None):
    """drange generates a set of Decimal values over the
    range [start, stop) with step size step

    drange([start,] stop, [step [,precision]])"""

    if stop is None:
        for x in _xrange(int(ceil(start))):
            yield x
    else:
        # find precision
        if precision is not None:
            decimal.getcontext().prec = precision
        # convert values to decimals
        start = decimal.Decimal(start)
        stop = decimal.Decimal(stop)
        step = decimal.Decimal(step)
        # create a generator expression for the index values
        indices = (
            i for i in _xrange(
                0, 
                ((stop-start)/step).to_integral_value()
            )
        )  
        # yield results
        for i in indices:
            yield float(start + step*i)

## testranges.py
import frange
import drange
list(frange.frange(0, 2, 0.5)) # [0.0, 0.5, 1.0, 1.5]
list(drange.drange(0, 2, 0.5, precision = 6)) # [0.0, 0.5, 1.0, 1.5]
list(frange.frange(3)) # [0, 1, 2]
list(frange.frange(3.5)) # [0, 1, 2, 3]
list(frange.frange(0,10, -1)) # []

Ini adalah solusi saya untuk mendapatkan rentang dengan langkah float.
Menggunakan fungsi ini tidak perlu mengimpor numpy, atau menginstalnya.
Saya cukup yakin itu bisa ditingkatkan dan dioptimalkan. Merasa bebas untuk melakukannya dan mempostingnya di sini.

from __future__ import division
from math import log

def xfrange(start, stop, step):

    old_start = start #backup this value

    digits = int(round(log(10000, 10)))+1 #get number of digits
    magnitude = 10**digits
    stop = int(magnitude * stop) #convert from 
    step = int(magnitude * step) #0.1 to 10 (e.g.)

    if start == 0:
        start = 10**(digits-1)
    else:
        start = 10**(digits)*start

    data = []   #create array

    #calc number of iterations
    end_loop = int((stop-start)//step)
    if old_start == 0:
        end_loop += 1

    acc = start

    for i in xrange(0, end_loop):
        data.append(acc/magnitude)
        acc += step

    return data

print xfrange(1, 2.1, 0.1)
print xfrange(0, 1.1, 0.1)
print xfrange(-1, 0.1, 0.1)

Outputnya adalah:

[1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0]
[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1]
[-1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0.0]

Untuk kelengkapan butik, solusi fungsional:

def frange(a,b,s):
  return [] if s > 0 and a > b or s < 0 and a < b or s==0 else [a]+frange(a+s,b,s)

Anda dapat menggunakan fungsi ini:

def frange(start,end,step):
    return map(lambda x: x*step, range(int(start*1./step),int(end*1./step)))

Trik untuk menghindari putaran-off masalah adalah dengan menggunakan nomor yang terpisah untuk bergerak melalui jangkauan, yang dimulai dan setengah yang langkah maju dari awal .

# floating point range
def frange(a, b, stp=1.0):
  i = a+stp/2.0
  while i<b:
    yield a
    a += stp
    i += stp

Atau, numpy.arangebisa digunakan.

Itu bisa dilakukan menggunakan Numpy library. Fungsi arange () memungkinkan langkah-langkah dalam float. Tapi, ia mengembalikan array numpy yang dapat dikonversi ke daftar menggunakan tolist () untuk kenyamanan kita.

for i in np.arange(0, 1, 0.1).tolist():
   print i

Jawaban saya mirip dengan yang lain menggunakan peta (), tanpa perlu NumPy, dan tanpa menggunakan lambda (meskipun Anda bisa). Untuk mendapatkan daftar nilai float dari 0,0 hingga t_max dalam langkah-langkah dt:

def xdt(n):
    return dt*float(n)
tlist  = map(xdt, range(int(t_max/dt)+1))

Terkejut belum ada yang menyebutkan solusi yang disarankan dalam Python 3 docs :

Lihat juga:

• The linspace resep menunjukkan bagaimana menerapkan versi malas kisaran yang cocok untuk floating aplikasi point.

Setelah ditentukan, resep mudah digunakan dan tidak memerlukan numpyatau perpustakaan eksternal lainnya, tetapi fungsinya seperti numpy.linspace(). Perhatikan bahwa alih-alih stepargumen, numargumen ketiga menentukan jumlah nilai yang diinginkan, misalnya:

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

Saya mengutip versi modifikasi dari resep Python 3 lengkap dari Andrew Barnert di bawah ini:

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

Untuk mengatasi masalah presisi float, Anda dapat menggunakan Decimalmodul .

Ini menuntut upaya ekstra untuk mengubah Decimaldari intatau floatsaat menulis kode, tetapi Anda bisa meneruskan strdan memodifikasi fungsi jika memang dibutuhkan kenyamanan semacam itu.

from decimal import Decimal
from decimal import Decimal as D


def decimal_range(*args):

    zero, one = Decimal('0'), Decimal('1')

    if len(args) == 1:
        start, stop, step = zero, args[0], one
    elif len(args) == 2:
        start, stop, step = args + (one,)
    elif len(args) == 3:
        start, stop, step = args
    else:
        raise ValueError('Expected 1 or 2 arguments, got %s' % len(args))

    if not all([type(arg) == Decimal for arg in (start, stop, step)]):
        raise ValueError('Arguments must be passed as <type: Decimal>')

    # neglect bad cases
    if (start == stop) or (start > stop and step >= zero) or \
                          (start < stop and step <= zero):
        return []

    current = start
    while abs(current) < abs(stop):
        yield current
        current += step

Output sampel -

list(decimal_range(D('2')))
# [Decimal('0'), Decimal('1')]
list(decimal_range(D('2'), D('4.5')))
# [Decimal('2'), Decimal('3'), Decimal('4')]
list(decimal_range(D('2'), D('4.5'), D('0.5')))
# [Decimal('2'), Decimal('2.5'), Decimal('3.0'), Decimal('3.5'), Decimal('4.0')]
list(decimal_range(D('2'), D('4.5'), D('-0.5')))
# []
list(decimal_range(D('2'), D('-4.5'), D('-0.5')))
# [Decimal('2'),
#  Decimal('1.5'),
#  Decimal('1.0'),
#  Decimal('0.5'),
#  Decimal('0.0'),
#  Decimal('-0.5'),
#  Decimal('-1.0'),
#  Decimal('-1.5'),
#  Decimal('-2.0'),
#  Decimal('-2.5'),
#  Decimal('-3.0'),
#  Decimal('-3.5'),
#  Decimal('-4.0')]

Tambahkan koreksi otomatis untuk kemungkinan tanda yang salah pada langkah:

def frange(start,step,stop):
    step *= 2*((stop>start)^(step<0))-1
    return [start+i*step for i in range(int((stop-start)/step))]

Solusi saya:

def seq(start, stop, step=1, digit=0):
    x = float(start)
    v = []
    while x <= stop:
        v.append(round(x,digit))
        x += step
    return v

Solusi Terbaik: tidak ada kesalahan pembulatan
_________________________________________________________________________________

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

_________________________________________________________________________________

Atau, untuk rentang yang ditetapkan alih-alih mengatur titik data (misalnya fungsi berkelanjutan), gunakan:

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

Untuk mengimplementasikan fungsi: ganti x / pow(step, -1)dengan f( x / pow(step, -1) ), dan tentukan f.
Sebagai contoh:

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

start dan stop bersifat inklusif dan bukan yang satu (biasanya stop dikecualikan) dan tanpa impor, dan menggunakan generator

def rangef(start, stop, step, fround=5):
    """
    Yields sequence of numbers from start (inclusive) to stop (inclusive)
    by step (increment) with rounding set to n digits.

    :param start: start of sequence
    :param stop: end of sequence
    :param step: int or float increment (e.g. 1 or 0.001)
    :param fround: float rounding, n decimal places
    :return:
    """
    try:
        i = 0
        while stop >= start and step > 0:
            if i==0:
                yield start
            elif start >= stop:
                yield stop
            elif start < stop:
                if start == 0:
                    yield 0
                if start != 0:
                    yield start
            i += 1
            start += step
            start = round(start, fround)
        else:
            pass
    except TypeError as e:
        yield "type-error({})".format(e)
    else:
        pass


# passing
print(list(rangef(-100.0,10.0,1)))
print(list(rangef(-100,0,0.5)))
print(list(rangef(-1,1,0.2)))
print(list(rangef(-1,1,0.1)))
print(list(rangef(-1,1,0.05)))
print(list(rangef(-1,1,0.02)))
print(list(rangef(-1,1,0.01)))
print(list(rangef(-1,1,0.005)))
# failing: type-error:
print(list(rangef("1","10","1")))
print(list(rangef(1,10,"1")))

Python 3.6.2 (v3.6.2: 5fd33b5, 8 Jul 2017, 04:57:36) [MSC v.1900 64 bit (AMD64)]

Saya tahu saya terlambat ke pesta di sini, tapi inilah solusi generator sepele yang bekerja di 3.6:

def floatRange(*args):
    start, step = 0, 1
    if len(args) == 1:
        stop = args[0]
    elif len(args) == 2:
        start, stop = args[0], args[1]
    elif len(args) == 3:
        start, stop, step = args[0], args[1], args[2]
    else:
        raise TypeError("floatRange accepts 1, 2, or 3 arguments. ({0} given)".format(len(args)))
    for num in start, step, stop:
        if not isinstance(num, (int, float)):
            raise TypeError("floatRange only accepts float and integer arguments. ({0} : {1} given)".format(type(num), str(num)))
    for x in range(int((stop-start)/step)):
        yield start + (x * step)
    return

maka Anda dapat memanggilnya seperti aslinya range()... tidak ada penanganan kesalahan, tetapi beri tahu saya jika ada kesalahan yang dapat ditangkap secara wajar, dan saya akan memperbarui. atau Anda dapat memperbaruinya. ini adalah StackOverflow.

Berikut adalah solusi saya yang berfungsi baik dengan float_range (-1, 0, 0,01) dan berfungsi tanpa kesalahan representasi floating point. Ini tidak terlalu cepat, tetapi berfungsi dengan baik:

from decimal import Decimal

def get_multiplier(_from, _to, step):
    digits = []
    for number in [_from, _to, step]:
        pre = Decimal(str(number)) % 1
        digit = len(str(pre)) - 2
        digits.append(digit)
    max_digits = max(digits)
    return float(10 ** (max_digits))


def float_range(_from, _to, step, include=False):
    """Generates a range list of floating point values over the Range [start, stop]
       with step size step
       include=True - allows to include right value to if possible
       !! Works fine with floating point representation !!
    """
    mult = get_multiplier(_from, _to, step)
    # print mult
    int_from = int(round(_from * mult))
    int_to = int(round(_to * mult))
    int_step = int(round(step * mult))
    # print int_from,int_to,int_step
    if include:
        result = range(int_from, int_to + int_step, int_step)
        result = [r for r in result if r <= int_to]
    else:
        result = range(int_from, int_to, int_step)
    # print result
    float_result = [r / mult for r in result]
    return float_result


print float_range(-1, 0, 0.01,include=False)

assert float_range(1.01, 2.06, 5.05 % 1, True) ==\
[1.01, 1.06, 1.11, 1.16, 1.21, 1.26, 1.31, 1.36, 1.41, 1.46, 1.51, 1.56, 1.61, 1.66, 1.71, 1.76, 1.81, 1.86, 1.91, 1.96, 2.01, 2.06]

assert float_range(1.01, 2.06, 5.05 % 1, False)==\
[1.01, 1.06, 1.11, 1.16, 1.21, 1.26, 1.31, 1.36, 1.41, 1.46, 1.51, 1.56, 1.61, 1.66, 1.71, 1.76, 1.81, 1.86, 1.91, 1.96, 2.01]

Saya hanya pemula, tetapi saya memiliki masalah yang sama, ketika mensimulasikan beberapa perhitungan. Inilah cara saya mencoba menyelesaikannya, yang tampaknya bekerja dengan langkah desimal.

Saya juga cukup malas dan jadi saya merasa sulit untuk menulis fungsi jangkauan saya sendiri.

Pada dasarnya apa yang saya lakukan adalah mengubah xrange(0.0, 1.0, 0.01)ke saya xrange(0, 100, 1)dan menggunakan pembagian dengan 100.0di dalam loop. Saya juga khawatir, apakah akan ada kesalahan pembulatan. Jadi saya memutuskan untuk menguji, apakah ada. Sekarang saya dengar, kalau misalnya 0.01dari perhitungan tidak persis float0.01 membandingkan mereka harus mengembalikan False (jika saya salah, tolong beri tahu saya).

Jadi saya memutuskan untuk menguji apakah solusi saya akan bekerja untuk kisaran saya dengan menjalankan tes singkat:

for d100 in xrange(0, 100, 1):
    d = d100 / 100.0
    fl = float("0.00"[:4 - len(str(d100))] + str(d100))
    print d, "=", fl , d == fl

Dan itu dicetak Benar untuk masing-masing.

Sekarang, jika saya benar-benar salah, tolong beri tahu saya.

Liner satu ini tidak akan mengacaukan kode Anda. Tanda parameter langkah penting.

def frange(start, stop, step):
    return [x*step+start for x in range(0,round(abs((stop-start)/step)+0.5001),
        int((stop-start)/step<0)*-2+1)]