NumPy入门指南(二) | Day2

import numpy as np
a = np.arange(10) #生成数组的索引是从0-9
# 冒号分隔切片参数 start:stop:step 来进行切片操作
print(a[2:7:2])# 从索引3开始到索引8停止，索引8不包含，step为2
'''
[2 4 6]
'''

# 取其中的一个元素，只放置一个参数，如 [2]，将返回与该索引相对应的单个元素
print(a[2])
'''
2
'''

#  如果为 [2:]，表示从该[2]索引开始以后的所有项都将被提取
print(a[2:])
'''
[2 3 4 5 6 7 8 9]
'''

import numpy as np
t1 = np.arange(24).reshape(4,6)
print(t1)
'''
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
'''

# 取一行数组(一行代表是一条数据，索引也是从0开始的)
print(t1[0])  # [0 1 2 3 4 5]
## 取一行数组元素的第二种表示方法，写全行和列
# '0'的位置代表取的行，','后面是截取的列，'：'冒号代表从这个位置起后的所有元素被获取
print(t1[0,:])  # [0 1 2 3 4 5]
# t1中括号里的参数可以理解为行的索引为0，取第一行；’,’ 后面是取的列数，不写默认索引为0是第一列，冒号是从索引为0的列开始取到最后，就是第一列到最后一列。整体理解就是取第一行中的所有列


# 取连续的多行数组
print(t1[0:])
# 取连续的多行数组，
print(t1[0:2,:]) # 行的索引为0到2，2不取，列取所有
'''
运行结果：
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
'''

print(t1[[0,2,3]]) # 取不连续的多行
print(t1[[0,1,3],:]) # 取不连续的多行的第二种表示方法，写全行和列
'''
运行结果：
[[ 0  1  2  3  4  5]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [18 19 20 21 22 23]]
'''

print(t1[:,0])# 取一列
print(t1[:,0:])# 连续的多列
print(t1[:,[0,1,3]])# 取不连续的多列
'''
运行结果：
[ 0  6 12 18]

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]

[[ 0  1  3]
 [ 6  7  9]
 [12 13 15]
 [18 19 21]]

'''
# 取某一个值,如二行三列
print(t1[1,2])  # 8
# 取多个不连续的值，[[行，行。。。],[列，列。。。]]
print(t1[[0,1,1],[0,1,3]]) # [0 7 9]

import numpy as np 
t1 = np.arange(24).reshape(4,6)
# 修改某一行的值
t1[0,:]=0
print(t)
# 修改某一列的值
t1[:,0]=0
print(t1)
'''
[[ 0  0  0  0  0  0]
 [ 0  7  8  9 10 11]
 [ 0 13 14 15 16 17]
 [ 0 19 20 21 22 23]]
'''

t2 = np.arange(24).reshape(4,6)
# 修改连续多行
t2[0:2,:]=0
# 修改连续多列
t2[:,1:4]=0
print(t2)
'''
[[ 0  0  0  0  0  0]
 [ 0  0  0  0  0  0]
 [12  0  0  0 16 17]
 [18  0  0  0 22 23]]
'''

t3 = np.arange(24).reshape(4,6)
# 修改多行多列，取第二行到第四行，第三列到第五列
t3[1:4,2:5]=0
# 修改多个不相邻的点，[[行，行。。。],[列，列。。。]]
t3[[0,1],[0,1]]=0 # 修改第一行第一列为0，等于不修改；第二行第二列的7为0
print(t3)
'''
[[ 0  1  2  3  4  5]
 [ 6  0  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
'''

t4 = np.arange(24).reshape(4,6)
# 可以根据条件修改，比如讲小于10的值改掉
t4[t4<10]=0
print(t4)
'''
[[ 0  0  0  0  0  0]
 [ 0  0  0  0 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
'''

# 使用逻辑判断
# np.logical_and  &
# np.logical_or   |
# np.logical_not  ~
t5 = np.arange(24).reshape(4,6)
t5[(t5>10)&(t5<16)]=0 # 与
print(t5)

t5[(t5<10)|(t5>16)]=1 # 或
print(t5)

