วิธีการใช้ค่าขั้นตอนทศนิยม ()

มีวิธีการก้าวระหว่าง 0 ถึง 1 คูณ 0.1 หรือไม่?

ฉันคิดว่าฉันสามารถทำสิ่งต่อไปนี้ได้ แต่ล้มเหลว:

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

แต่มันบอกว่าอาร์กิวเมนต์ขั้นตอนไม่สามารถเป็นศูนย์ได้ซึ่งฉันไม่ได้คาดไว้

แทนที่จะใช้ขั้นตอนทศนิยมโดยตรงมันปลอดภัยกว่าที่จะแสดงสิ่งนี้ในแง่ของจำนวนคะแนนที่คุณต้องการ มิฉะนั้นข้อผิดพลาดในการปัดเศษทศนิยมจะทำให้คุณได้ผลลัพธ์ที่ผิด

คุณสามารถใช้ฟังก์ชันlinspaceจากไลบรารีNumPy (ซึ่งไม่ได้เป็นส่วนหนึ่งของไลบรารีมาตรฐาน แต่ค่อนข้างง่ายที่จะได้รับ) linspaceใช้จำนวนจุดที่จะกลับมาและยังช่วยให้คุณระบุว่าจะรวมจุดปลายด้านขวาหรือไม่:

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

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

ข้อผิดพลาดในการปัดเศษทศนิยมจะทำให้เกิดปัญหา ต่อไปนี้เป็นกรณีง่าย ๆ ที่ข้อผิดพลาดในการปัดเศษทำให้เกิดarangeอาร์เรย์ที่มีความยาว 4 เมื่อควรสร้างตัวเลข 3 ตัวเท่านั้น

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

ช่วงไพ ธ อน () สามารถทำได้เฉพาะจำนวนเต็มไม่ใช่ทศนิยม ในกรณีเฉพาะของคุณคุณสามารถใช้ list comprehension แทน:

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

(แทนที่การโทรไปยังช่วงด้วยนิพจน์นั้น)

สำหรับกรณีทั่วไปคุณอาจต้องการเขียนฟังก์ชันหรือตัวสร้างแบบกำหนดเอง

การสร้าง'xrange ([เริ่ม] หยุด [ขั้นตอน])'คุณสามารถกำหนดเครื่องกำเนิดที่ยอมรับและสร้างประเภทใดก็ได้ที่คุณเลือก (ยึดตามประเภทที่รองรับ+และ<):

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

เพิ่มขนาดของiลูปแล้วลดลงเมื่อคุณต้องการ

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

แก้ไข: ฉันไม่สามารถจำได้ว่าทำไมฉันคิดว่ามันจะทำงาน syntactically

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

ที่ควรมีผลลัพธ์ที่ต้องการ

scipyมีฟังก์ชั่นในตัวarangeซึ่งทำให้คอนrange()สตรัคเตอร์ของงูใหญ่สามารถตอบสนองความต้องการของคุณในการจัดการโฟลตได้

from scipy import arange

ฉันคิดว่า NumPy ค่อนข้างล้นมือ

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

โดยทั่วไปแล้วให้ทำตามขั้นตอน1/xที่yคุณทำ

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/xเสียงการปัดเศษน้อยลงเมื่อฉันทดสอบ)

คล้ายกับฟังก์ชั่นของ R อัน seqนี้คืนค่าลำดับในลำดับใด ๆ ที่ให้ค่าขั้นตอนที่ถูกต้อง ค่าสุดท้ายเท่ากับค่าหยุด

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

ผล

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]

ฟังก์ชันในตัว range () ส่งคืนลำดับของค่าจำนวนเต็มฉันกลัวดังนั้นคุณไม่สามารถใช้มันเพื่อทำขั้นตอนทศนิยม

ฉันจะบอกว่าใช้สักครู่ห่วง:

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

ถ้าคุณอยากรู้อยากเห็น Python กำลังแปลง 0.1 ถึง 0 ของคุณซึ่งเป็นสาเหตุที่มันบอกคุณว่าอาร์กิวเมนต์ไม่เป็นศูนย์

นี่เป็นวิธีแก้ปัญหาโดยใช้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)

ตัวอย่างการใช้งาน:

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

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

ใน Python 2.7x ให้ผลลัพธ์ดังนี้:

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

แต่ถ้าคุณใช้:

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

