numpy 相关函数

1.numpy.ndim
a,b的ndim是指数组的行数,或者说是数组第一维是多少。就是数组的维数，对于二维可以用array[x][y],三维可以用array[x][y][z].你可以想成二维的是一个灰度图像，三维的是rgb这种多通道图像

>>> d
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]], dtype=int16)
>>> e
array([[ 1.5,  2. ,  3. ],
       [ 4. ,  5. ,  6. ]])
>>> d.ndim
3
>>> e.ndim
2

>>> a
array([ 1.,  2.,  3.])
>>> b
array([[ 1.5,  2. ,  3. ],
       [ 4. ,  5. ,  6. ]])
>>> c
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])
>>> a.ndim
1
>>> b.ndim
2
>>> c.ndim
2
>>>

2.numpy.shape 返回数组维数的元组

>>> y=np.zeros((2,3,4))
>>> y.shape
(2, 3, 4)  #表示2个3维4列的数组组成
>>> y
array([[[ 0.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  0.]],

       [[ 0.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  0.]]])
>>> b=np.array([[1.5,2.,3.],[4.,5.,6.]])
>>> b.ndim
2
>>> b.shape  #返回2行3列的数组，2表示行数，3表示列数
(2, 3)
>>> b.shape[0] #返回的是几行即几维
2
>>> b.shape[1] #返回的是几列
3

3.numpy.random.seed(0)的作用
使得随机数据可预测,当我们设置相同的seed，每次生成的随机数相同。如果不设置seed，则每次会生成不同的随机数.

>>> numpy.random.seed(0)
>>> numpy.random.rand(4)
array([ 0.5488135 ,  0.71518937,  0.60276338,  0.54488318])

4.numpy.concatenate数组拼接
numpy.concatenate((a1,a2,…), axis=0)函数，能够一次完成多个数组的拼接。其中a1,a2,…是数组类型的参数。

>>> a=np.array([1,2,3])
>>> b=np.array([11,22,33])
>>> c=np.array([44,55,66])
>>> np.concatenate((a,b,c),axis=0)  # 默认情况下，axis=0可以不写
array([ 1,  2,  3, 11, 22, 33, 44, 55, 66]) #对于一维数组拼接，axis的值不影响最后的结果
>>> a=np.array([[1,2,3],[4,5,6]])
>>> b=np.array([[11,21,31],[7,8,9]])
>>> np.concatenate((a,b),axis=0)
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [11, 21, 31],
       [ 7,  8,  9]])
>>> np.concatenate((a,b),axis=1)  #axis=1表示对应行的数组进行拼接
array([[ 1,  2,  3, 11, 21, 31],
       [ 4,  5,  6,  7,  8,  9]])

对numpy.append()和numpy.concatenate()两个函数的运行时间进行比较,concatenate()效率更高，适合大规模的数据拼接

>>> from time import clock as now
>>> a=np.arange(9999)
>>> b=np.arange(9999)
>>> time1=now()
>>> c=np.append(a,b)
>>> time2=now()
>>> print time2-time1
28.2316728446
>>> a=np.arange(9999)
>>> b=np.arange(9999)
>>> time1=now()
>>> c=np.concatenate((a,b),axis=0)
>>> time2=now()
>>> print time2-time1
20.3934997107

5.numpy中的inf表示一个无限大的正数

import numpy
x =  numpy.inf
x>9999999999999999999
#返回结果为：True

6.astype改变array数组内数值的类型

#用法1：直接将原来的类型转换成现在指定的类型
numeric_strings=np.array(['1.25','-9.6','42'],dtype=np.string_)
numeric_strings=numeric_strings.astype(float) #没写np.float64,因为python类型会映射到等价的dtype上

#用法2：可直接引用另外一个变量的dtype，基要和另一个数组一样的类型则直接用该数组.dtype
int_array=np.arange(10)  #输出是：array([0,1,2,3,4,5,6,7,8,9])
calibers=np.array([.22,.270,.33],dtype=np.float64)
int_array=int_array.astype(calibers.dtype)  #将前面的int的奕成float64
#print_array的值为：array([0.,1.,2.,3.,4.,5.,6.,7.,8.,9.,])

7.切片与python代码的不同点
当你将一个标量值(一维中的都是单个词，这里标量指的就是单个值)赋值给一个切片时(如arr[5:8]=12),该值会自动传播(即”广播”)到整个选区。
与列表最重要的区别在于，numpy中的数组切片是原始数组的视图，这意味着数据不会被复制，
视图上的任何修改都会直接反映到源数组上。即映射到原来数组上