t5[~(t5>6)]=2 # 非
print(t5)
'''
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10  0]
 [ 0  0  0  0 16 17]
 [18 19 20 21 22 23]]

[[ 1  1  1  1  1  1]
 [ 1  1  1  1 10  1]
 [ 1  1  1  1 16  1]
 [ 1  1  1  1  1  1]]

[[ 2  2  2  2  2  2]
 [ 2  2  2  2 10  2]
 [ 2  2  2  2 16  2]
 [ 2  2  2  2  2  2]]
'''


# 拓展:三目运算，也叫条件判断( np.where(condition, x, y)，满足条件(condition)，输出x，不满足输出y。
score = np.array([[70,78],[72,71],[65,71]])
result = np.where(score>70,True,False)
print(result)
'''
[[False  True]
 [ True  True]
 [False  True]]
'''

# 1.numpy.append() 函数在数组的末尾添加值。追加操作会分配整个数组，并把原来的数组复制到新数组中。此外， 输入数组的维度必须匹配否则将生成Value Error。注意: 最多两个数组拼接，不能三个及以上进行拼接
'''
参数说明:
arr:输入数组
values:要向arr添加的值，需要和arr形状相同(除了要添加的轴)
axis:默认为None。当axis无定义时，是横向加成，返回总是为一维数组!当axis有定义的时候，分别为0和1的时 候。当axis有定义的时候，分别为0的时候(列数要相同)。当axis为1时，数组是加在右边(行数要相同)。
'''
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print ('第一个数组:')
print (a)
print ('\n') #'\n' 换行的意思

print ('向数组添加元素:')
print (np.append(a, [7,8,9]))
print ('\n') # 如果填加时不指定轴，则数组会变成一维数组

print ('沿0轴-行添加元素:')
print (np.append(a, [[7,8,9]],axis = 0))
print ('\n') # 末尾添加一行数据，不改变列结构

print ('沿1轴-列添加元素:')
print (np.append(a, [[5,5,5],[7,8,9]],axis = 1)) # 末尾添加一列数据，不改变行结构

第一个数组:
[[1 2 3]
 [4 5 6]]

向数组添加元素:
[1 2 3 4 5 6 7 8 9]

沿轴 0 添加元素:
[[1 2 3]
 [4 5 6]
 [7 8 9]]

沿轴 1 添加元素:
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]

# 2. numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。
import numpy as pd
a = np.array([[1,2],[3,4],[5,6]])
print ('第一个数组:')
print (a)
print ('\n')

# insert(arr,obj,values，axis) arr:添加的数组,obj:索引,values:添加的数据,axis:指定的轴
print ('未传递 Axis 参数。在插入之前输入数组会被展开。')
print (np.insert(a,3,[11,12]))
print ('\n')

print ('传递了 Axis 参数。会广播值数组来配输入数组。')
print ('沿轴 0 广播:')
print (np.insert(a,1,[11],axis = 0))
print ('\n')
print ('沿轴 1 广播:')
print (np.insert(a,1,11,axis = 1))

第一个数组:
[[1 2]
 [3 4]
 [5 6]]


未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 1  2  3 11 12  4  5  6]


传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴 0 广播:
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]


沿轴 1 广播:
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]

#numpy.delete 函数返回从输入数组中删除指定子数组的新数组。如果未提供轴参数，则输入数组将展开，与 insert()函数相同。
'''
numpy.delete(arr, obj, axis=None)
参数说明:
arr:输入数组
obj:可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
axis:沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开
'''
import numpy as np
a = np.arange(12).reshape(3,4)

print ('第一个数组:')
print (a)
print ('\n')

print ('未传递 Axis 参数。在删除之前输入数组会被展开。')
print (np.delete(a,5))
print ('\n')
print ('删除每一行中的第二列:')
print (np.delete(a,1,axis = 1))
print ('\n')

# 运行结果：
'''
第一个数组:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


未传递 Axis 参数。在删除之前输入数组会被展开。
[ 0  1  2  3  4  6  7  8  9 10 11]


删除每一行中的第二列:
[[ 0  2  3]
 [ 4  6  7]
 [ 8 10 11]]
'''

