#-*- coding: UTF-8 -*-
'''
#################################################
# Author : 烤鱼想睡觉
# Date : Dec 14, 2015 9:39:10 AM
#company :
# description : NumPy数组
#################################################
'''
from numpy import arange, array, zeros, ones, empty, int16, linspace, hstack, \
concatenate, vstack, dstack, column_stack, row_stack, hsplit, vsplit, split, \
dsplit
#使用array函数创建时,参数必须是由方括号括起来的列表,而不能使用多个数值作为参数调用array。
#创建二维数组
b = array([arange(-4,-1), arange(100,106,2), arange(3,6)])
'''
数组的属性
'''
print '数组的数据类型:',b.dtype #数组的数据类型
print '数组的维数:',b.ndim #数组的维数,本例为2
print '数组的维度:',b.shape #数组的维度,本例为3
print '数组的大小:',b.size #数组的大小 = 行 * 列 = 3 * 3
print '数组每个元素的大小:',b.itemsize #数组每个元素的大小
print '数组:\n' , b
#print b.data #包含实际数组元素的缓冲区,由于一般通过数组的索引获取元素,所以通常不需要使用这个属性。
''''
用函数zeros可创建一个全是0的数组,
用函数ones可创建一个全为1的数组,
函数empty创建一个内容随机并且依赖与内存状态的数组。
默认创建的数组类型(dtype)都是float64。
'''
print '\nzeros函数:\n',zeros((3,4))
print 'ones函数:\n',ones((3,5))
print 'empty函数:\n',empty((3,6))
#可以定制数组中的数据类型
print '\n定制数组中的数据类型:\n', ones( (2,3,4), dtype=int16) #手动指定数组中元素类型
'''
当arange使用浮点数参数时,由于浮点数精度有限,通常无法预测获得的元素个数。因此,最好使用函数linspace去接收我们想要的元素个数来代替用range来指定步长
'''
print '\nlinspace函数:', linspace(-1, 0, 5) #5是想要的元素个数,那么就可以计算出布长了
'''
索引和切片
'''
a = arange(9)
print '\n索引和切片:',a[3:7]
print '-------------------------------------------------------修改数组的维度 begin------------------------------'
'''
reshape函数改变调用数组的形状并返回该数组;
resize函数改变调用数组自身。
'''
a = array([[ 7., 5.],
[ 9., 3.],
[ 7., 2.],
[ 7., 8.],
[ 6., 8.],
[ 3., 2.]])
#b = a.reshape((2,6))
print '\n原数组:\n', a
print '\nreshape函数:\n', b
print '原数组:\n', a
c = a.resize((3,4)) #生成3行4列的数组
print '\nresize函数:\n', c
print '原数组:\n', a
'''
ravel函数和flatten函数,是reshape和resize函数的反函数,用于将数组展平;
ravel函数只是返回数组的一个视图;flatten函数会请求内存来保存结果
'''
a = array([[ 7., 5.],
[ 9., 3.],
[ 7., 2.],
[ 7., 8.],
[ 6., 8.],
[ 3., 2.]])
print '\nravel函数:', a.ravel()
print 'flatten函数:', a.flatten()
'''
除了可以用reshape函数,还可以用元组设置维度
'''
a = array([arange(6,12),arange(0,6)]) #2行6列
a.shape = (3,4) #3行4列
print '\n用元组设置维度\n', a
'''
transpose在线性代数中,转置矩阵是很常见的操作。对于多维数组可以这么做:
'''
a = array([arange(6,12),arange(0,6)]) #2行6列
print '\n转置矩阵:\n', a.transpose()
print '-------------------------------------------------------修改数组的维度 end--------------------------------'
print '-------------------------------------------------------数组的组合 begin---------------------------------'
'''
NumPy数组有水平组合,垂直组合,深度组合等多种组合方式,
我们将使用vstack,dstack,hstack,column_stack,row_column以及concatenate函数来完成数组的组合
'''
#创建一些数组
a = arange(9).reshape(3, 3)
b = a * 2
#水平组合。将ndarray对象构成的元组作为参数,传给hstack函数。
print '\n数组a:\n', a
print '数组b:\n', b
print '\n水平组合hstack:\n', hstack((a, b)) #注意参数是一个元组
#也可以用concatenate函数来实现同样的效果,axis = 1:
print '水平组合concatenate:\n', concatenate((a, b), axis = 1) #注意参数是一个元组
#垂直组合
print '\n垂直组合vtack:\n', vstack((a, b))
#也可以用concatenate函数来实现同样的效果,axis = 0:
print '垂直组合concatenate:\n', concatenate((a, b), axis = 0)
#深度组合。所谓深度组合,就是将一系列数组沿着纵轴(深度)方向进行层叠组合。
print '\n深度组合vtack:\n', dstack((a, b))
#列组合。
#column_stack对于一维数组将按照列方向进行组合
#column_stack对于二维数组和hstack的效果相同
c = arange(3)
d = c * 3
print '\ncolumn_stack对于一维数组将按照列方向进行组合:\n', column_stack((c, d))
print 'column_stack对于二维数组和hstack的效果相同:\n', column_stack((a, b))
print '验证一下,对于二维数组和hstack的效果相同:\n', column_stack((a, b)) == hstack((a, b))
#行组合。
#对于两个一维数组,将直接层叠起来成为一个二维数组
print '\n对于两个一维数组,将直接层叠起来成为一个二维数组:\n', row_stack((c, d))
#对于二维数组,row_stack和vstack的效果十一样
print '对于二维数组,row_stack和vstack的效果是一样的:\n', row_stack((a, b))
print '验证一下,对于二维数组,row_stack和vstack的效果是否是一样的:\n', row_stack((a, b)) == vstack((a, b))
print '-------------------------------------------------------数组的组合 end---------------------------------'
print '-------------------------------------------------------数组的分割 begin---------------------------------'
'''
NumPy数组可以进行水平/垂直/深度分割,相关的函数hsplit/vsplit/dsplit/split。
可以将数组分割成相同大小的子数组,也可以指定原数组中需要分割的位置。
'''
a = array([arange(3), arange(5, 8), arange(100, 103)])
print '原始数组:\n', a
#水平分割
print '\n水平分割:\n', hsplit(a, 3)
#垂直分割
print '\n垂直分割:\n', vsplit(a, 3)
#调用split函数并且在参数中指定参数axis=1/axis=0可以达到水平分割和垂直分割的目的
print '\nsplit水平分割:\n', split(a, 3, axis = 1)
print 'split水平分割:\n', split(a, 3, axis = 0)
#深度分割
a = arange(27).reshape(3, 3, 3)
print "\n深度分割:\n", dsplit(a, 3)
print '-------------------------------------------------------数组的分割 end---------------------------------'
结果:
数组的数据类型: int64
数组的维数: 2
数组的维度: (3, 3)
数组的大小: 9
数组每个元素的大小: 8
数组:
[[ -4 -3 -2]
[100 102 104]
[ 3 4 5]]
zeros函数:
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]
ones函数:
[[ 1. 1. 1. 1. 1.]
[ 1. 1. 1. 1. 1.]
[ 1. 1. 1. 1. 1.]]
empty函数:
[[ 1.27062560e-312 1.81690705e-316 3.13151775e-292 1.95116135e+289
3.35716747e-309 6.08590601e+250]
[ 8.91441948e-309 1.45261363e-296 7.50195472e-304 2.09984405e-301
3.12520962e-308 8.81442827e-278]
[ 1.27812108e+294 7.74687577e-304 2.52279021e-306 1.95024498e+289
3.49297520e-309 6.87991117e-315]]
定制数组中的数据类型:
[[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]
[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]]
linspace函数: [-1. -0.75 -0.5 -0.25 0. ]
索引和切片: [3 4 5 6]
-------------------------------------------------------修改数组的维度 begin------------------------------
原数组:
[[ 7. 5.]
[ 9. 3.]
[ 7. 2.]
[ 7. 8.]
[ 6. 8.]
[ 3. 2.]]
reshape函数:
[[ -4 -3 -2]
[100 102 104]
[ 3 4 5]]
原数组:
[[ 7. 5.]
[ 9. 3.]
[ 7. 2.]
[ 7. 8.]
[ 6. 8.]
[ 3. 2.]]
resize函数:
None
原数组:
[[ 7. 5. 9. 3.]
[ 7. 2. 7. 8.]
[ 6. 8. 3. 2.]]
ravel函数: [ 7. 5. 9. 3. 7. 2. 7. 8. 6. 8. 3. 2.]
flatten函数: [ 7. 5. 9. 3. 7. 2. 7. 8. 6. 8. 3. 2.]
用元组设置维度
[[ 6 7 8 9]
[10 11 0 1]
[ 2 3 4 5]]
转置矩阵:
[[ 6 0]
[ 7 1]
[ 8 2]
[ 9 3]
[10 4]
[11 5]]
-------------------------------------------------------修改数组的维度 end--------------------------------
-------------------------------------------------------数组的组合 begin---------------------------------
数组a:
[[0 1 2]
[3 4 5]
[6 7 8]]
数组b:
[[ 0 2 4]
[ 6 8 10]
[12 14 16]]
水平组合hstack:
[[ 0 1 2 0 2 4]
[ 3 4 5 6 8 10]
[ 6 7 8 12 14 16]]
水平组合concatenate:
[[ 0 1 2 0 2 4]
[ 3 4 5 6 8 10]
[ 6 7 8 12 14 16]]
垂直组合vtack:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 0 2 4]
[ 6 8 10]
[12 14 16]]
垂直组合concatenate:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 0 2 4]
[ 6 8 10]
[12 14 16]]
深度组合vtack:
[[[ 0 0]
[ 1 2]
[ 2 4]]
[[ 3 6]
[ 4 8]
[ 5 10]]
[[ 6 12]
[ 7 14]
[ 8 16]]]
column_stack对于一维数组将按照列方向进行组合:
[[0 0]
[1 3]
[2 6]]
column_stack对于二维数组和hstack的效果相同:
[[ 0 1 2 0 2 4]
[ 3 4 5 6 8 10]
[ 6 7 8 12 14 16]]
验证一下,对于二维数组和hstack的效果相同:
[[ True True True True True True]
[ True True True True True True]
[ True True True True True True]]
对于两个一维数组,将直接层叠起来成为一个二维数组:
[[0 1 2]
[0 3 6]]
对于二维数组,row_stack和vstack的效果是一样的:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 0 2 4]
[ 6 8 10]
[12 14 16]]
验证一下,对于二维数组,row_stack和vstack的效果是否是一样的:
[[ True True True]
[ True True True]
[ True True True]
[ True True True]
[ True True True]
[ True True True]]
-------------------------------------------------------数组的组合 end---------------------------------
-------------------------------------------------------数组的分割 begin---------------------------------
原始数组:
[[ 0 1 2]
[ 5 6 7]
[100 101 102]]
水平分割:
[array([[ 0],
[ 5],
[100]]), array([[ 1],
[ 6],
[101]]), array([[ 2],
[ 7],
[102]])]
垂直分割:
[array([[0, 1, 2]]), array([[5, 6, 7]]), array([[100, 101, 102]])]
split水平分割:
[array([[ 0],
[ 5],
[100]]), array([[ 1],
[ 6],
[101]]), array([[ 2],
[ 7],
[102]])]
split水平分割:
[array([[0, 1, 2]]), array([[5, 6, 7]]), array([[100, 101, 102]])]
深度分割:
[array([[[ 0],
[ 3],
[ 6]],
[[ 9],
[12],
[15]],
[[18],
[21],
[24]]]), array([[[ 1],
[ 4],
[ 7]],
[[10],
[13],
[16]],
[[19],
[22],
[25]]]), array([[[ 2],
[ 5],
[ 8]],
[[11],
[14],
[17]],
[[20],
[23],
[26]]])]