python——数组的创建、存取（切片、整数、布尔）、去重、堆叠、连接

标准Python的列表(list)中，元素本质是对象。如：L = [1, 2, 3]，需要3个指针和三个整数对象，对于数值运算比较浪费内存和CPU。因此，Numpy提供了ndarray(N-dimensional array object)对象：存储单一数据类型的多维数组。

本文简单的介绍一下python中几种数组的创建、存取（切片、整数、布尔）、去重、堆叠、连接方法。

1、数组的创建
（1）使用numpy模块中的array函数创建：

#通过array函数传递list对象
L = [1, 2, 3, 4, 5, 6]
print 'L = ', L
a = np.array(L)
print 'a = ', a
print type(a), type(L)

# 创建多维数组
b = np.array([[1, 2, 3, 4], [ 5, 6, 7, 8 ], [9, 10, 11, 12]])
print 'b = ', b
#数组属性可以通过shpe属性获得
print b.shape
#强制修改shape,这里并不是对数组进行转置，而是改变每个轴的大小，数组元素在内存中的位置并没有改变
b.shape = 4, 3
print b
print b.shape

# 当某个轴为-1时，将根据数据元素的个数自动计算磁此轴的长度
b.shape = (2, -1)
print b
print b.shape
#使用reshape方法，可以创建改变尺寸的新数组，但原数组尺寸不变
c = b.reshape((4,-1))
print 'b = ', b
print 'c = ', c

# 数组b和c共享内存，修改其中一个影响另外一个
b[0][1] = 100
print 'b = \n', b
print 'c = \n', c

d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype = np.float)
print 'd = ', d
f = d.astype(np.int)
print 'f = \n', f
print f.dtype, d.dtype
#不能对属性强制赋值, 得到的结果将是混乱的数据
d.dtype = np.int
print '强制改变属性：', d

（2）使用numpy中的arange、linspace、logspace、fromstring等函数创建：

#!/usr/bin/python
# -*- coding:utf-8 -*-

import numpy as np
# 如果生成一定规则的数据，可以使用NumPy专门提供的函数

# arange函数类似于Python的range函数：指定起始值，终值，步长来创建数组
# 和Python的range类似，arange不包含终值，但可以生成浮点数，而range只能是整数类型
np.set_printoptions(linewidth = 200, suppress = True)  #不换行，每行长度为200; 输出不使用科学计数法
a = np.arange(1, 10, 0.5)
print a
#range只能用于整数，其他情况下会出错
#a = range(1.0, 10.0, 0.5)

# linspace函数通过指定：起始值，终值(包括)，元素个数来创建数组
b = np.linspace(1, 10, 10)
print 'b = ', b
#可以使用参数endpoint来指定是否包含终值
c = np.linspace(1, 10, 10, endpoint = False)
print 'c = ', c
# 和linspace类似，logspace可以创建等比数列，默认底为10
# 下面函数创建起始值为10^0，终值为10^2(包括)，有10个数的等比数列
d = np.logspace(0, 2, 10, endpoint = True)
print 'd =', d
e = np.logspace(0, 2, 10, endpoint = True, base = 2)
print 'e =', e

# 使用frombuffer, fromstring, fromfile 等函数可以从字节序列创建数组
s = 'abcd'
g = np.fromstring(s, dtype = np.int8)
print 'g = ', g

2、数组的存取

（1）常规办法：数组元素的存取方法和Python的标准方法相同

#!/usr/bin/python
# -*- coding:utf-8 -*-

import numpy as np

a = np.arange(10)
#切片，左闭右开
print 'a=', a, '  a[3:6]=', a[3:6]
#省略开始下标，表示从0开始
print 'a[:5] = ', a[:5]
#下标为负表示从后往前数
print 'a[-3:] = ', a[-3:]
#步长为2
print 'a[1:9:2] = ', a[1:9:2]
#步长为-1，即翻转
print 'a[::-1] = ', a[::-1]
# 切边数据与原始数据共享一个内存，可以直接修改元素值
a[1:4] = 10, 20, 30
print  'a = ',a
#在实践中要注意原始数据是否被破坏
b = a[2:5]
b[0] = 200
print 'a = ', a

