For Python 3.3+ code, usecollections.abc.Sequence instead ofcollections.Sequence.

There are two obvious simple algorithms forlinspace (plus some more advanced ones):

• division first:start + i*(stop-start)/(num-1)
• multiplication first:(stop*i + start*(num-i-1))/(num-1)

This recipe uses the former, primarily because it's the oneused by NumPy.

Both are simple and fast; neither accumulates errors (both will close to the minimum possible number of 1 ulp errors distributed evenly throughout the range, which is as good as you can hope for with floats); but neither is perfect:

• Division first underflows denormal numbers to0. (SeeNumPy bug #5437)
• Multiplication first overflows very large numbers toinf.
• Multiplication first doesn't match NumPy's results.
• Division first errors show up worse in a few highly visible cases (e.g.,linspace(0, 1, 11)[3] == 0.30000000000000004).
• Multiplication first requires types that can be multiplied and divided by integers, so it will not work with, e.g.,datetime. (Note that division first only multiplies and divides _differences_ between values—so, withdatetime,timedeltas.)

For many lazy sequences, a slice should return an instance of the same sequence. This is how the builtinrange works, for instance. However, floating point rounding makes that impossible forlinspace; a slice could at best guarantee a sequence whose values are within 2 ulp of the original values. So, a slice instead returns a list.

Inheriting fromSequence means thatlinspace provides__contains__,index, andcount methods, using the default (linear-search) implementation. It's generally a bad idea to use these (for the same reason it's a bad idea to compare floats with==), but not providing them would meanlinspace is no longer aSequence. Of course anO(1) implementation could be provided pretty easily, but that would just encourage (mis)use.