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. /home/dahu/Homework/GMM的EM算法实现/numpy练习.py
[[[     ]
  [     ]]

 [[     ]
  [   ]]] <type 'numpy.ndarray'>
(, , ) 3行5列
 轴的个数
 总个数
int64 每个元素的类型
[    ] <type 'numpy.ndarray'> array是工厂函数，生成数组
[ .   1.1  1.2  1.3  1.4  1.5  1.6  1.7  1.8  1.9  . ] [start,stop],还有一个是数量
[ .   1.1  1.2  1.3  1.4  1.5  1.6  1.7  1.8  1.9] 类似range，不过可以搞浮点数
float64 用linspace生成浮点数组，查看每个元素类型，正确。
[[   ]
 [   ]
 [   ]
 [   ]
 [   ]] 配合zip生成数组，纵向的
[[         ]
 [    ]
 [    ]] 横向的生成数组
[[  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]]
[     ] 1维
[[     ]
 [     ]
 [     ]
 [   ]] 2维
[[[       ]
  [       ]
  [     ]]

 [[   ]
  [   ]
  [   ]]] 3维
[[            ...,         ]
 [      ...,      ]
 [      ...,      ]
 ...,
 [   ...,   ]
 [   ...,   ]
 [   ...,   ]] 数组太大,省略中间部分只打印角落
[    ] 数组减法,按元素运算
[        ]
[     ] 数组相乘,对应元素相乘
[[       ]
 [       ]
 [    ]] 操作+=,*=也是针对每个元素来操作的
[[ .  .  .  .]
 [ .  .  .  .]
 [ .  .  .  .]] 也算是构造数组,由函数生成
            [[       ]
 [       ]
 [    ]] 迭代完了再转换成数组,不耽误
[[ .  .  .  .  .  .  .  .  .  .  .  .]
 [ .  .  .  .  .  .  .  .  .  .  .  .]]
[array([[ .,  .,  .],
       [ .,  .,  .]]), array([[ .,  .,  .],
       [ .,  .,  .]]), array([[ .,  .,  .],
       [ .,  .,  .]]), array([[ .,  .,  .],
       [ .,  .,  .]])] 纵向切
[array([[ .,  .,  .,  .,  .,  .,  .,  .,  .,  .,  .,  .]]), array([[ .,  .,  .,  .,  .,  .,  .,  .,  .,  .,  .,  .]])] 横向切

Process finished with exit code