数组的函数及运算------(一)

一.特殊函数创建数组

1.等差数列

import numpy as np

arr1=np.linspace(2,10,5)
print(arr1)     #[  2.   4.   6.   8.  10.]

"""
np.linspace(start=a1, stop=an, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
参数说明： 
endpoint=True: 表示等差数列， 在start与stop之间插入 n-2 个值；（n为数值的个数）
endpoint=False: 表示等差数列， 在start与stop之间插入 n-1个值，表示平均分成n份；（为线段的个数）
"""

2.等比数列

arr2=np.logspace(1,5,3,base=2)
print(arr2)   #[  2.   8.  32.]

3.arange–>类似于range

arr3=np.arange(1,10,1)
print(arr3)    #[1 2 3 4 5 6 7 8 9]

4全一数组

arr4=np.ones((2,4))
print(arr4)

'''
[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]
'''

5全零数组

arr5=np.zeros((3,5))
print(arr5)

'''
[[ 0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.]]
'''

6单位数组

arr6=np.eye(3)
print(arr6)

'''
[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]
'''

7对角数组

arr7=np.diag([1,2,3,4])
print(arr7)

'''
[[1 0 0 0]
 [0 2 0 0]
 [0 0 3 0]
 [0 0 0 4]]
'''

8创建随机数组

(1)创建n个0-1之间的随机数(一维的)

arr8=np.random.random(10)
print(arr8)     #[ 0.38577165  0.01456249  0.31928876  0.8083111   0.27088015  0.63171955  0.04054835  0.70315425  0.15719737  0.47176773]

(2)创建服从均匀分布的随机数(0-1)

arr9=np.random.rand(100000)
print(arr9)      #[ 0.85394415  0.87689807  0.24274053 ...,  0.53871246  0.84275727 0.09990747]
import matplotlib.pyplot as plt
plt.figure()
plt.hist(arr9,10)
plt.show()

(3)创建服从正态分布的随机数

arr10=np.random.randn(10000)
print(arr10)    #[ 1.16913581 -0.40398283 -0.8118837  ...,  0.10862416  0.13421117 -2.37939989]
plt.figure()
plt.hist(arr10,9)
plt.show()

(4)随机整数生成 low <= x < high

arr11=np.random.randint(2,4,size=[2,5])
print(arr11)

'''
[[3 3 3 3 2]
 [2 3 2 2 3]]
'''

二.矩阵形态变换

1.重置数组结构

arr_1=np.arange(10)
print(arr_1)
# 一维变二维
arr_2=arr_1.reshape((2,5))
print(arr_2)
# 二维变一维
arr_3=arr_2.ravel()
print(arr_3)
# 展平方法2:flatten('C')     C默认行(横向)展平,F纵向展平
arr_4=arr_2.flatten('C')
print(arr_4)
arr_5=arr_2.flatten('F')
print(arr_2)

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

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

2.堆叠方法

arr_6=np.zeros((3,4))
arr_7=np.ones((3,5))
arr_8=np.zeros((4,3))
arr_9=np.ones((2,3))
arra=np.ones(3)
arrb=np.zeros(3)
# 横向堆叠,行数相同即可
arr_10=np.hstack((arr_6,arr_7))
print(arr_10)
# 纵向堆叠,列数相同即可(可以将一维数组堆叠成二维及多维数组)
arr_11=np.vstack((arr_8,arr_9))
arrc=np.vstack((arra,arrb))
print(arr_11)
print(arrc)

'''
[[ 0.  0.  0.  0.  1.  1.  1.  1.  1.]
 [ 0.  0.  0.  0.  1.  1.  1.  1.  1.]
 [ 0.  0.  0.  0.  1.  1.  1.  1.  1.]]
 
[[ 0.  0.  0.]
 [ 0.  0.  0.]
 [ 0.  0.  0.]
 [ 0.  0.  0.]
 [ 1.  1.  1.]
 [ 1.  1.  1.]]
 
[[ 1.  1.  1.]
 [ 0.  0.  0.]]
'''

3.数组合并

# concatenate(axis=0沿着纵向拼接,axis=1沿着横向拼接)
arr_12=np.concatenate((arr_8,arr_9),axis=0)
arrd=np.concatenate((arra,arrb),axis=0)
print(arr_12)
print(arrd)

'''
[[ 0.  0.  0.]
 [ 0.  0.  0.]
 [ 0.  0.  0.]
 [ 0.  0.  0.]
 [ 1.  1.  1.]
 [ 1.  1.  1.]]
 
[ 1.  1.  1.  0.  0.  0.]

concatenate与hstack/vstack的区别: concatenate是严格严格沿着数组的方向拼接的,一位数组只有一个axis轴,因此只有一种拼接方式. hstack/vstack不关注有几个轴,只是单纯的按照横向/纵向堆叠即可,因此一位数组也有两种堆叠方式
'''

4.数组分割

# axis=0 行切割,行数不变
arr_12=np.hsplit(arr_10,3)
arr_13=np.hsplit(arr_10,[2,4,6])
print(arr_12)
print(arr_13)
# axis=1 列切割,列数不变
arr_14=np.vsplit(arr_10,3)
print(arr_14)
# split分割 , 沿着轴的分割
arr_15=np.split(arr_10,3,axis=0)
arr_16=np.split(arr_10,3,axis=1)
print(arr_15)
print(arr_16)