arr=np.arange(10) #输出: array([0,1,2,3,4,5,6,7,8,9])
print arr
print arr[5] #输出：5
print arr[5:8] #输出：array([5,6,7])
arr[5:8]=12
print arr  #会把前面的切片映射到原数组arr上，故此时输出结果是：array([0,1,2,3,4,12,12,12,8,9])
arr_slice=arr[5:8] #取出[5:8]的位值，即[5,6,7]，也是现在新的数组的12处
arr_slice[1]=12345 #在取出的arr_slice中取第一个数即[6]处，即新的数组的中间的12处
print arr #输出结果是：array([0,1,2,3,4,12,12345,12,8,9])
#如果你想要得到的是ndarray切片的一份副本而非视图，就需要显式地进行复制操作，例如：arr[5:8].copy().
arr[5:8].copy()
#因为Numpy设计目的是处理大数据，假如Numpy坚持要将数据复制来复制去的话会产生性能和内存的问题

8.多维数组中元素索引
多维数组取某个元素值

arr2d=np.array([1,2,3],[4,5,6],[7,8,9])
print arr2d[2]  #返回的值：array([7,8,9])
#若要取每个列表中的单个值，可以用逗号隔开的索引列表来选择单个元素

#下面两种方法是一样的
#方法1：有点像python中先按元组的方法取出单个列表，再用列表的方法取出值
print arr2d[0][2] #输出结果：3
#方法2：直接用逗号隔开的索引列表来选取
print arr2d[0,2] #输出结果：3

多维数组元素索引

#下面是2X2X3的数组，即2个2维3列的数组
arr3d=np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
print arr3d
#输出的结果如下
 [[[ 1  2  3]
   [ 4  5  6]] 
  [[ 7  8  9]
   [10 11 12]]]

#取出arr3d[0]
print arr3d[0] #结果：取出第一个数组:[[1,2,3],[4,5,6]]

标量值和数组都可以被赋值

old_values=arr3d[0].copy() #old_values就是上面arr3d[0]的值
arr3d[0]=42  #arr3d[0]的数组的值都为42
print arr3d
#输出结果如下
# [[[42 42 42]
#   [42 42 42]]
#
#  [[ 7  8  9]
#   [10 11 12]]]
arr3d[0]=old_values #old_values的值赋值给arr3d[0]中
print arr3d
#输出结果如下：
# [[[ 1  2  3]
#   [ 4  5  6]]
#
#  [[ 7  8  9]
#   [10 11 12]]]

以此类推，arr3d[1,0]可以访问索引以(1,0)开头的那些值(以一维数组的形式返回)：
print arr3d[1,0]
返回的结果是：array([7,8,9])

9.多维数组中切片索引

arr2d=np.array([[1,2,3],[4,5,6],[7,8,9]])
print arr2d
print arr2d[:2] #输出结果是：array([[1,2,3],[4,5,6]])
print arr2d[:2,1:] #在前面取出的arr2d[:2]的基础上再取各个数组的从1：开始
#输出结果
# [[2 3]
#  [5 6]]
print arr2d[1,:2] #先取出1的数组(从0开始的)，即[4,5,6],再：2是取从头取到第2个，但不包括位置为2的值，即[4,5]
#输出结果为：
# array[4 5]
print arr2d[2,:1] #如上，得到的结果是：array([7])

注意：“只有冒号”表示选取整个轴，如下

print arr2d[:,:1] #第一个：表示所有轴都选中，第2个:1是取每个数组的第一个值
#输出结果是：
[[1]
 [4]
 [7]]

对切片表达式的赋值操作也会被扩散到整个选区：

arr2d[:2,1:]=0 #先取位置为0:2不包括2的位置的数组即[[1,2,3],[4,5,6]],
# 后面的1：是从位置为1开始一直取到结束即[8,9]位置都赋0
print arr2d
#输出结果如下：
[[1 0 0]
 [4 0 0]
 [7 8 9]]

10.布尔索引

names=np.array(['Bob','Joe','Will','Bob','Will','Joe','Joe'])
data=np.random.rand(7,4) #随行生成7行4列的数组
print data
print names
print names=='Bob' #输出的结果是：[ True False False  True False False False]

