【Python数据分析系列2】Numpy学习——索引与切片

1.索引

对建立的数组要读、写指定的元素，可以通过索引、花式索引、切片、迭代来实现

1.1基本索引

Numpy数组的基本索引使用方法同Python列表对象的使用方法，也采用方括号[]来索引数组值

1.1.1一维数组单一元素的读写

import numpy as np
n1 = np.arange(10)
print('n1: ', n1)
print('读取下标为9的元素：',  n1[9])
print('从右往左读取第一个元素',  n1[-1])

#对一维数组单一元素进行赋值修改
n1[0] = 10
print('修改后的n1: ', n1)

输出：
n1:  [0 1 2 3 4 5 6 7 8 9]
读取下标为9的元素： 9
从右往左读取第一个元素 9
修改后的n1:  [10  1  2  3  4  5  6  7  8  9]

1.1.2二维数组单一元素的读写

n2 = n1.reshape(2,5)
print('n2: ', n2)

print('读取第2行第1列的元素',   n2[1,0])  #这里注意下python中的数组和列表的索引都是从0开始的
n2[1,1] = -1  #将第2行第2列的值修改为-1
print('修改后的n2: ', n2)

输出：
n2:  [[10  1  2  3  4]
 	  [ 5  6  7  8  9]]
读取第2行第1列的元素 5
修改后的n2:  [[10  1  2  3  4]
             [ 5 -1  7  8  9]]

1.1.3三维数组单一元素的读写

n3 = np.arange(12).reshape(2,2,3)
print('n3: ',  n3)

print(n3[1, 0, 0])      #下标1为第三维的第二行，中间0为第二维的第一行，最右边0为第一维的第一列
print(n3[1, 1, 1])      #下标1为第三维的第二行，中间1为第二维的第二行，最右边1为第一维的第二列
#在上一篇博客中提到，数维数时，从最里面往外数，如[[[，最里面[是第一维，往左第二个为第二维，最左边的是第三维

n3[1,0,2] = -1
print('修改后的n3: ', n3)

输出：
n3:  [[[ 0  1  2]
       [ 3  4  5]]
      [[ 6  7  8]
       [ 9 10 11]]]
6
10
修改后的n3:  [[[ 0  1  2]
              [ 3  4  5]]

			 [[ 6  7 -1]
			  [ 9 10 11]]]

1.1.4索引省略法

#当确定不了维度时，可以通过下标右边“...”（省略号）或者直接省略下标数来读取数组
print('n3[1, ...]=', n3[1, ...])  #等同于n3[1, ]或者n3[1]，右边两个维度的下标省略

#从下标左边开始省略，只能用“...”的形式，不能用n3[,2]的方式
print('n3[..., 2]=',n3[..., 2])  #获取一维最右列元素，用n3[, 2]将报错

#从下标中间维度只能用“...”的形式，不能直接省略中间的下标数
print('n3[1,...,2]=',n3[1,...,2])  #不能用n3[1, ,2]的方式

输出：
n3[1, ...]= [[ 6  7 -1]
             [ 9 10 11]]
n3[..., 2]= [[ 2  5]
             [-1 11]]
n3[1,...,2]= [-1 11]

1.1.5生成数组索引

n4 = np.arange(4).reshape(2,2)
print('n4: ',  n4)
n4[1][1]  #等价于n4[1,1]，但是该方法效率低，建议多用n4[1，1]方式

输出：
n4:  [[0 1]
      [2 3]]
3

1.2花式索引

利用整数数组的所有元素作为下标进行索引，又叫**数组索引**

1.2.1整数数组索引

#（1）一维数组的数组索引
fi1 = np.array(['Tom猫','加菲猫','波斯猫','黑猫','英国短脸猫','田园猫'])
f1 = np.array([1, 2, 4, 5])
print('fi1[f1]:', fi1[f1]) #将f1的元素作为下标，提取fi1对应下标的元素
#注意：这种方法无需通过循环处理，执行速度比循环处理要快的多！

#（2）二维数组的数组索引
#用一维整数数组作为数组索引，生成指定行的子数组
fi2 = np.array([['Tom猫',1,200], ['加菲猫',10,1000], ['波斯猫',5,2000],
                        ['黑猫',2,180], ['英国短脸猫',8,1800], ['田园猫',20,100]])
f2 = np.array([1,2,3])  #用一维数组指定第2，3，4行
print('fi2[f2]:', fi2[f2])

#还可以指定x,y坐标的数组，求指定数组对应坐标的元素，形成子数组
fi3 = np.array([[0,-1,9],[8,1,10],[-2,8,3]])
print('fi3=',  fi3)

x = np.array([[0,1,2]])  #以一维数组形式，指定所有x坐标值
y = np.array([[0,1,2]])  #以一维数组形式，指定所有y坐标值
print('fi3[x,y]= ', fi3[x,y])   #分别挑出坐标为[0,0],[1,1],[2,2]的元素

输出：
fi1[f1]= ['加菲猫' '波斯猫' '英国短脸猫' '田园猫']
fi2[f2]: [['加菲猫' '10' '1000']
          ['波斯猫' '5' '2000']
          ['黑猫' '2' '180']]