（2）整数/布尔数组存取

#!/usr/bin/python
# -*- coding:utf-8 -*-

import numpy as np

#根据整数数组存取：当使用整数序列对数组元素进行存取时，
#将使用整数序列中的每个元素作为下标， 整数序列可以是列表（list）或者数组(ndarray)
#####使用整数序列作为下标获得的数组不和原始数组共享数据内存#####
a = np.logspace(0, 9, 10, base = 2)
print 'a = ', a
i = np.arange(0, 10, 2)
b = a[i]
b[2] = 1.6
print 'a = ', a   #a的元素值并没有改变,任然为16
print 'b = ', b

#使用布尔数组i作为下标存取数组a中的元素：返回数组a中'数组i的对应下标为True'的所有元素
#生成10个满足[0,1)均匀分布的随机数
a = np.random.rand(10)
print 'a = ', a
#大于0.5的元素索引
print '索引：', a > 0.5
#打印大于0.5的元素
b = a[a > 0.5]
print 'b = ', b
#将原素组中大于0.5的元素换成0.5
a[a > 0.5] = 0.5
print 'a = ', a
#b的值不受影响,a和b不共享内存
print 'b = ', b

（3）二维数组扩展、切片等操作

# 二维数组切片
# 当横、纵坐标都为ndarray或list时，前后两个数字按序形成一个二维坐标,
# 此时两个ndarray/list中元素个数必须相同
a = np.arange(0, 60, 10).reshape((-1, 1)) + np.arange(6)
print 'a = \n', a
print 'a[[0, 1, 2], [2, 3, 4]] =  ', a[[0, 1, 2], [2, 3, 4]]
#print a[[0,1], [2, 3, 4]]  # 错误写法
# 其中坐标位置为数字时，表示对应的行或列，此时前后个数可以不对应
print 'a[4, [2, 3, 4]] = ', a[4, [2, 3, 4]]
print 'a[4:, [2, 3, 4]] = \n', a[4:, [2, 3, 4]]
i = np.array([True, False, False, True, True, False])
print 'a[i] = \n', a[i]
print 'a[i, 3] = ', a[i, 3]

3、数组元素去重

#一维数组去重，直接使用库函数
a = np.array((1, 2, 3, 4, 5, 5, 7, 3, 2, 2, 8, 8))
print '原始数组：', a
b = np.unique(a)
print '去重后：', b
#二维数组的去重
c = np.array(((1,2), (3,4), (5,6), (1,3), (3,4), (6,7)))
print '原始数组：\n', c
#unique只能一维，二维会将数据展开
print '错误方法去重后：', np.unique(c)
#方案一：暴力法，利用set
print '去重方案一：\n', np.array(list(set((tuple(i) for i in c))))
#方案二：转换为虚数
x = c[:, 0] + c[:, 1] * 1j
print '方案二：转换成虚数：\n', x
print '虚数去重后：\n', np.unique(x)
print np.unique(x, return_index = True)
idx = np.unique(x, return_index = True)[1]
print '二维数组去重后：\n', c[idx]

4、数组元素堆叠、连接

a = np.arange(1, 10).reshape(3, 3)
b = np.arange(11, 20).reshape(3, 3)
c = np.arange(101, 110).reshape(3, 3)
print 'a = \n', a
print 'b = \n', b
print 'c = \n', c
print '数组的堆叠：'
print 'axis = 0:\n', np.stack((a, b, c), axis = 0)  #最外面一层堆叠
print 'axis = 1:\n', np.stack((a, b, c), axis = 1)  #最外面第二层堆叠
print 'axis = 2:\n', np.stack((a, b, c), axis = 2)  #最外面第三层堆叠
print '数组的连接：'
print 'axis = 0:\n', np.concatenate((a, b), axis = 0)
print 'axis = 1:\n', np.concatenate((a, b), axis = 1)