ให้สิ่งที่คุณต้องการ:

[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 

และถ้าคุณทำเช่นนี้บ่อยครั้งคุณอาจต้องการบันทึกรายการที่สร้างขึ้น r

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

more_itertoolsเป็นห้องสมุดบุคคลที่สามที่ใช้numeric_rangeเครื่องมือ:

import more_itertools as mit


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

เอาท์พุต

0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9

เครื่องมือนี้ยังสามารถใช้ได้กับและDecimalFraction

เวอร์ชันของฉันใช้ฟังก์ชันช่วงดั้งเดิมเพื่อสร้างดัชนีทวีคูณสำหรับการเปลี่ยนแปลง ซึ่งอนุญาตให้ใช้ไวยากรณ์เดียวกันกับฟังก์ชันช่วงดั้งเดิม ฉันได้ทำสองรุ่นรุ่นหนึ่งใช้ float และอีกรุ่นใช้ Decimal เพราะฉันพบว่าในบางกรณีฉันต้องการหลีกเลี่ยงการปัดเศษ roundoff ที่แนะนำโดยเลขทศนิยม

มันสอดคล้องกับผลการตั้งค่าที่ว่างเปล่าเช่นเดียวกับในช่วง / xrange

การส่งเฉพาะค่าตัวเลขเดียวไปยังฟังก์ชันใดฟังก์ชันหนึ่งจะส่งคืนเอาต์พุตช่วงมาตรฐานให้กับค่าเพดานจำนวนเต็มของพารามิเตอร์อินพุต (ดังนั้นถ้าคุณให้ 5.5 มันจะส่งคืนช่วง (6))

แก้ไข: โค้ดด้านล่างนี้มีให้ใช้งานเป็นแพ็คเกจบน 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)) # []

นี่เป็นวิธีแก้ปัญหาของฉันในการหาช่วงด้วยขั้นตอนลอย
การใช้ฟังก์ชั่นนี้ไม่จำเป็นต้องนำเข้าจำนวนมากหรือติดตั้ง
ฉันค่อนข้างแน่ใจว่ามันสามารถปรับปรุงและเพิ่มประสิทธิภาพได้ รู้สึกอิสระที่จะทำและโพสต์ได้ที่นี่

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)

ผลลัพธ์คือ:

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

เพื่อความสมบูรณ์ของบูติกโซลูชันที่ใช้งานได้:

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)

คุณสามารถใช้ฟังก์ชั่นนี้:

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

เคล็ดลับเพื่อหลีกเลี่ยงการปัดเศษปัญหาคือการใช้จำนวนที่แยกต่างหากเพื่อย้ายผ่านช่วงที่เริ่มต้นและครึ่งขั้นตอนข้างหน้าของการเริ่มต้น

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

หรือnumpy.arangeสามารถใช้

มันสามารถทำได้โดยใช้ห้องสมุด Numpy ฟังก์ชั่น arange () ช่วยให้ขั้นตอนในการลอย แต่จะคืนค่าอาร์เรย์ที่สามารถแปลงเป็นรายการโดยใช้ tolist () เพื่อความสะดวกของเรา

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

คำตอบของฉันคล้ายกับคนอื่น ๆ ที่ใช้แผนที่ () โดยไม่จำเป็นต้องใช้ NumPy และไม่ต้องใช้แลมบ์ดา (แม้ว่าคุณจะทำได้) ในการรับรายการค่าทศนิยมตั้งแต่ 0.0 ถึง t_max ในขั้นตอนของ dt:

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

ไม่มีใครแปลกใจที่ได้กล่าวถึงวิธีการแก้ปัญหาที่แนะนำในเอกสาร Python 3 :

ดูสิ่งนี้ด้วย:

• linspace สูตรที่แสดงให้เห็นถึงวิธีการใช้รุ่นที่ขี้เกียจของช่วงที่เหมาะสำหรับการใช้จุดลอย

เมื่อกำหนดสูตรง่ายต่อการใช้งานและไม่จำเป็นต้องมีnumpyหรือห้องสมุดภายนอกอื่น ๆ numpy.linspace()แต่การทำงานเช่น โปรดทราบว่าแทนที่จะเป็นstepอาร์กิวเมนต์อาร์กิวเมนต์ที่สามnumระบุจำนวนค่าที่ต้องการตัวอย่างเช่น:

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