fi3= [[ 0 -1  9]
      [ 8  1 10]
      [-2  8  3]]
fi3[x,y]=  [[0 1 3]]

1.2.2布尔数组索引

s1 = np.arange(9).reshape(3,3)
print('s1', s1)

b1 = np.array([[True,False,False],[False,True,False],[False,False,True]])  #创建一个布尔数组
print('b1', b1)
print('s1[b1]: ', s1[b1])  

#注意：布尔索引要求布尔数组与被索引数组保持一样的形状，索引结果生成新的一维数组；
#另外也可以以行为单位进行索引

b2 = np.array([True,False,False])
print('s1[b2]: ',s1[b2])   #保留第一行，注意这里的结果是二维的

b3 = np.array([False,True,False])
print('s1[b3]: ',s1[b3])   #保留第二行，注意这里的结果是二维的

输出：
s1 [[0 1 2]
    [3 4 5]
    [6 7 8]]
b1 [[ True False False]
    [False  True False]
    [False False  True]]
s1[b1]:  [0 4 8]
s1[b2]:  [[0 1 2]]
s1[b3]:  [[3 4 5]]

2.切片

下标切片的基本格式为[b:e:s]，b为下标开始数字；e为下标结束数字（不包括自身）；s为步长，默认值为1。b、e、s可以任意省略

2.1一维数组切片

import numpy as np
k1 = np.arange(1,10)
print('k1=', k1)

print('k1[1:4] = ', k1[1:4])  #取一维数组下标1-3的元素

print('k1[:5] = ', k1[:5])  #取一维数组下标0-4的元素

print('k1[5:] = ', k1[5:])  #取一维数组下标5到最后的元素

print('k1[:-1] =', k1[:-1])  #取一维数组下标倒数第二个开始带数组下标0范围的元素

print('k1[:] = ', k1[:])  #取一维数组所有下标的元素

print('k1[ : : 2] =', k1[ : : 2])  #每隔步长2取值

输出：
k1= [1 2 3 4 5 6 7 8 9]
k1[1:4] =  [2 3 4]
k1[:5] =  [1 2 3 4 5]
k1[5:] =  [6 7 8 9]
k1[:-1] = [1 2 3 4 5 6 7 8]
k1[:] =  [1 2 3 4 5 6 7 8 9]
k1[ : : 2] = [1 3 5 7 9]

2.2二维数组切片

k2 = np.arange(9).reshape(3,3)
print('k2 = ', k2)
输出：
k2 =  [[0 1 2]
       [3 4 5]
       [6 7 8]]

2.2.1行切片

print('k2[1:3] = ', k2[1:3])  #取2、3行数组值，等价于k2[1:3, ]或k2[1:3,:]

print('k2[:2] = ', k2[:2])  #取1、2行

print('k2[2:] = ', k2[2:])  #取第3行，等价于k2[2]

输出：
k2[1:3] =  [[3 4 5]
            [6 7 8]]
k2[:2] =  [[0 1 2]
           [3 4 5]]
k2[2:] =  [[6 7 8]]

2.2.2列切片

#3.2.2二维数组列切片
print('k2[ : , 2] = ', k2[ : , 2])  #截取所有行，第3列的子数组

print('k2[ : , : 2] = ', k2[ : , : 2])  #截取所有行，第1列和第2列的子数组

print('k2[ 1 , 2 : ] = ', k2[ 1 , 2 : ])  #指定第2行，截取第3列

输出：
k2[ : , 2] = [2 5 8]
k2[ : , : 2] =  [[0 1]
                 [3 4]
                 [6 7]]
k2[ 1 , 2 : ] =  [5]

2.3三维数组切片

k3 = np.array([[['Tom',10,'boy'],['Kite',11,'girl']],[['Alice',12,'girl'],['John',11,'boy']]])
print('k3 = ', k3)

print('k3[ 1 , 1 : ] = ', k3[ 1 , 1 : ])   #获取第三维的第2行，第二维的第1行，第一维的所有列

print('k3[ 0 , :,  :2] = ', k3[ 0 , :,  :2] )  #获取第三维的第1行，第二维的所有行，第一维的1、2列

输出：
k3 =  [[['Tom' '10' 'boy']
        ['Kite' '11' 'girl']]

       [['Alice' '12' 'girl']
        ['John' '11' 'boy']]]
k3[ 1 , 1 : ] =  [['John' '11' 'boy']]
k3[ 0 , :,  :2] =  [['Tom' '10']
                    ['Kite' '11']]

3.迭代

数组作为元素集合，可以被迭代读取相应的元素

3.1一维数组读取

d1 = np.arange(3)
for g in d1:
    print(g)
输出：
0
1
2

3.2二维数组读取

d2 = np.array([['Tom',10,'boy'],['Kite',11,'girl'],['Alice',12,'girl']])
for g1 in d2:
    print(g1)
输出：
['Tom' '10' 'boy']
['Kite' '11' 'girl']
['Alice' '12' 'girl']

##转载请注明出处##
##《Python编程从数据分析到机器学习实践》##