'''
[array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.],
       [ 0.,  0.,  0.]]),      
array([[ 0.,  1.,  1.],
       [ 0.,  1.,  1.],
       [ 0.,  1.,  1.]]),
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])]
       
[array([[ 0.,  0.],
       [ 0.,  0.],
       [ 0.,  0.]]), 
array([[ 0.,  0.],
       [ 0.,  0.],
       [ 0.,  0.]]), 
array([[ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.]]), 
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])]
       
[array([[ 0.,  0.,  0.,  0.,  1.,  1.,  1.,  1.,  1.]]), array([[ 0.,  0.,  0.,  0.,  1.,  1.,  1.,  1.,  1.]]), array([[ 0.,  0.,  0.,  0.,  1.,  1.,  1.,  1.,  1.]])]

[array([[ 0.,  0.,  0.,  0.,  1.,  1.,  1.,  1.,  1.]]), array([[ 0.,  0.,  0.,  0.,  1.,  1.,  1.,  1.,  1.]]), array([[ 0.,  0.,  0.,  0.,  1.,  1.,  1.,  1.,  1.]])]

[array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.],
       [ 0.,  0.,  0.]]), 
array([[ 0.,  1.,  1.],
       [ 0.,  1.,  1.],
       [ 0.,  1.,  1.]]), 
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])]
'''

三.数组运算

1.四则运算

# (1)四则运算(+ - * / ** // %)
ar_1=np.arange(1,17).reshape((4,4))
print(ar_1)
ar_2=np.diag([2,3,1,5])
print(ar_2)

# 数组乘法(对应元素相乘
ar_3=ar_1*ar_2
print(ar_3)
ar_4=ar_1+ar_2
print(ar_4)
ar_5=ar_1-ar_2
print(ar_5)
ar_6=ar_4/ar_1
print(ar_6)
ar_7=ar_4//ar_1
print(ar_7)
ar_8=ar_4%ar_1
print(ar_8)

'''
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]
 [13 14 15 16]]
 
[[2 0 0 0]
 [0 3 0 0]
 [0 0 1 0]
 [0 0 0 5]]
 
[[ 2  0  0  0]
 [ 0 18  0  0]
 [ 0  0 11  0]
 [ 0  0  0 80]]
 
[[ 3  2  3  4]
 [ 5  9  7  8]
 [ 9 10 12 12]
 [13 14 15 21]]
 
[[-1  2  3  4]
 [ 5  3  7  8]
 [ 9 10 10 12]
 [13 14 15 11]]
 
[[ 3.          1.          1.          1.        ]
 [ 1.          1.5         1.          1.        ]
 [ 1.          1.          1.09090909  1.        ]
 [ 1.          1.          1.          1.3125    ]]
 
[[3 1 1 1]
 [1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]]
 
[[0 0 0 0]
 [0 3 0 0]
 [0 0 1 0]
 [0 0 0 5]]
 '''

2.比较运算

# (2)比较运算: > < = <= >=  !=    返回值是bool值
# 两个数数组比较
ar_9=ar_1>=ar_2
print(ar_9)
# 数组和值比较   
mask=ar_1>8
print(mask)
print(ar_1[mask])

'''
[[False  True  True  True]
 [ True  True  True  True]
 [ True  True  True  True]
 [ True  True  True  True]]
 
[[False False False False]
 [False False False False]
 [ True  True  True  True]
 [ True  True  True  True]]
 
[ 9 10 11 12 13 14 15 16]
'''

3.逻辑运算

# (3)逻辑运算---将一个逻辑数组转化成一个bool值
# 逻辑与
ar_10=np.all(mask)
print(ar_10)     #False
# 逻辑或
ar_11=np.any(mask)
print(ar_11)    #True

4.广播运算

# (4)广播运算 ----只有一行或者一列才可以广播
ar_12=np.arange(1,17).reshape([4,4])
ar_13=np.array([1,0,1,0])
ar_14=np.array([[1],[0],[1],[0]])
print(ar_12)
print(ar_12+ar_13)     # 直接相加就已经广播
print(ar_12+ar_14)

'''
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]
 [13 14 15 16]]
 
[[ 2  2  4  4]
 [ 6  6  8  8]
 [10 10 12 12]
 [14 14 16 16]]
 
[[ 2  3  4  5]
 [ 5  6  7  8]
 [10 11 12 13]
 [13 14 15 16]]
'''

5.标题特殊方法

# (5)特殊方法
# 排序
ar_15=np.array([21,10,20,8,15,1])
# 排序,并修改原数组
ar_15.sort()
print(ar_15)
# 索引排序argsort---返回排序后的索引值
ar_16=ar_15.argsort()
print(ar_16)
ar_17=np.array([[12,2,10,9],[2,90,25,1]])
print(ar_17)
ar_17.sort(axis=0)
print(ar_17)
print(ar_17.argsort())

'''
[ 1  8 10 15 20 21]

[0 1 2 3 4 5]
[[12  2 10  9]
 [ 2 90 25  1]]
 
[[ 2  2 10  1]
 [12 90 25  9]]
[[3 0 1 2]
 [3 0 2 1]]
'''

去重

arr=np.array([21,2,21,1,0,1])
arr1=np.unique(arr)
print(arr1)
arr2=np.array([[2,1,2,1],[2,0,2,0],[1,1,2,1],[2,0,2,0],])
print(np.unique(arr2))          #将所有元素放到一行去重(像集合一样),并按大小排序
print(np.unique(arr2,axis=1))   # 一列一列的看,如果某列重复则只剩下一列,并按列排序
print(np.unique(arr2,axis=0))   # 一行一行的看,如果某行重复则只剩下一行,并按行排序

''''''
[ 0  1  2 21]

[0 1 2]
[[1 2 2]
 [0 2 2]
 [1 1 2]
 [0 2 2]]
 
[[1 1 2 1]
 [2 0 2 0]
 [2 1 2 1]]