print data[names=='Bob'] #因为names=='Bob'为True有两个，则生成2行4列的随机数组

print names!='Bob' #输出结果是：[False  True  True False  True  True  True]
print data[(names!='Bob')]  ##因为names!='Bob'有5个为True的，则生成5行4列的随机数组
#使用算术运算符：&，|
mask=(names=='Bob') | (names=='Will') #[ True False  True  True  True False False]

print mask
print data[mask]  #因为mask为True的有4个，则生成4行4列的数组

布尔型数组和切片混合使用
print data[names=='Bob',2:] #data[names=='Bob']中每个数组中取2:位置开始到最后的元素
# data[names=='Bob']的结果是：
# [[ 0.90203958  0.02821906  0.30351464  0.33156672]
#  [ 0.60263345  0.97656289  0.58361359  0.06398002]]
#然后data[names=='Bob',2:]之后的结果是：
# [[ 0.30351464  0.33156672]
#  [ 0.58361359  0.06398002]]
print data[names=='Bob',3]  #data[names=='Bob']中每个数组中取3这个位置的数
#输出的结果是：
# [ 0.33156672  0.06398002]

通过布尔型索引选取数组中的数据，将总是创建数据的副本，即使返回一模一样的数组也是如此。
通过布尔型数组设置值是一种经常用到的手段。如将data中的所有负值都设置为0，我们只需如下：

data[data<0]=0
print data

通过一维布尔数组设置整行或列的值也很简单：

data[names!='Joe']=7 #不是Joe的为True,有多少个True就总共该data数组有
#少行，将为True的这一行的值都为7
print data
#返回的结果如下：
[[ 7.          7.          7.          7.        ]
 [ 0.11834433  0.25350225  0.45062154  0.1694289 ]
 [ 7.          7.          7.          7.        ]
 [ 7.          7.          7.          7.        ]
 [ 7.          7.          7.          7.        ]
 [ 0.7159481   0.70406219  0.50870176  0.8419536 ]
 [ 0.97546717  0.36981413  0.35265204  0.88268987]]

11.花式索引
它指的是利用整数数组进行索引

arr=np.empty((8,4))
for i in range(8):
    arr[i]=i #arr[i]是指的行，arr[1]是指的第一行
print arr
#输出结果如下：
# [[ 0.  0.  0.  0.]
#  [ 1.  1.  1.  1.]
#  [ 2.  2.  2.  2.]
#  [ 3.  3.  3.  3.]
#  [ 4.  4.  4.  4.]
#  [ 5.  5.  5.  5.]
#  [ 6.  6.  6.  6.]
#  [ 7.  7.  7.  7.]]
#为了以特定顺序选取子集，只需传入一个用于指定顺序的整数列或ndarray即可
print arr[[4,3,0,6]] #取arr中4的位置的行，切片为正数时则从下标0开始，
# 但是负数是从最后开始倒数第几个，这个时间没有0哦，例如-2，那就是倒数第2行
#输出的结果如下：
# [[ 4.  4.  4.  4.]
#  [ 3.  3.  3.  3.]
#  [ 0.  0.  0.  0.]
#  [ 6.  6.  6.  6.]]

负数索引，从尾部开始

print arr[[-3,-5,-7]]
#输出的结果如下：
# [[ 5.  5.  5.  5.]
#  [ 3.  3.  3.  3.]
#  [ 1.  1.  1.  1.]]

一次传入多个索引数组会有一点特别，它返回的是一个一维数组，其中的元素对应各个索引元组

arr=np.arange(32).reshape((8,4)) #arange(32)即32个数(从0-31)，数组的shape是8行4列
print arr
#返回结果如下：
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]
#  [12 13 14 15]
#  [16 17 18 19]
#  [20 21 22 23]
#  [24 25 26 27]
#  [28 29 30 31]]
print arr[[1,5,7,2],[0,3,1,2]] #第一个数组是取出的行，例1表示下标为1的行取出(下标是从0开始)，则取出的是[4  5  6  7]
#第二个数组是在前面取出的行的行几个元素，上面是1行对应的是0下标元素，由取第1行的第一个元素，即4，所以第一个数是4，
#依此类推，最终选出的元素是(1,0),(5,3),(7,1),(2,2).第2个数是：下标为5的行位置为3的元素，即23.
#输出的结果如下：
# [ 4 23 29 10]

要得到多维数组则要[:, ]将整行取出

