NumPy学习 -- 001_数组

本文详细介绍了NumPy数组的基本操作,包括创建、属性查询、维度调整、数组组合与分割等核心功能。通过丰富的实例展示了如何利用NumPy进行高效的数据处理。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

#-*- 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]]])]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值