# numpy.unique(arr, return_index=False, return_inverse=False, return_counts=False, axis=None) 用于去除数组中的重复元素。
'''
arr:输入数组，如果不是一维数组则会展开
return_index:如果为true，返回新列表元素在旧列表中的位置(下标)，并以列表形式储
return_inverse:如果为true，返回旧列表元素在新列表中的位置(下标)，并以列表形式储
return_counts:如果为true，返回去重数组中的元素在原数组中的出现次数
'''
import numpy as np
a = np.array([5,2,6,2,7,5,6,8,2,9])
print ('第一个数组:')
print (a)
print ('\n')

print ('第一个数组的去重值:')
u = np.unique(a)
print (u)
print ('\n')

# return_index = True 会有两个返回值，一个是返回的去重后数组u，还有一个是数组indices（缩影），表示去重后的元素在去重前列表中的位置。
print ('去重数组的索引数组:')
u,indices = np.unique(a, return_index = True)
print (u)
print (indices)

print ('我们可以看到每个和原数组下标对应的数值:')
print (a)

print ('去重数组的下标:')
u,indices = np.unique(a,return_inverse = True)
print (u)
print (indices)

print ('返回去重元素的重复数量:')
u,indices = np.unique(a,return_counts = True)
print (u)
print (indices)

第一个数组:
[5 2 6 2 7 5 6 8 2 9]

第一个数组的去重值:
[2 5 6 7 8 9]
# 元素’2‘出现三次排在最前面，索引为0

去重数组的索引数组:
[2 5 6 7 8 9]
[1 0 2 4 7 9]
# 返回新列表元素在旧列表中的位置

我们可以看到每个和原数组下标对应的数值:
[5 2 6 2 7 5 6 8 2 9]

去重数组的下标:
[2 5 6 7 8 9]
[1 0 2 0 3 1 2 4 0 5]
# return_inverse:如果为true，返回旧列表元素在新列表中的位置(下标)，并以列表形式储

返回去重元素的重复数量:
[2 5 6 7 8 9]
[3 2 2 1 1 1]

import numpy as np
# 1. 根据轴连接的数组序列
# np.concatenate((a1, a2,...),axis=0)函数，能够一次完成多个数组拼接
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])

# 要求a,b两个数组的维度相同
print ('沿轴 0 连接两个数组:')
print (np.concatenate((a,b),axis= 0))
print ('\n')
print ('沿轴 1 连接两个数组:')
print (np.concatenate((a,b),axis = 1))
'''
沿轴 0 连接两个数组:
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

沿轴 1 连接两个数组:
[[1 2 5 6]
 [3 4 7 8]]
'''

# 2. 根据轴进行堆叠
print ('沿轴 0 堆叠连接两个数组:')
print (np.stack((a,b),axis= 0))
print ('\n')
print ('沿轴 1 堆叠连接两个数组:')
print (np.stack((a,b),axis = 1))
'''
沿轴 0 堆叠连接两个数组:
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]

沿轴 1 堆叠连接两个数组:
[[[1 2]
  [5 6]]

 [[3 4]
  [7 8]]]
'''

# 3. 矩阵垂直拼接
a1 = [[0,1,2,3,4,5],
[6,7,8,9,10,11]]
a2 = [[12,13,14,15,16,17],
[18,19,20,21,22,23]]
va1a2= np.vstack((a1,a2))
print(va1a2)
'''
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
'''


# 4. 矩阵水平拼接
b1 = [[0,1,2,3,4,5],
[6,7,8,9,10,11]]
b2 = [[12,13,14,15,16,17],
      [18,19,20,21,22,23]]
hb1b2 = np.hstack((b1,b2))
print(hb1b2)
'''
[[ 0  1  2  3  4  5 12 13 14 15 16 17]
 [ 6  7  8  9 10 11 18 19 20 21 22 23]]
'''

import numpy as np
# 1. 将一个数组分割为多个子数组
'''
numpy.split(ary, indices_or_sections, axis=0)
参数说明:
ary:被分割的数组
indices_or_sections:如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置
axis:沿着哪个维度进行切向，默认为0，横向切分。为1时，纵向切分
'''