print arr[[1,5,7,2]][:,[0,3,1,2]] #先取出[1,5,7,2]行，再[:,]取一整行，[0,3,1,2]是一整行元素的取值，先
#取的是0元素，再取3(该行的第4个元素)，再取1(第2个元素)，最后取2(第3个元素)
#输出的结果如下：
# [[ 4  7  5  6]
#  [20 23 21 22]
#  [28 31 29 30]
#  [ 8 11  9 10]]

花式索引跟切片不一样，它总是将数据复制到新数组中。

12.数组转置和轴对换
transpose方法

arr=np.arange(15).reshape((3,5))
print arr
#输出结果如下：
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10 11 12 13 14]]
print arr.T
#输出结果如下：
# [[ 0  5 10]
#  [ 1  6 11]
#  [ 2  7 12]
#  [ 3  8 13]
#  [ 4  9 14]]
#在进行矩阵计算时，经常会用到该操作，比如利用np.dot计算矩阵内积XTX.
arr=np.random.rand(6,3)
print np.dot(arr.T,arr)

arr=np.arange(16).reshape((2,2,4)) #reshape(2,2,4)指2个2维4列的数组
print arr
#输出的结果如下：
# [[[ 0  1  2  3]
#   [ 4  5  6  7]]
#
#  [[ 8  9 10 11]
#   [12 13 14 15]]]

ndarray还有一个swapaxes方法,它需要接受一对辆编号

print arr.swapaxes(1,2)
#输到结果如下：
# [[[ 0  4]
#   [ 1  5]
#   [ 2  6]
#   [ 3  7]]
#
#  [[ 8 12]
#   [ 9 13]
#   [10 14]
#   [11 15]]]

13.快速的元素级数组函数

#例如：sqrt,exp等一元的
arr=np.arange(10)
print np.sqrt(arr) #开方
print np.exp(arr)

#add,max接受两个数组的，叫二元，并返回一个结果数组
x=random.rand(8)
y=random.rand(8)
print x
print y
print np.maximum(x,y) #元素级最大值，取x,y各对应的比较。如x[0]和y[0]比较，哪个大就放在np.maximum(x,y)生成新的数组中

arr=random.rand(7)*5
print np.modf(arr)

一元是针对数组里的各个元素，二元是针对两个数组中各对应的元素
(如：x(1)-y(1),即相同位置的值进行操作)
一元的ufunc函数：

abs,fabs    绝对值，对于非复数值，可以使用更快的fabs
sqrt        平方根
square      平方
exp         指数
log         对数
sign        各元素的正负号：1(正)，0(零)，-1(负数)
ceil        >=该值的最小整数
floor       <=该值的最大整数
rint        四舍五入到最接近的整数，保留dtype
modf        将数组的小数和整数部分以两个独立数组的形式返回
isnan       返回一个表示“哪些值是NaN(这不是一个数字)”的布尔型数组
isfinite/isinf   分别返回一个表示“哪些元素是有穷的(非inf,非NaN)”或“哪些元素是无穷的”的布尔型数组
cos,cosh,sin,sinh,tan,tanh                          三角函数
arccos,arccosh,arcsin，arcsinh,arctan,arctanh        反三角函数
logical_not     计算各元素not x的真值。相当于-arr

二元的ufunc函数：需要两个数组的

add         相加
subtract    第一个数组减第二个数组
multiply    各元素相乘
divide,floor_divide    除法或向下圆整除法(丢弃余数)
power       对第一个数组中的元素A,根据第二个数组中的相应元素B,计算A的B次方
maximum,fmaxt  元素级的最大值计算，fmax将忽略NaN
mimimum,fmin    元素级的最小值计算，fmin将忽略NaN
mod         元素级的求模计算（除法的余数）
copysign    将第二个数组中的值的符号复制给第一个数组中的值
greater,greater_equal,less,less_equal,equal,not_equal   >,>=,<,<=,==,!=
logical_and,logical_or,logical_xor  &,|,^(即与，或，非)

14.利用数组进行数据处理
where的用法

import numpy as np
from numpy import random
import matplotlib.pyplot as plt

points=np.arange(-5,5,0.01)
xs,ys=np.meshgrid(points,points)
print ys
z=np.sqrt(xs**2+ys**2)
print z
plt.imshow(z,cmap=plt.cm.gray);plt.colorbar()
plt.title("Image plot of $\sqrt{x^2+y^2}$ for a grid of values")