ฉันขอเสนอเวอร์ชั่นเต็มของสูตร Python 3 จาก 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))

เพื่อตอบโต้ประเด็นที่ลอยความแม่นยำ, คุณสามารถใช้โมดูลDecimal

สิ่งนี้ต้องการความพยายามพิเศษในการแปลงDecimalจากintหรือfloatขณะเขียนโค้ด แต่คุณสามารถส่งstrและปรับเปลี่ยนฟังก์ชันได้หากจำเป็นต้องใช้ความสะดวกสบายนั้น

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

ตัวอย่างผลลัพธ์ -

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

เพิ่มการแก้ไขอัตโนมัติสำหรับความเป็นไปได้ของขั้นตอนการลงชื่อที่ไม่ถูกต้อง:

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

ทางออกของฉัน:

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

ทางออกที่ดีที่สุด: ไม่มีข้อผิดพลาดในการปัดเศษ
_________________________________________________________________________________

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

_________________________________________________________________________________

หรือสำหรับชุดช่วงแทนชุดข้อมูลจุด (เช่นฟังก์ชั่นต่อเนื่อง) ใช้:

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

ที่จะใช้ฟังก์ชั่น: แทนที่x / pow(step, -1)ด้วยและกำหนดf( x / pow(step, -1) ) ตัวอย่างเช่น:f

>>> 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 และ stop นั้นถูกรวมมากกว่าหนึ่งอันหรืออื่น ๆ (โดยปกติแล้ว stop จะถูกแยกออก) และไม่มีการนำเข้าและใช้ generators

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 ก.ค. 2017, 04:57:36) [MSC v.1900 64 บิต (AMD64)]

ฉันรู้ว่าฉันมางานปาร์ตี้ที่นี่ช้า แต่นี่เป็นโซลูชันตัวสร้างตัวละครที่ทำงานใน 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

จากนั้นคุณสามารถเรียกมันเหมือนกับต้นฉบับrange()... ไม่มีการจัดการข้อผิดพลาด แต่แจ้งให้เราทราบหากมีข้อผิดพลาดที่สามารถจับได้อย่างสมเหตุสมผลและฉันจะอัปเดต หรือคุณสามารถอัปเดต นี่คือ StackOverflow

นี่คือโซลูชันของฉันที่ทำงานได้ดีกับ float_range (-1, 0, 0.01) และทำงานได้โดยไม่มีข้อผิดพลาดในการแสดงจุดลอยตัว มันไม่เร็วมาก แต่ใช้งานได้ดี:

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]

ฉันเป็นเพียงผู้เริ่มต้น แต่ฉันมีปัญหาเดียวกันเมื่อจำลองการคำนวณบางอย่าง นี่คือวิธีที่ฉันพยายามทำสิ่งนี้ซึ่งดูเหมือนว่าจะทำงานกับขั้นตอนทศนิยม

ฉันค่อนข้างขี้เกียจและดังนั้นฉันจึงพบว่ามันยากที่จะเขียนฟังก์ชันช่วงของตัวเอง

โดยพื้นฐานแล้วสิ่งที่ฉันทำคือเปลี่ยนxrange(0.0, 1.0, 0.01)เป็นxrange(0, 100, 1)และใช้การแบ่งตาม100.0ภายในลูป ฉันก็เป็นห่วงเช่นกันหากมีข้อผิดพลาดในการปัดเศษ ดังนั้นฉันจึงตัดสินใจทดสอบว่ามีหรือไม่ ตอนนี้ฉันได้ยินมาว่าหากตัวอย่าง0.01จากการคำนวณไม่ตรงกับที่ลอย0.01พวกเขาควรกลับเท็จ (ถ้าฉันผิดโปรดแจ้งให้เราทราบ)

ดังนั้นฉันตัดสินใจทดสอบว่าโซลูชันของฉันจะใช้งานได้ในช่วงของฉันหรือไม่โดยใช้การทดสอบสั้น ๆ :

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

และมันจะพิมพ์ True สำหรับแต่ละรายการ

ตอนนี้ถ้าฉันเข้าใจผิดทั้งหมดโปรดแจ้งให้ฉันทราบ

ซับในอันนี้จะไม่ถ่วงรหัสของคุณ เครื่องหมายของพารามิเตอร์ขั้นตอนมีความสำคัญ

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