arr = np.arange(9).reshape(3,3)
print(arr)
print ('将数组分为三个大小相等的子数组:')
b = np.split(arr,3)
print (b)
print('\n')

# 2.numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。
# floor() 向下取整数，如：3.6，向下取整是3.0，浮点型
harr = np.floor(10 * np.random.random((2, 6)))
print ('原array:')
print(harr)
print ('水平分割:')
print(np.hsplit(harr, 3))
print('\n')

# 3.numpy.vsplit 沿着垂直轴的方向分割
varr = np.arange(16).reshape(4,4)
print ('原array:')
print (varr)
print ('竖直分割:')
print (np.vsplit(varr,2))

[[0 1 2]
 [3 4 5]
 [6 7 8]]
将数组分为三个大小相等的子数组:
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

原array:
[[4. 3. 7. 0. 8. 2.]
 [8. 2. 7. 5. 6. 7.]]
水平分割:
[array([[4., 3.],[8., 2.]]),
array([[7., 0.],[7., 5.]]),
array([[8., 2.],[6., 7.]])]

原array:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
竖直分割:
[array([[0, 1, 2, 3],[4, 5, 6, 7]]),
array([[ 8,  9, 10, 11],[12, 13, 14, 15]])]

import numpy as np
score = np.array([[80,88],[82,81],[75,81]])
print(score)
'''
[[80 88]
 [82 81]
 [75 81]]
'''

# 1. 获取所有数据最大值
ans01 = np.max(score)
print(ans01) # 88

# 2. 获取某一个轴上的数据最大值
ans02 = np.max(score,axis=0)
print(ans02)  #[82 88]

# 3. 获取最小值
ans03 = np.min(score)
print(ans03) # 75

# 4. 数据的比较
ans04 = np.maximum([-2, -1, 0, 1, 2], 0) # 第一个参数中的每一个数与第二个参数比较返回大的
ans05 = np.minimum([-2, -1, 0, 1, 2], 0) # 第一个参数中的每一个数与第二个参数比较返回小的
ans06 = np.maximum([-2, -1, 0, 1, 2], [1,2,3,4,5]) # 接受的两个参数，也可以大小一致;第二个参数只是一个单独的值时，其实是用到了维度的广播机制;
print(ans04,ans05,ans06)
# [0 0 0 1 2]  [-2 -1  0  0  0]   [1 2 3 4 5]

# 5. 求平均值
ans07 = np.mean(score) # 获取所有数据的平均值
ans08 = np.mean(score,axis=0) # 获取一个轴上的平均值
print(ans07,ans08)
# 81.16666666666667 [79.         83.33333333] 轴上有两列，[]中放有两列的均值

# 6. 返回给定axis上的累计和
ans09 = np.array([[1,2,3], [4,5,6]])
print(ans09)
'''
[[1 2 3]
 [4 5 6]]
'''
print(np.cumsum(ans09,0))
'''
[[1 2 3]
 [5 7 9]] # 5=1+4; 7=2+5; 9=3+6
'''
print(np.cumsum(ans09,1))
'''
[[ 1  3  6]   # 1  3=2+1 6=3+2+1
 [ 4  9 15]]  # 4  9=4+5 15=4+5+6
'''

# 7. argmin求最小值索引
ans10 = np.argmin(score,axis=0)
print(score)
'''
[[80 88]
 [82 81]
 [75 81]]
'''
print(ans10)
# [2 1] 最小值在第三行第一列

import numpy as np
# 创建一个nan和inf
a = np.nan
b = np.inf 
print(a,type(a))
# nan <class 'float'>
print(b,type(b))
# inf <class 'float'> nan和inf都是float浮点型数据


## 判断数组中为nan的个数: print(np.count_nonzero(t != t))
# 1.创建数组(注意:float类型的数据才能赋值nan)
t = np.arange(24,dtype=float).reshape(4,6)
print(t)
'''
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]
'''