xarr=np.array([1.1,1.2,1.3,1.4,1.5])
yarr=np.array([2.1,2.2,2.3,2.4,2.5])
cond=np.array([True,False,True,True,False])

result=[(x if c else y) for x,y,c in zip(xarr,yarr,cond)]
print result

#上面的纯python用在大数据处理速度太慢，而且无法用于多维数组中
# 而改成numpy的where就能解决
result=np.where(cond,xarr,yarr) #where第一个值是条件，即cond为True，则返回xarr,否则返回yarr
print result

在数据分析工作中，where通常用于根据另一个数组而产生一个新的数组。
（1）np.where的第二个和第三个参数不必是数组，它们都可以是标量值(即单个数值)。
（2）传递给where的数组大小可以不相等，甚至可以是标量值
例：设一个由随机数据组成的矩阵，将所有正值规制为2，将所有负值替换为-2.用where

arr=random.randn(4,4)
print arr
arr_new=np.where(arr>0,2,-2)
print arr_new
print np.where(arr>0,2,arr) #只将正值设置为2，因为当arr>0为假时，则还是传arr原来的值

例2：两个布尔型cond1和cond2,希望根据4种不同的布尔值组合实现不同的赋值操作

result=[]
for i in range(n):
    if cond1[i] and cond2[i]:
        result.append(0)
    elif cond1[i]:
        result.append(1)
    elif cond2[i]:
        result.append(2)
    else:
        result.append(3)
# 这个for循环确实可以改成一个嵌套的where表达式
np.where(cond1&cond2,0,
         np.where(cond1,1,
                  np.where(cond2,2,3)))
#在上面的例子中，我们还可以利用"布尒值在计算过程中可以被当作0或1处理"
result=1*(cond1-cond2)+2*(cond2&-cond1)+3*-(cond1|cond2)

15.数学和统计方法
可以对数组上的一组数学函数对整个数组或某个轴向的数据进行统计计算 ,
如sum,mean(求均值),std(标准差)等聚合计算 .

arr=np.random.randn(5,4) #randn正态分布的数据
print arr.mean()
print np.mean(arr)
print arr.sum()

mean和sum这类的函数可以接受一个axis参数，用于计算该轴向上的统计值

print arr.mean(axis=1)
print arr.sum(0)

cumsum和cumprod之类的方法则不聚合，而是产生一个由中间结果组成的数组

arr=np.array([[0,1,2],[3,4,5],[6,7,8]])
print arr
#输出结果
# [[0 1 2]
#  [3 4 5]
#  [6 7 8]]
print arr.mean(axis=1) #axis=1是行，每一行求均值
#输出结果：[ 1.  4.  7.]
print arr.mean(axis=0) #axis=0是列，每一列求平均值
#输出结果：[ 3.  4.  5.]
print arr.mean(axis=2) #axis=2报错，报out of range

print arr.cumsum(0) #0是列，即每一列累积和
#输出结果：
# [[ 0  1  2]
#  [ 3  5  7]
#  [ 9 12 15]]
print arr.cumprod(1) #1是行，即每一行累计积
#输出结果
# [[  0   0   0]
#  [  3  12  60]
#  [  6  42 336]]

基本数组统计方法

sum     对数组全部或某轴向的元素求和
mean    算术平均数
std,var     标准差和方差
min,max     最大值和最小值
argmin,argmax   分别为最大和最小元素的索引
cumsum      所有元素的累计和
cumprod     所有元素的累计积

16.用于布尔型数组的方法
布尔值会被强制转换为1(True)和0(False).sum被用来对布尔型数组中的True值计数.
主要有sum,any,all的方法.
any用于测试数组中是否存在一个或多个True.
all则检查数组中所有值是否都是True.

arr=random.randn(100)
print (arr>0).sum() #正值的个数，因为arr>0为True时是1，再sum()是对1的数求和，
# 多少个1相加，就有多少个arr>0的数
bools=np.array([False,False,True,False])
print bools.any() #检测bools中是否有True的
print bools.all() #检测bools中的值是否都是True

any,all这两个方法也能用于非布尔型数组，所有非0元素将会被当做True.

17.排序、唯一化及Numpy中数组集合逻辑

#排序
#与python内置的列表类型一样，Numpuy
arr=random.randn(8)
print arr
print arr.sort()

arr=random.randn(5,3)
print arr
arr.sort(1)
print arr

