numpy中matrix类型与array类型的转换
如何让
M = matrix([[1], [2], [3], [4]])
如何转变为
array([1, 2, 3, 4])
比较优雅的办法：
x=matrix(arange(12).reshape((3,4)))
>>> x
matrix([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> x.getA1()
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> x.getA()
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
注意getA函数与getA1函数的区别
python内置array模块
这个模块定义了一个对象类型，用以表示一些基础变量构成的列表，包括字符，整数，浮点数，Array是序列类型，使用起来与list十分接近，但是存储的变量类型只能是一种，所以方便高效的数值运算。可以使用type code在创建array时指定内部变量的类型，type code定义如下表：
| Type code |
C Type |
Python Type |
Minimum size in bytes |
Notes |
| ‘b’ |
signed char |
int |
1 |
|
| ‘B’ |
unsigned char |
int |
1 |
|
| ‘u’ |
Py_UNICODE |
Unicode character |
2 |
(1) |
| ‘h’ |
signed short |
int |
2 |
|
| ‘H’ |
unsigned short |
int |
2 |
|
| ‘i’ |
signed int |
int |
2 |
|
| ‘I’ |
unsigned int |
int |
2 |
|
| ‘l’ |
signed long |
int |
4 |
|
| ‘L’ |
unsigned long |
int |
4 |
|
| ‘q’ |
signed long long |
int |
8 |
(2) |
| ‘Q’ |
unsigned long long |
int |
8 |
(2) |
| ‘f’ |
float |
float |
4 |
|
| ‘d’ |
double |
float |
8 |
|
注意：
1.u类型长度与平台有关，有可能16bits或32bits，此类型将会在python4.0中被移除
2.q或Q类型只能在C编译器支持long long类型中使用
此模块定义了如下类型：
class array.array(typecode[, initializer])
typecode限制了array的类型，initializer为可选项，终于初始化，这个参数必须是一个列表，一个类似于字节的对象，或者对适当类型的元素进行迭代的迭代器。
如果给定一个列表或字符串，那么初始化器就会被传递给新的数组的fromlist()、frombytes()或fromunicode()方法(见下面)，并将初始项添加到数组中。否则，迭代初始化器将被传递给扩展()方法。
具有添加删除切片等方法，详见：
python之array模块
numpy中的array
更清晰的一些教程：
NumPy的详细教程–作者：chesian
更为亲民一些的内置函数整理：
numpy中常用的一些内置函数：
创建：
array的创建：参数既可以是list，也可以是元组.使用对应的属性shape直接得到形状
a=np.array((1,2,3,4,5))# 参数是元组
b=np.array([6,7,8,9,0])# 参数是list
c=np.array([[1,2,3],[4,5,6]])# 参数二维数组
print a,b,
c.shape()
也可以直接改变属性array的形状，-1代表的是自己推算。这里并不是T, reshape(())也可以
c = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])
c.shape # (3L, 4L)
c.shape=4,-1 //c.reshape((2,-1))
c
<pre style="box-sizing: border-box; overflow: auto; font-size: 14px; padding: 0px; margin-top: 0px; margin-bottom: 0px; line-height: 17.0001px; word-break: break-all; word-wrap: break-word; border: 0px; border-radius: 0px; white-space: pre-wrap; vertical-align: baseline; background-color: rgb(255, 255, 255);">array([[ 1, 2, 3],
[ 4, 4, 5],
[ 6, 7, 7],
[ 8, 9, 10]])
这里的reshape最终相当于是一个浅拷贝，也就是说还是和原来的数据使用相同的内存空间
d=c.reshape((2,-1))
d[1:2]=100
c
array([[ 1, 2, 3],
[ 4, 4, 5],
[100, 100, 100],
[100, 100, 100]])
前面在创建数组的时候并没有使用数据类型，这里我们也可以使用数据类型。默认的是int32.
a1=np.array([[1,2,3],[4,5,6]],dtype=np.float64)
print a1.dtype,a.dtype #float64 int32<pre style="margin-top: 0px; margin-bottom: 0px; line-height: 17.0001px; box-sizing: border-box; overflow: auto; font-size: 14px; padding: 0px; word-break: break-all; word-wrap: break-word; border: 0px; border-radius: 0px; white-space: pre-wrap; vertical-align: baseline; background-color: rgb(255, 255, 255);">
前面在创建的时候我们都是使用的np.array()方法从tuple或者list转换成为array，感觉很是费劲，numpy自己提供了很多的方法让我们自己直接创建一个array.
arr1=np.arange(1,10,1) #
arr2=np.linspace(1,10,10)
print arr1,arr1.dtype
print arr2,arr2.dtype
[1 2 3 4 5 6 7 8 9] int32
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.] float64
np.arange(a,b,c)表示产生从a-b不包括b，间隔为c的一个array，数据类型默认是int32。但是linspace(a,b,c)表示的是把a-b平均分成c分，它包括b。
有时候我们需要对于每一个元素的坐标进行赋予不同的数值，可以使用fromfunction函数
def fun(i):
return i%4+2
np.fromfunction(fun,(10,))
array([ 2., 3., 4., 5., 2., 3., 4., 5., 2., 3.])
fromfunction必须支持多维数组，所以他的第二个参数必须是一个tuple，只能是(10,),(10)是错误的。
def fun2(i,j):
return (i+1)*(j+1)
np.fromfunction(fun2,(9,9))
array([[ 1., 2., 3., 4., 5., 6., 7., 8., 9.],
[ 2., 4., 6., 8., 10., 12., 14., 16., 18.],
[ 3., 6., 9., 12., 15., 18., 21., 24., 27.],
[ 4., 8., 12., 16., 20., 24., 28., 32., 36.],
[ 5., 10., 15., 20., 25., 30., 35., 40., 45.],
[ 6., 12., 18., 24., 30., 36., 42., 48., 54.],
[ 7., 14., 21., 28., 35., 42., 49., 56., 63.],
[ 8., 16., 24., 32., 40., 48., 56., 64., 72.],
[ 9., 18., 27., 36., 45., 54., 63., 72., 81.]])
虽然说，这里提供了很多的直接产生array的方式，但是大部分情况我们都是会从list进行转换，因为在实际的处理中，我们需要从txt加载文件，那样直接读入的数据显示存放到list中，需要处理的时候我们转换到array,因为
array的设计更加符合我们的使用，涉及到矩阵的运算在使用mat，那么list主要就是用进行元素的索取。
def loaddataSet(fileName):
file=open(fileName)
dataMat=[] //
for line in file.readlines():
curLine=line.strip().split('\t')
floatLine=map(float,curLine)//这里使用的是map函数直接把数据转化成为float类型
dataMat.append(floatLine)
return dataMat
上面的函数返回最终的数据就是最初的list数据集，再根据不同的处理需求是转化到array还是mat。其实array是mat的父类，能用mat的地方，array理论上都能传入。
元素访问：
arr[5] #5
arr[3:5] #array([3, 4])
arr[:5] #array([0, 1, 2, 3, 4])
arr[:-1]# array([0, 1, 2, 3, 4, 5, 6, 7, 8])
arr[:] #array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
arr[2:4]=100 # array([ 0, 1, 100, 100, 4, 5, 6, 7, 8, 9])
arr[1:-1:2] #array([ 1, 100, 5, 7]) 2 是间隔
arr[::-1] #array([ 9, 8, 7, 6, 5, 4, 100, 100, 1, 0])
arr[5:2:-1]# -1的间隔表示从右向左所以5>2 #array([ 5, 4, 100])
上面是array的一维数组的访问方式，我们再来看看二维的处理方式
print c[1:2]# c[1:2].shape-->(1L, 3L)
print c[1:2][0] # shape-->(3L,)
[[4 4 5]]
[4 4 5]
print c[1]
print c[1:2]
[4 4 5]
[[4 4 5]]
print c[1][2]
print c[1:4]
print c[1:4][0][2]
5
[[ 4 4 5]
[100 100 100]
[100 100 100]]
5
可以看出对于有:的表达最终的结果外面还嵌套一层list的[]，。访问的一定要注意，python最bug的就是，语法灵活，不管怎样写索引语法都是正确的，但是最终的结果却让你大跌眼镜。
还有array的索引最终产生的是一个一个原始数据的浅拷贝，还和原来的数据共用一块儿内存
b=arr[1:6]
b[:3]=0
arr #<pre style="box-sizing: border-box; overflow: auto; font-size: 14px; padding: 0px; margin-top: 0px; margin-bottom: 0px; line-height: 17.0001px; word-break: break-all; word-wrap: break-word; border: 0px; border-radius: 0px; white-space: pre-wrap; vertical-align: baseline; background-color: rgb(255, 255, 255);">array([0, 0, 0, 0, 4, 5, 6, 7, 8, 9])
产生上面的原因是因为array中直接存放的数据，拷贝的话直接拿走的是pointer，没有取走数据，但是list却会直接发生深拷贝，数据指针全部带走
list1=list(c)
list1[1]=0
list1 #上面修改的0并没有被改变
[array([1, 2, 3]), 0, array([100, 100, 100]), array([100, 100, 100])]
除了这些之外还有自己的更加牛掰的方式（只能用array)
1）使用布尔数组.感觉甚是强大，就不要自己写什么判断语句啦，注意这种方式得到结果不和原始数组共享空间。布尔索引仅仅适用于数组array，list没资格用。布尔索引最终得到下标索引为true的数据。索引只能是布尔数组
a=np.array(a*2)
a>5
a[a>5] #
array([16, 32, 48, 64, 80, 16, 32, 48, 64, 80])
2)列表索引
列表索引可以是数组和list。返回的数据不和原来的数据共享内存。索引可以是list和array
x=np.arange(10)
index=[1,2,3,4,5]
arr_index=np.array(index)
print x
print x[index] # list索引
print x[arr_index] # array索引
[0 1 2 3 4 5 6 7 8 9]
[1 2 3 4 5]
[1 2 3 4 5]
array和list区别*2
a=np.arange(10)
lista=list(a)
print a*2
print lista*2
[ 0 2 4 6 8 10 12 14 16 18]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
array的广播
a = np.arange(0, 60, 10).reshape(-1, 1)
b = np.arange(0, 5)
print a
print b
[[ 0]
[10]
[20]
[30]
[40]
[50]]
[0 1 2 3 4]
print np.add(a,b,c)
[[ 0 1 2 3 4]
[10 11 12 13 14]
[20 21 22 23 24]
[30 31 32 33 34]
[40 41 42 43 44]
[50 51 52 53 54]]