# 2.增加nan：将数组中的第四行第五列的元素改成nan
t[3,4] = np.nan
print(t)
'''
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. nan 23.]]
'''
# nan和任何数计算都为nan
print(np.sum(t,axis=0)) # 结果 [36. 40. 44. 48. nan 56.]

#3.方法：np.count_nonzero() 求得非零值的个数
print(np.count_nonzero(t)) # 23个，只有第一个元素是0

# 4.numpy特性：nan不等于nan ；符号’!=‘ ：不等于
# 判断修改过的含有一个nan的数组t是否不等于t
print(t != t)
'''
[[False False False False False False]
 [False False False False False False]
 [False False False False False False]
 [False False False False  True False]]

 只有倒数第二个为nan的元素不相等，其他的元素都相等；验证numpy中的nan和nan是不相等的
'''

# 5.结合判断非零个数的方法和 nan的特性来判断nan的个数
# False=0；True = 1；因而数组（t != t) 只有1个1：true，其他23个元素全是0：false
print(np.count_nonzero(t != t)) # 结果：1
# count_nonzero统计非零数，数组(t != t)只有一个1，其他全是0，结果是1；数组中有一个nan存在 ；

import numpy as np
t = np.arange(24).reshape(4,6).astype('float')

# 将数组中的一部分替换nan 准备含有nan的数据
t[1,3:] = np.nan
print(t)
'''
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8. nan nan nan]
 [12. 13. 14. 15. 16. 17.]
'''


# 将数组中的nan替换为0
t[np.isnan(t)] = 0 # 方法:np.isnan(arr) 找出nan 赋值为0
print(t)
'''
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  0.  0.  0.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]

'''

import numpy as np
t = np.arange(24).reshape(4,6).astype('float')

# 将数组中的一部分替换nan 准备含有nan的数据
t[1,3:] = np.nan
print(t)
'''
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8. nan nan nan]
 [12. 13. 14. 15. 16. 17.]
'''

# ----- 将数组中的nan替换为每一列的平均值 ------

for i in range(t.shape[1]):# 循环遍历每一列
     # t.shape[1]:是为了获取列数; print(t2.shape) 返回 (4,6)：四行六列,(4,6)是一个元祖类型的数据，t.shape[1] 通过下标取得列数；shape()中不直接写6因为，实际用的数据的列数是很大的，不可能一下数的出来
    
    temp_col = t[:,i] # 获取当前的列数据
    # 循环6次可以取到6列数组，前三行不含有nan；因此需要判断含列是否有nan，含有nan的列才需要替换
    # [ 0.  6. 12. 18.]
    # [ 1.  7. 13. 19.]
    # [ 2.  8. 14. 20.]
    # [ 3. nan 15. 21.]
    # [ 4. nan 16. 22.]
    # [ 5. nan 17. 23.]
    
    nan_num = np.count_nonzero(temp_col != temp_col) # 求得当前列数据含有nan的个数
    
    if nan_num != 0: # nan的个数不等于0则为True 含有nan
      
            temp_col_not_nan = temp_col[temp_col==temp_col] #去掉一列中的nan，形成不含nan的列
        
            temp_col[np.isnan(temp_col)] = np.mean(temp_col_not_nan)#将nan替换成这一列不含nan元素的均值
        
print(t)
'''
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8. 13. 14. 15.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]

'''

import numpy as np

#对换数组的维度:transpose()
a = np.arange(12).reshape(3,4)
print ('原数组:')
print (a )
print ('\n')
print ('对换数组:')
print (np.transpose(a))

'''
原数组:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

对换数组:
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]
'''

# arr.T 与transpose()相同
a = np.arange(12).reshape(3,4)
print ('原数组:')
print (a)
print ('\n')
print ('转置数组:')
print (a.T)
'''
原数组:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

转置数组:
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]
'''

# swapaxes()函数用于交换数组的两个轴
t1 = np.arange(24).reshape(4,6)
re = t1.swapaxes(1,0)
print ('原数组:')
print (t1)
print ('\n')
print ('调用 swapaxes 函数后的数组:')
print (re)
'''
原数组:
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]

调用 swapaxes 函数后的数组:
[[ 0  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]
'''