唯一化以及其它的集合逻辑

names=np.array(['Bob','Joe','Will','Bob','Will','Joe','Joe'])
print np.unique(names)
ints=np.array([3,3,3,2,2,1,1,4,4])

print np.unique(ints)
#用np.unique等价的纯python代码来对比一下：
print sorted(set(names))
#输出结果如下：
['Bob' 'Joe' 'Will']

#np.in1d用于测试一个数组中的值在另一个数组中的成员，返回一个布尔型数组。
values=np.array([6,0,0,3,2,5,6])
print np.in1d(values,[2,3,6])
#输出结果如下：
[ True False False  True  True False  True]

Numpy中数组的集合运算

unique(x)       计算x中的唯一元素，并返回有序结果
intersect1d(x,y)  计算x和y中的公共元素，并返回有序结果
union1d(x,y)     计算x和y的并集，并返回有序结果
in1d(x,y)        得到一个表示“x的元素是否包含于y”的布尔型数组
setdiff1d(x,y)    集合的差，即元素在x中且不在y中
setxor1d(x,y)     集合的对称差，即存在于一个数组中但不同时存在于两个数组中的元素

18.用于数组的文件的输入和输出
数组以二进制格式保存到磁盘
（1）np.save和np.load是读写磁盘数组数据的两个主要函数。np.save是保存即写入到磁盘，np.load是读取磁盘上的数组
（2）np.savez可以将多个数组保存到一个压缩文件中，将数组以关键字参数的形式传入即可。它的扩展名为.npz
（3）np.loadtxt或者np.genfromtxt将数据加载到普通的Numpy数组中（操作的是txt文件）
（4）np.savetxt是将数组保存到txt文件中
（5）它是以二进制写入的，故直接用text打开是乱码
（6）默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为.npy的文件中的。

arr=np.arange(10)
print arr
np.save('some_array',arr) #文件路径末尾没有扩展名.npy,则该扩展名会被自动加上。
print np.load('some_array.npy')
#np.savez可以将多个数组保存到一个压缩文件中，将数组以关键字参数的形式传入即可。它的扩展名为.npz
np.savez('array_archive.npz',a=arr,b=arr)
#读取/加载npz文件，会得到一个类似字典的对象，该对象会对各个数组进行延时加载
arch=np.load('array_archive.npz')
print arch['b'] #结果是：[0 1 2 3 4 5 6 7 8 9]

#存取文本文件
#python中的文件读写函数的格式很容易将手搞晕，所以我们将介绍pandas中的read_csv和read_table函数，
#有时我们需要用np.loadtxt或者np.genfromtxt将数据加载到普通的Numpy数组中。
arr=np.loadtxt('/Users/mac/PycharmProjects/python2.7/BigData/Digital-Signage/submit_Digital/array_ex.txt',delimiter=',')
#array_ex.txt中的内容如下
# 0.580052,0.186730,1.040717,1.134411
# 0.194163,-0.636917,-0.938659,0.124094
# -0.126410,0.268607,-0.695724,0.047428
# -1.484413,0.004176,-0.744203,0.005487
# 2.302869,0.200131,1.670238,-1.881090
# -0.193230,1.047233,0.482803,0.960334
print arr #按分隔符取出后如下
# [[ 0.580052  0.18673   1.040717  1.134411]
#  [ 0.194163 -0.636917 -0.938659  0.124094]
#  [-0.12641   0.268607 -0.695724  0.047428]
#  [-1.484413  0.004176 -0.744203  0.005487]
#  [ 2.302869  0.200131  1.670238 -1.88109 ]
#  [-0.19323   1.047233  0.482803  0.960334]]

#np.savetxt执行的是相反的操作，将数组写到以某种分隔符隔开的文本文件中。
arr1=np.array([[ 0.580052,0.18673,1.040717,1.134411],
 [ 0.194163,-0.636917,-0.938659,0.124094],
 [-0.12641,0.268607,-0.695724,0.047428],
 [-1.484413,0.004176,-0.744203,0.005487],
 [ 2.302869,0.200131,1.670238,-1.88109 ],
 [-0.19323,1.047233,0.482803,0.960334]])
np.savetxt('new_array.txt',arr)
#用loadtxt读取，genfromtxt和loadtxt差不多，只不过它面向的是结构化数组和缺失数据处理。
a=np.loadtxt('new_array.txt')
print a