#!/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