np.arange()

函数返回一个有终点和起点的固定步长的排列，如[1,2,3,4,5]，起点是1，终点是6，步长为1。

参数个数情况： np.arange()函数分为一个参数，两个参数，三个参数三种情况

1）一个参数时，参数值为终点，起点取默认值0，步长取默认值1。

2）两个参数时，第一个参数为起点，第二个参数为终点，步长取默认值1。

3）三个参数时，第一个参数为起点，第二个参数为终点，第三个参数为步长。其中步长支持小数
#一个参数 默认起点0，步长为1 输出：[0 1 2]
a = np.arange(3)

#两个参数 默认步长为1 输出[3 4 5 6 7 8]
a = np.arange(3,9)

#三个参数 起点为0，终点为3，步长为0.1 输出[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1.   1.1  1.2  1.3  1.4 1.5  1.6  1.7  1.8  1.9  2.   2.1  2.2  2.3  2.4  2.5  2.6  2.7  2.8  2.9]
a = np.arange(0, 3, 0.1)

range()返回的是range object，而np.arange()返回的是numpy.ndarray（type(np.arange(10)) == np.ndarray）
两者都是均匀地（evenly）等分区间；
range尽可用于迭代，而np.arange作用远不止于此，它是一个序列，可被当做向量使用。


range()不支持步长为小数，np.arange()支持步长为小数


两者都可用于迭代


两者都有三个参数，以第一个参数为起点，第三个参数为步长，截止到第二个参数之前的不包括第二个参数的数据序列

某种意义上，和STL中由迭代器组成的区间是一样的，即左闭右开的区间。[first, last)或者不加严谨地写作[first:step:last)

>>>range(1,5)
range(1,5)
>>>tuple(range(1, 5))
(1, 2, 3, 4)
>>>list(range(1, 5))
[1, 2, 3, 4]


>>>r = range(1, 5)
>>>type(r)
<class 'range'>

>>>for  i in range(1, 5):
...    print(i)
1
2
3
4

>>> np.arange(1, 5)
array([1, 2, 3, 4])

>>>range(1, 5, .1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer

>>>np.arange(1, 5, .5)
array([ 1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5])

>>>range(1, 5, 2)
>>>for i in range(1, 5, 2):
...    print(i)
1
3

>>for i in np.arange(1, 5):
...    print(i)
1
2
3
4
 

这是一个小坑，

torch.range 已经被弃用了/
torch.range(0,5)
__main__:1: UserWarning: torch.range is deprecated in favor of torch.arange and will be removed in 0.5. Note that arange generates values in [start; end), not [start; end].
tensor([0., 1., 2., 3., 4., 5.])

因为不符合直接，真是左闭右闭的区间。而且是float。
torch.arange(0,5)
tensor([0, 1, 2, 3, 4])

range返回从0到4的5个数构成的list，而arange返回一个array对象。不过他们的元素都是一样的。

迭代对象nditer提供了一种灵活访问一个或者多个数组的方式。
单个数组的迭代（Single Array Iteration）
迭代器最基本的任务的可以完成对数组元素的访问，迭代器接口可以一个接一个地提供的每一个元素。
例如：
a = np.arange(6).reshape(2, 3)
for x in np.nditer(a):
    print x, " "
0  1  2  3  4  5  

对于这种迭代方式需要注意的是：所选择的顺序是和数组内存布局一致的，而不是使用标准C或者Fortran顺序。这是为了使用效率而设计的，这反映了默认情况下只需访问每个元素，而无需考虑其特定顺序。我们可以通过迭代上述数组的转置来看到这一点，并与以C顺序访问数组转置的copy的方式做对比，有：
a = np.arange(6).reshape(2, 3)
for x in np.nditer(a.T):
    print x,
print "\n"
for x in np.nditer(a.T.copy(order = 'C')):
    print x, 
 
0 1 2 3 4 5 
 
0 3 1 4 2 5

从上述例子可以看出，a和a.T的遍历顺序是一样的，也就是他们在内存中的存储顺序也是一样的，但是a.T.copy(order = ‘C’)的遍历结果是不同的，那是因为它和前两种的存储方式是不一样的。默认是按行访问。
控制迭代顺序（Controlling Iteration Order）

有时候，无论元素在内存中的分布如何，重要的是要以特定的顺序来访问数组。所以nditer提供了一种顺序参数（order parameter ）的方法来实现这一要求。默认情况下是order = ‘K’， 就是上述的访问方式。另外有：order = 'C’和order = ‘F’。不妨理解为：C是按行访问，F是按列访问。
a = np.arange(6).reshape(2, 3)
for x in np.nditer(a, order = 'F'):
    print x,
print "\n"
for x in np.nditer(a.T, order = 'C'):
    print x, 
 
0 3 1 4 2 5 
 
0 3 1 4 2 5

修改数组值（Modify Array Values）

默认情况下，nditer将输入数组视为只读对象。要修改数组元素，必须指定读写（ read-write）或只写（write-only）模式。这是由每个操作数标志控制的。一般而言，Python中的赋值只需更改本地或全局变量字典中的引用，而不是修改现有变量。

a = np.arange(6).reshape(2, 3)

print a
for x in np.nditer(a, op_flags = ['readwrite']):
    x[...] = 2*x
 
print a
 
[[0 1 2]
 [3 4 5]]
[[ 0  2  4]
 [ 6  8 10]]

原文链接：https://blog.csdn.net/Hearthougan/article/details/71281040