numpy 练习

numpy学习，为后续机器学习铺垫

参考网址

#!/usr/bin/python
#coding=utf-8
#__author__='dahu'
# 
from numpy import *
import numpy as np

a = np.arange(12).reshape(2, 2, 3)  # 2个2行3列的数组
print a, type(a)  # ndarray
print a.shape  ,'3行5列'
print a.ndim   ,'轴的个数'
print a.size   ,'总个数'
print a.dtype  ,'每个元素的类型'
a = array(range(5))  # 创建数组
print a, type(a),   'array是工厂函数，生成数组'
b = array(tuple(range(5)))
# print b, type(b)
print linspace(1, 2, 11)  ,'[start,stop],还有一个是数量'
print arange(1, 2, 0.1)  , '类似range，不过可以搞浮点数'
fl = array(linspace(1, 2, 11))
print fl.dtype  ,'用linspace生成浮点数组，查看每个元素类型，正确。'
c = array(zip(range(5), range(10, 15), range(20, 25)))
print c,'配合zip生成数组，纵向的'
d = array((range(5), range(10, 15), range(20, 25)))
print d,'横向的生成数组'
# print zeros((3,4))  #全0数组
# print ones((3,4))   #全1数组
print empty((3, 4))  # 函数 empty 创建一个内容随机并且依赖与内存状态的数组，这个没怎么明白

#打印数组
''' 打印规则:
最后的轴从左到右打印
次后的轴从顶向下打印
剩下的轴从顶向下打印，每个切片通过一个空行与下一个隔开
'''
print np.arange(6),'1维'
print np.arange(12).reshape(4,3),'2维'
print np.arange(24).reshape(2,3,4),'3维'

# np.set_printoptions(threshold='nan')  #强制打印整个数组
print arange(10000).reshape(100,100),'数组太大,省略中间部分只打印角落'

#基本运算
print np.arange(10,15)-np.arange(5),'数组减法,按元素运算'
print np.arange(5)**2
print np.arange(5)*np.arange(10,15),'数组相乘,对应元素相乘'
a=np.arange(12).reshape(3,4)
a+=1
print a,'操作+=,*=也是针对每个元素来操作的'
print np.fromfunction(lambda x,y:x*y,(3,4)),'也算是构造数组,由函数生成'
# print a,a.shape
# a=a.reshape(2,2,3)
# print a
for ele in a.flat:
    print ele,                      #对每个数组元素进行迭代,多维也可以
c=[ele for ele in a.flat]
print np.array(c).reshape(3,4)      ,'迭代完了再转换成数组,不耽误'
e= np.floor(10*np.random.random((2,12))) #floor取整数位
print e
print np.hsplit(e,4),'纵向切'
print np.vsplit(e,2),'横向切'

/usr/bin/python2.7 /home/dahu/Homework/GMM的EM算法实现/numpy练习.py
[[[ 0  1  2]
  [ 3  4  5]]

 [[ 6  7  8]
  [ 9 10 11]]] <type 'numpy.ndarray'>
(2, 2, 3) 3行5列
3 轴的个数
12 总个数
int64 每个元素的类型
[0 1 2 3 4] <type 'numpy.ndarray'> array是工厂函数，生成数组
[ 1.   1.1  1.2  1.3  1.4  1.5  1.6  1.7  1.8  1.9  2. ] [start,stop],还有一个是数量
[ 1.   1.1  1.2  1.3  1.4  1.5  1.6  1.7  1.8  1.9] 类似range，不过可以搞浮点数
float64 用linspace生成浮点数组，查看每个元素类型，正确。
[[ 0 10 20]
 [ 1 11 21]
 [ 2 12 22]
 [ 3 13 23]
 [ 4 14 24]] 配合zip生成数组，纵向的
[[ 0  1  2  3  4]
 [10 11 12 13 14]
 [20 21 22 23 24]] 横向的生成数组
[[  0.00000000e+000   4.94065646e-324   9.88131292e-324   1.48219694e-323]
 [  1.97626258e-323   2.47032823e-323   2.96439388e-323   3.45845952e-323]
 [  3.95252517e-323   4.44659081e-323   4.94065646e-323   5.43472210e-323]]
[0 1 2 3 4 5] 1维
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]] 2维
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]] 3维
[[   0    1    2 ...,   97   98   99]
 [ 100  101  102 ...,  197  198  199]
 [ 200  201  202 ...,  297  298  299]
 ..., 
 [9700 9701 9702 ..., 9797 9798 9799]
 [9800 9801 9802 ..., 9897 9898 9899]
 [9900 9901 9902 ..., 9997 9998 9999]] 数组太大,省略中间部分只打印角落
[10 10 10 10 10] 数组减法,按元素运算
[ 0  1  4  9 16]
[ 0 11 24 39 56] 数组相乘,对应元素相乘
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]] 操作+=,*=也是针对每个元素来操作的
[[ 0.  0.  0.  0.]
 [ 0.  1.  2.  3.]
 [ 0.  2.  4.  6.]] 也算是构造数组,由函数生成
1 2 3 4 5 6 7 8 9 10 11 12 [[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]] 迭代完了再转换成数组,不耽误
[[ 0.  0.  4.  6.  3.  8.  6.  3.  7.  0.  5.  7.]
 [ 3.  7.  1.  2.  9.  8.  4.  2.  3.  0.  9.  7.]]
[array([[ 0.,  0.,  4.],
       [ 3.,  7.,  1.]]), array([[ 6.,  3.,  8.],
       [ 2.,  9.,  8.]]), array([[ 6.,  3.,  7.],
       [ 4.,  2.,  3.]]), array([[ 0.,  5.,  7.],
       [ 0.,  9.,  7.]])] 纵向切
[array([[ 0.,  0.,  4.,  6.,  3.,  8.,  6.,  3.,  7.,  0.,  5.,  7.]]), array([[ 3.,  7.,  1.,  2.,  9.,  8.,  4.,  2.,  3.,  0.,  9.,  7.]])] 横向切

Process finished with exit code 0