一.ndaarry

1.ndarry的特性

多维性

# 导入numpy库
import numpy as np

# 创建一个0维数组
arr = np.array(5)
print(arr)
print('arr的维度: ', arr.ndim)

5
arr的维度:  0

# 创建一个1维数组
arr1 = np.array([1, 2, 3])
print(arr1)
print('arr1的维度: ', arr1.ndim)# number of dimensions

[1 2 3]
arr1的维度:  1

# 创建一个2维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2)
print('arr2的维度: ', arr2.ndim)

[[1 2 3]
 [4 5 6]]
arr2的维度:  2

同质性

arr3 = np.array([1,'string'])# 数组中有不同的数据类型,会被强制相同的数据类型---整型转换为字符串类型
print(arr3)

['1' 'string']

arr4 = np.array([1,3.14159])# 数组中有不同的数据类型,会被强制相同的数据类型----整型转换为浮点型
print(arr4)

[1.      3.14159]

2.ndarray的属性

#ndarray的属性----shape(数组的形状),ndim(数组的维度0,1,2...),dtype(数组元素的数据类型),size(数组元素的个数),itemsize(数组元素的字节大小,T(转置),
#nbytes(数组总内存占用量),flags(内存存储方式--是否为连续存储)
arr4 = np.array([[1,2,3],[4,5,6]])
print(arr2.shape)# 数组的形状
print(arr2.ndim)# 数组的维度
print(arr2.dtype)# 数组元素的数据类型
print(arr2.size)# 数组元素的个数
print(arr2.itemsize)# 数组元素的字节大小
print(arr2.T)# 转置
print(arr2.nbytes)# 数组总内存占用量---SIZE*ITEMSIZEG
print(arr2.flags)# 内存存储方式--是否为连续存储

(2, 3)
2
int64
6
8
[[1 4]
 [2 5]
 [3 6]]
48
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False

3.ndarray的创建

#基础的创建方法
arr = np.array([1, 2, 3])#array()---->方法
print(arr.ndim)#ndim--->属性
print(arr)

list1 = [4, 5, 6]
arr2 = np.array(list1)#list---->方法
print(arr2)

list2 = [7, 8, 9]
arr3 = np.array(list2,dtype=np.float64)#强制指定数据类型
print(arr3)

1
[1 2 3]
[4 5 6]
[7. 8. 9.]

# copy()方法
print(arr2)
arr4 = np.copy(arr2)#copy()---->方法-->元素值相同,但内存地址不同
print(arr4)

arr2[0] = 100#修改arr2的值,arr4的值不会改变
print(arr2)
print(arr4)

[4 5 6]
[4 5 6]
[100   5   6]
[4 5 6]

# 预定义形状
# 全0  全1  未初始化  固定值

# 全0
#创建2行3列的全0数组
arr5 = np.zeros((2,3))
print(arr5)
print(arr5.dtype)

[[0. 0. 0.]
 [0. 0. 0.]]
float64

# 创建1行10列的全0数组
arr6 = np.zeros(10,dtype=int)
print(arr6)
print(arr6.dtype)

[0 0 0 0 0 0 0 0 0 0]
int64

# 全1
arr7 = np.ones((5,5))
print(arr7)

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

# 未初始化
# 创建2行2列的未初始化数组---随机数
arr8 = np.empty((2,2))
print(arr8)

[[0.00000000e+000 7.01232584e-312]
 [7.01232585e-312 7.01232585e-312]]

# 固定值
arr9 = np.full((2,2),5)# 2行2列,元素值都为5
print(arr9)

[[5 5]
 [5 5]]

arr10 = np.zeros_like(arr9)# 与arr9形状相同,元素值都为0
print(arr10)
#np.empty_like()---->方法,与arr9形状相同,元素值都为随机数
#np.ones_like()---->方法,与arr9形状相同,元素值都为1
#np.full_like()---->方法,与arr9形状相同,元素值都为指定值

[[0 0]
 [0 0]]

# 等差数列
#不包含结束值
arr11 = np.arange(1,10,1)# 1-9,步长为1
print(arr11)
arr12 = np.arange(2,10,2)
print(arr12)

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

# 等间隔数列
arr13 = np.linspace(1,10,5)# 1-10,分成5份-----(10-1)/(5-1)==2.25
print(arr13)
arr14 = np.linspace(0,100,5,dtype=int)
print(arr14)
arr15 = np.arange(0,101,25)
print(arr15)

[ 1.    3.25  5.5   7.75 10.  ]
[  0  25  50  75 100]
[  0  25  50  75 100]

# 对数间隔数列
arr16 = np.logspace(0,4,3,base=3)# 3的0次方到3的4次方,分成3份,base为底
print(arr16)

arr17 = np.logspace(0,4,3)# 10的0次方到10的4次方,分成3份,base为10,默认base=10
print(arr17)

[ 1.  9. 81.]
[1.e+00 1.e+02 1.e+04]

# 特殊矩阵的创建
# 单位矩阵
arr18 = np.eye(5)# 5x5的单位矩阵
print(arr18)

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

#对角矩阵：对角线元素为非0,其他元素为0
arr19 = np.diag([1,2,3,4,5])# 对角线元素为1,2,3,4,5的矩阵
print(arr19)

[[1 0 0 0 0]
 [0 2 0 0 0]
 [0 0 3 0 0]
 [0 0 0 4 0]
 [0 0 0 0 5]]

#零矩阵
arr20 = np.zeros((3,3))
print(arr20)

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

#对称矩阵

arr21 = np.array([[1,2,3],[2,4,5],[3,5,6]])
arr22 = arr21.T# 转置
arr23 = arr21 + arr22# 矩阵相加
print(arr21)
print(arr22)
print(arr21 == arr22)
print(arr23)

[[1 2 3]
 [2 4 5]
 [3 5 6]]
[[1 2 3]
 [2 4 5]
 [3 5 6]]
[[ True  True  True]
 [ True  True  True]
 [ True  True  True]]
[[ 2  4  6]
 [ 4  8 10]
 [ 6 10 12]]

#随机数组的生成
#生成0到1之间的随机浮点数（均匀分布）
m1 = np.random.rand(2,3)# 2行3列的随机数组----rand()---0-1之间的随机数
print(m1)

[[0.48793671 0.56304297 0.29254552]
 [0.68702053 0.30754081 0.70473255]]

#生成制定范围内的随机浮点数
m2 = np.random.uniform(6,10,size=(2,3))# 2行3列的随机数组----uniform()----1-10之间的随机数
print(m2)

[[8.00939235 8.14218444 6.29156787]
 [8.30331262 8.02627495 8.1833841 ]]

#生成制定范围的随机整数
m3 = np.random.randint(1,10,size=(2,3))# 2行3列的随机数组----randint()----1-10之间的随机整数
print(m3)

[[5 7 4]
 [3 7 7]]

#生成随机数列（正态分布）
#两边概率小，中间概率大
m4 = np.random.randn(2,3)# 2行3列的随机数组----randn()----正态分布
print(m4)

[[-1.14441517  0.55895459  0.48746024]
 [ 1.22769155  1.1437808  -0.50165269]]

# 设置随机种子
# 设置随机种子后，每次生成的随机数都相同
np.random.seed(20)# 设置随机种子
m5 = np.random.randint(1,10,size=(2,5))
print(m5)

[[4 5 7 8 3]
 [1 7 9 6 4]]

4.ndarray的数据类型

# 1.bool类型

# 创建bool类型数组
m6 = np.array([1,0,2,0,5,0],dtype='bool')
print(m6)

[ True False  True False  True False]

# 2.int类型

# 创建int类型数组
#int8,int16,int32,int64,uint8,uint16,uint32,uint64---表示的范围不同，符号不同
m7 = np.array([1,2,3000,4,5],dtype='int')
print(m7)

[   1    2 3000    4    5]

# 3.float类型

# 创建float类型数组
#float16,float32,float64,float128---表示的精度不同
m8 = np.array([1.1,2.2,3.3,4.4,5.5],dtype='float')
print(m8)

[1.1 2.2 3.3 4.4 5.5]

# 4.complex类型

# 创建complex类型数组
m9 = np.array([1+2j,2+3j,3+4j,4+5j,5+6j],dtype='complex')
print(m9)

[1.+2.j 2.+3.j 3.+4.j 4.+5.j 5.+6.j]

5.ndarray的索引与切片

# 1.一维数组的索引与切片

# 创建一维数组
arr_1 = np.random.randint(1,100,20)
print(arr_1)

[17 63 17  8 99  7 27 14 76 59 26  4 75 76 62 78 84 58 95 33]

# 索引
print(arr_1[0])# 索引第一个元素---17
print(arr_1[4])# 索引第五个元素---99
print(arr_1[-1])# 索引最后一个元素---33
print(arr_1[arr_1>50])# 索引大于50的元素---bool索引
print(arr_1[(arr_1>20) & (arr_1<90)])

17
99
33
[63 99 76 59 75 76 62 78 84 58 95]
[63 27 76 59 26 75 76 62 78 84 58 33]

# 切片
print(arr_1[1:5])# 切片从第二个元素到第五个元素---
print(arr_1[slice(1,5)])# 切片从第二个元素到第五个元素---slice()方法

print(arr_1[1:-1])# 切片从第二个元素到倒数第二个元素

print(arr_1[::2])# 切片从第一个元素到最后一个元素,步长为2
print(arr_1[slice(None, None,2)])# 切片从第一个元素到最后一个元素,步长为2

print(arr_1[::-1])# 切片从最后一个元素到第一个元素,步长为-1

[63 17  8 99]
[63 17  8 99]
[63 17  8 99  7 27 14 76 59 26  4 75 76 62 78 84 58 95]
[17 17 99 27 76 26 75 62 84 95]
[17 17 99 27 76 26 75 62 84 95]
[33 95 58 84 78 62 76 75  4 26 59 76 14 27  7 99  8 17 63 17]

# 2.二维数组的索引与切片

# 创建二维数组
arr_2 = np.random.randint(1,100,(4,8))
print(arr_2)

[[11  7 76 19  4 78 18 44]
 [17 19 80 91 60 72 76 30]
 [46  7 64 79 25 19 94 34]
 [79 43 95  4 19 71 53 23]]

# 索引
print(arr_2[0])
print(arr_2[0][arr_2[0]>50])# 索引第1行大于50的元素---bool索引---返回的是一维数组

print(arr_2[:,3])# 索引第4列的所有元素---返回的是一维数组
print(arr_2[:,3][arr_2[:,3]>50])# 索引第4列大于50的元素---bool索引---返回的是一维数组

print(arr_2[0,0])# 索引第1行第1列元素
print(arr_2[2,3])# 索引第3行第4列元素-
print(arr_2[-1,-1])# 索引最后一行最后一列元素
print(arr_2[arr_2>50])# 索引大于50的元素---bool索引---返回的是一维数组
print(arr_2[(arr_2>50) & (arr_2<90)])# 索引大于50小于90的元素---bool索引---返回的是一维数组

[11  7 76 19  4 78 18 44]
[76 78]
[19 91 79  4]
[91 79]
11
79
23
[76 78 80 91 60 72 76 64 79 94 79 95 71 53]
[76 78 80 60 72 76 64 79 79 71 53]

# 切片
print(arr_2[ :,:])# 索引所有元素
print(arr_2[1:3,2:4])# 切片第2行到第3行,第3列到第4列

[[11  7 76 19  4 78 18 44]
 [17 19 80 91 60 72 76 30]
 [46  7 64 79 25 19 94 34]
 [79 43 95  4 19 71 53 23]]
[[80 91]
 [64 79]]

6.ndarray的运算

# 算术运算
a = np.array([[1,2,3]])
b = np.array([[4,5,6]])
print(a+b)
print(a-b)
print(a*b)
print(a/b)

[[5 7 9]]
[[-3 -3 -3]]
[[ 4 10 18]]
[[0.25 0.4  0.5 ]]

# 列表加法---列表拼接
l1 = [1,2,3]
l2 = [4,5,6]
print(l1+l2)

#利用for循环实现列表对应元素加法
for i in range(len(l1)):
    l2[i] = l1[i] + l2[i]

print(l2)

[1, 2, 3, 4, 5, 6]
[5, 7, 9]

# 矩阵的运算
a_2 = np.array([[1,2,3],[4,5,6],[7,8,9]])
b_2 = np.array([[4,5,6],[7,8,9],[1,2,3]])

#二维数组的加法、减法、乘法、除法
print(a_2+b_2)
print(a_2-b_2)
print(a_2*b_2)
print(a_2/b_2)

#二维数组和标量的运算---矩阵的每个元素都和标量进行运算
print(a_2+2)
print(a_2-2)
print(a_2*2)
print(a_2/2)

[[ 5  7  9]
 [11 13 15]
 [ 8 10 12]]
[[-3 -3 -3]
 [-3 -3 -3]
 [ 6  6  6]]
[[ 4 10 18]
 [28 40 54]
 [ 7 16 27]]
[[0.25       0.4        0.5       ]
 [0.57142857 0.625      0.66666667]
 [7.         4.         3.        ]]
[[ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
[[-1  0  1]
 [ 2  3  4]
 [ 5  6  7]]
[[ 2  4  6]
 [ 8 10 12]
 [14 16 18]]
[[0.5 1.  1.5]
 [2.  2.5 3. ]
 [3.5 4.  4.5]]

#广播机制---不同形状的数组进行运算
# 同一维度：相同，1
a_3 = np.array([1,2,3])# 1x3
b_3 = np.array([[4],[5],[6]])# 3x1
print(a_3)
print(b_3)

print(a_3+b_3)# 广播机制---->1x3+3x1=3x3
print(a_3-b_3)
print(a_3*b_3)

'''
a
1 2 3
1 2 3
1 2 3
b
4 4 4
5 5 5
6 6 6

'''

[1 2 3]
[[4]
 [5]
 [6]]
[[5 6 7]
 [6 7 8]
 [7 8 9]]
[[-3 -2 -1]
 [-4 -3 -2]
 [-5 -4 -3]]
[[ 4  8 12]
 [ 5 10 15]
 [ 6 12 18]]





'\na\n1 2 3\n1 2 3\n1 2 3\nb\n4 4 4\n5 5 5\n6 6 6\n\n'

# 矩阵的运算
a_4 = np.array([[1,2,3],[4,5,6],[7,8,9]])
b_4 = np.array([[4,5,6],[7,8,9],[1,2,3]])

print(a_4*b_4)#对应元素相乘
#线性代数--矩阵乘法
print(np.dot(a_4,b_4))#矩阵乘法
print(a_4@b_4)#矩阵乘法

[[ 4 10 18]
 [28 40 54]
 [ 7 16 27]]
[[ 21  27  33]
 [ 57  72  87]
 [ 93 117 141]]
[[ 21  27  33]
 [ 57  72  87]
 [ 93 117 141]]

7.numpy的常用函数

1.基本数学函数

#1.计算平方根
#返回值是浮点数
print(np.sqrt(9))
print(np.sqrt([1,4,9,16]))
a_list = np.array([1,2,3,4,5])
print(np.sqrt(a_list))

3.0
[1. 2. 3. 4.]
[1.         1.41421356 1.73205081 2.         2.23606798]

# 2.计算指数
print(np.exp(1))# e的1次方
print(np.exp([0,1,2]))# e的0次方,1次方,2次方

2.718281828459045
[1.         2.71828183 7.3890561 ]

# 3.计算自然对数  ln(x)
print(np.log(1))# 自然对数e
print(np.log([np.exp(1),np.exp(2),np.exp(3)]))
#log10(x)---->以10为底的对数
print(np.log10(100))# 以10为底的对数

0.0
[1. 2. 3.]
2.0

# 三角函数的相关函数
# sin(x) cos(x) tan(x)
print(np.sin(0))# 0的正弦
print(np.sin(1))# 1的正弦
print(np.sin(np.pi/2))# 90度的正弦
print(np.cos(0))# 0的余弦
print(np.cos(1))# 1的余弦
print(np.cos(np.pi/2))# 90度的余弦
print(np.tan(0))# 0的正切
print(np.tan(1))# 1的正切

0.0
0.8414709848078965
1.0
1.0
0.5403023058681398
6.123233995736766e-17
0.0
1.5574077246549023

2.统计函数

# 1.计算绝对值
print(np.abs(-1))
print(np.abs([-1,2,-3]))

1
[1 2 3]

# 2.计算平均值
print(np.mean([1,2,3,4,5]))

3.0

# 3.计算a的b次方
print(np.power(2,3))
print(np.power([1,2,3],2))

8
[1 4 9]

# 4.计算方差-----方差是衡量数据集离散程度的指标
#平均值 = (1+2+3+4+5)/5 = 3
#方差 = ((1-3)^2 + (2-3)^2 + (3-3)^2 + (4-3)^2 + (5-3)^2)/5 =(4 + 1 +0 +1 +4)/5 = 2
print(np.var([1,2,3,4,5]))

2.0

# 5.计算标准差-----方差的算术平方根------方差越小，数据集离散程度越小
# 方差的平方根
print(np.std([1,2,3,4,5]))

1.4142135623730951

# 6.计算中位数
# 从小到大排列后，中间的那个数元素
print(np.median([1,2,3,4,5]))

3.0

# 7.计算最大值
print(np.max([1,2,3,4,5]))

5

# 8.计算最小值
print(np.min([1,2,3,4,5]))

1

# 9.计算排序后的数组
# 默认升序排列
print(np.sort([3,1,4,1,5,9,2,6,5,3,5]))

#降序排列
print(np.sort([3,1,4,1,5,9,2,6,5,3,5])[::-1])

[1 1 2 3 3 4 5 5 5 6 9]
[9 6 5 5 5 4 3 3 2 1 1]

# 10.四舍五入
print(np.around([0.37,1.64,2.44,2.87,3.14,3.5]))

[0. 2. 2. 3. 3. 4.]

# 11.向上取整向下取整
print(np.ceil([0.37,1.64,2.44,2.87,3.14,3.5]))# 向上取整
print(np.floor([0.37,1.64,2.44,2.87,3.14,3.5]))# 向下取整

[1. 2. 3. 3. 4. 4.]
[0. 1. 2. 2. 3. 3.]

# 12.检测数组是否为NaN或Inf
print(np.isnan(np.nan))# True
print(np.isinf(np.inf))# True
print(np.isinf(np.nan))# False
print(np.isnan([1,2,np.nan,4,5]))

True
True
False
[False False  True False False]

# 13.求和
arry = np.random.randint(1,20,8)
print(arry)
print(np.sum(arry))

# 求累加和
v1 = np.array([1,2,3,4,5])
print(np.cumsum(v1))# [1 3 6 10 15]

[13  6  3  6 10 10  3 16]
67
[ 1  3  6 10 15]

# 14.求积
# 数组中所有元素的乘积
arry1 = np.random.randint(1,5,8)
print(arry1)
print(np.prod(arry1))

# 求累乘积
v2 = np.array([1,2,3,4,5])
print(np.cumprod(v2))# [1 2 6 24 120]

[2 3 2 3 1 2 1 1]
72
[  1   2   6  24 120]

# 15.计算数组中某一百分位数的值percentile()---->计算数组中某一百分位数的值
# 百分位数：将数组从小到大排列后，所处的位置的百分比
arry2 = np.random.randint(1,10,10)
print(arry2)
print(np.sort(arry2))
print(np.percentile(arry2,50))# 50%分位数
print(np.percentile(arry2,90))# 90%分位数
#(n-1)*percent%+1=a.b     finally_num = (1-b)*arr[a] + b*arr[a+1]

[1 4 5 1 6 7 8 5 1 7]
[1 1 1 4 5 5 6 7 7 8]
5.0
7.1

# 16.统计数组中的元素个数

arry3 = np.array([1,2,3,4,5,6,7,8,1,3,4,5,6])
print(arry3)
print(np.bincount(arry3))# 统计数组中每个元素出现的次数
#输出：[0 2 1 2 2 2 2 1 1]表示0出现0次，1出现2次，2出现1次，3出现2次，
# 4出现2次，5出现2次，6出现2次，7出现1次，8出现1次

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

# 16.统计数组中的非零元素个数
print(np.count_nonzero([1,2,0,0,4,0]))# 统计数组中非零元素的个数

3

# 17.统计数组中某个元素出现的次数
arry4 = np.array([1,2,3,4,5,6,7,8,1,3,4,5,6])
print(arry4)
print(np.where(arry4==3))# 返回数组中元素=3的索引

[1 2 3 4 5 6 7 8 1 3 4 5 6]
(array([2, 9]),)

3.比较函数

# 1.是否大于
print(np.greater([1,2,3,4,5],3))
# 2.是否小于
print(np.less([1,2,3,4,5],3))
# 3.是否等于
print(np.equal([1,2,3,4,5],3))

print('\n')
print(np.greater([3,4,5],[4,4,4]))
print(np.less([3,4,5],[4,4,4]))
print(np.equal([3,4,5],[4,4,4]))

[False False False  True  True]
[ True  True False False False]
[False False  True False False]


[False False  True]
[ True False False]
[False  True False]

# 逻辑运算
print(np.logical_and([1,0],[1,1]))
print(np.logical_or([1,0],[1,1]))
print(np.logical_not([1,0]))

[ True False]
[ True  True]
[False  True]

# 检查元素是否至少有一个元素为True
print(np.any([1,0,0]))# True
print(np.any([0,0,0]))# False

True
False

# 检查元素是否全部元素为True
print(np.all([1,1,1]))# True
print(np.all([1,0,1]))# False

True
False

# 自定义条件
#print(np.where(条件，符合条件，不符合条件))
arr24 = np.array([1,2,3,4,5])
print(np.where(arr24>3,arr24,0))
print(np.where(arr24<3,arr24,0))

[0 0 0 4 5]
[1 2 0 0 0]

# 自定义条件
arr25 = np.array([1,2,3,4,5])
print(np.where(arr25<3,1,0))

[1 1 0 0 0]

# 自定义条件---根据分数判断是否及格
score = np.random.randint(50,100,20)
print(score)
print(np.where(score>60,'及格','不及格'))

# 分三类
print(np.where(score<60,'不及格',np.where(score<80,'良好','优秀')))#----where()函数的嵌套使用

[95 71 70 70 99 95 74 61 51 91 68 86 62 86 91 60 82 81 97 71]
['及格' '及格' '及格' '及格' '及格' '及格' '及格' '及格' '不及格' '及格' '及格' '及格' '及格' '及格'
 '及格' '不及格' '及格' '及格' '及格' '及格']
['优秀' '良好' '良好' '良好' '优秀' '优秀' '良好' '良好' '不及格' '优秀' '良好' '优秀' '良好' '优秀'
 '优秀' '良好' '优秀' '优秀' '优秀' '良好']

# np.select()函数
# 功能：根据条件选择不同的值
# 语法：np.select(条件列表，选择列表)
# 条件列表：一个布尔数组，表示选择哪个条件
score1 = np.random.randint(50,100,20)
print(score1)
print(np.select([score1>80,(score1>=60) & (score1<=80),score1<60],['优秀','良好','不及格'],default = '未知'))

[54 68 60 50 93 54 97 90 61 65 61 54 72 56 89 94 59 61 68 85]
['不及格' '良好' '良好' '不及格' '优秀' '不及格' '优秀' '优秀' '良好' '良好' '良好' '不及格' '良好'
 '不及格' '优秀' '优秀' '不及格' '良好' '良好' '优秀']

# 排序函数
np.random.seed(0)
arr26 = np.random.randint(1,100,20)
print(arr26)
# 改变原数组
arr26.sort()# 直接对数组进行排序
print(arr26)

print('\n')
# 不改变原数组
arr27 = np.random.randint(1,100,20)
print(arr27)
print(np.sort(arr27))
print(arr27)
print('\n')
print(arr27.argsort())# 返回排序后的索引

[45 48 65 68 68 10 84 22 37 88 71 89 89 13 59 66 40 88 47 89]
[10 13 22 37 40 45 47 48 59 65 66 68 68 71 84 88 88 89 89 89]


[82 38 26 78 73 10 21 81 70 80 48 65 83 89 50 30 20 20 15 40]
[10 15 20 20 21 26 30 38 40 48 50 65 70 73 78 80 81 82 83 89]
[82 38 26 78 73 10 21 81 70 80 48 65 83 89 50 30 20 20 15 40]


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

# 去除重复元素
arr28 = np.array([1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9])
print(arr28)
print(np.unique(arr28))# 去除重复元素---进行排序后返回唯一的元素

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

# 两个数组的拼接
arr29 = np.array([1,2,3])
arr30 = np.array([4,5,6])
print(np.concatenate((arr29,arr30)))# 按行拼接-----返回拼接后的数组
print(np.vstack((arr29,arr30)))# 按列拼接-----返回拼接后的数组

[1 2 3 4 5 6]
[[1 2 3]
 [4 5 6]]

# 数组的分割
arr31 = np.array([1,2,3,4,5,6,7,8,9])
print(np.split(arr31,3))#平均分割为3份
print(np.split(arr31,[3,4,8]))#按索引分割

[array([1, 2, 3]), array([4, 5, 6]), array([7, 8, 9])]
[array([1, 2, 3]), array([4]), array([5, 6, 7, 8]), array([9])]

# 调整数组的形状
arr32 = np.array([1,2,3,4,5,6,7,8,9])
print(arr32.reshape(3,3))# 调整为3x3的矩阵
print(arr32.reshape(3,-1))# 调整为3x3的矩阵，-1表示自适应

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

二. Numpy科学计算综合练习

'''
题目一：温度数据分析
某城市一周的最高气温(。C)为 [28,30,29,31,32,30,29]
- 计算平均气温，最高气温和最低气温
- 找出气温超过30（。C）的天数
'''

import numpy as np
Temp = np.array([28,30,29,31,32,30,29])
print(Temp)
print('平均气温为:%.3f'%np.mean(Temp))
print('最高气温为:',np.max(Temp))
print('最低气温为:',np.min(Temp))
print('\n')
#方法1：
print('气温超过30度的天数:')
print(Temp[Temp>30])# 取出Temp中大于30的元素
print(len(Temp[Temp>30]))
print('\n')
#方法2：
print(np.where(Temp>30,1,0))# 取出Temp中大于30的元素，并将其值设置为0
print(np.sum(np.where(Temp>30,1,0)))# 计算大于30的元素的个数
print('\n')
#方法3：
print(np.count_nonzero(Temp>30))# 计算大于30的元素的个数

[28 30 29 31 32 30 29]
平均气温为:29.857
最高气温为: 32
最低气温为: 28


气温超过30度的天数:
[31 32]
2


[0 0 0 1 1 0 0]
2


2

'''
题目二: 学生考试成绩统计
某班级 5 名学生的数学成绩为 [85,90,78,92,88]
---计算成绩的平均分，中位数，和标准差
---将成绩转换为十分制（假设满分为10）
'''

import numpy as np
math_score = np.array([85,90,78,92,88])
print('数学成绩为：',math_score)
print('\n')

# 计算平均分
avg_score = np.mean(math_score)
print('平均分为：',avg_score)
print('\n')

# 计算中位数
median_score = np.median(math_score)
print('中位数为：',median_score)
print('\n')

# 计算标准差
std_score = np.std(math_score)
print('标准差为：',std_score)
print('\n')

# 将成绩转换为十分制
math_score_percent = math_score/10
print('数学成绩转换为十分制：',math_score_percent)
print('\n')
# 计算十分制平均分
avg_score_percent = np.mean(math_score_percent)
print('百分制平均分为：',avg_score_percent)

数学成绩为： [85 90 78 92 88]


平均分为： 86.6


中位数为： 88.0


标准差为： 4.882622246293481


数学成绩转换为十分制： [8.5 9.  7.8 9.2 8.8]


百分制平均分为： 8.66

'''
题目三：矩阵运算
给定矩阵  = [[1,2],[3,4]] and B = [[5,6],[7,8]]
---计算 A+B  and A*B(逐元素相乘)
---计算 A*B(矩阵乘法)
'''

import numpy as np
A = np.array([[1,2],[3,4]])
B = np.array([[5,6],[7,8]])
print('矩阵A:')
print(A)
print('矩阵B:')
print(B)
print('\n')

# 计算 A+B
C = A + B
print('矩阵A+B:')
print(C)
print('\n')

# 计算 A*B(逐元素相乘)
D = A * B
print('矩阵A*B(逐元素相乘)：')
print(D)
print('\n')

# 计算 A*B(矩阵乘法)
E = np.dot(A,B)
print('矩阵A*B(矩阵乘法)：')
print(E)

矩阵A:
[[1 2]
 [3 4]]
矩阵B:
[[5 6]
 [7 8]]


矩阵A+B:
[[ 6  8]
 [10 12]]


矩阵A*B(逐元素相乘)：
[[ 5 12]
 [21 32]]


矩阵A*B(矩阵乘法)：
[[19 22]
 [43 50]]

'''
题目四:随机数据生成
生成一个（3,4）的随机整数数组，范围为[0,10)
---计算每列的最大值和每行的最小值
---将数组中的所有奇数替换为1
'''

import numpy as np
np.random.seed(0)# 设置随机数种子---保证每次生成的随机数相同
A = np.random.randint(0,10,(3,4))
print('随机整数数组：')
print(A)
print('\n')

print('计算每列的最大值：')
print(np.max(A,axis=0))# 按列求最大值--axis=0表示列
print('\n')

print('计算每行的最小值：')
print(np.min(A,axis=1))# 按行求最小值----axis=1表示行
print('\n')

print('将数组中的所有奇数替换为1：')
# 方法1：
A[A%2==1] = 1# 将数组中所有奇数设置为1---原数组A会改变
print(A)
print('\n')
# 方法2：
np.random.seed(0)# 设置随机数种子---保证每次生成的随机数相同
A1 = np.random.randint(0,10,(3,4))
A1 = np.where(A1%2==1,1,A1)# 将数组中所有奇数设置为1---返回新的数组
print(A1)
print('\n')

随机整数数组：
[[5 0 3 3]
 [7 9 3 5]
 [2 4 7 6]]


计算每列的最大值：
[7 9 7 6]


计算每行的最小值：
[0 3 2]


将数组中的所有奇数替换为1：
[[1 0 1 1]
 [1 1 1 1]
 [2 4 1 6]]


[[1 0 1 1]
 [1 1 1 1]
 [2 4 1 6]]

'''
题目五:数组的变形
创建一个1->12的一维数组，并将其转换为(3,4)的二维数组
---计算每行的和与每列的平均值
---将数组展开为一维数组
'''

import numpy as np

A = np.arange(1,13)# 创建1->12的一维数组[1,2,3,4,5,6,7,8,9,10,11,12]
print('一维数组：')
print(A)
print('\n')
B = A.reshape(3,4)
print(B)
print('\n')

print('计算每行的和：')
print(np.sum(B,axis=1))
print('\n')

print('计算每列的平均值：')
print(np.mean(B,axis=0))
print('\n')

print('将数组展开为一维数组：')
print(np.reshape(B,(12)))
print(B.flatten())
print('\n')

一维数组：
[ 1  2  3  4  5  6  7  8  9 10 11 12]


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


计算每行的和：
[10 26 42]


计算每列的平均值：
[5. 6. 7. 8.]


将数组展开为一维数组：
[ 1  2  3  4  5  6  7  8  9 10 11 12]
[ 1  2  3  4  5  6  7  8  9 10 11 12]

'''
题目六: 布尔索引
生成一个（5,5）的随机数组，范围为[0,20)
---找出数组中大于10的元素
---将所有大于10的元素设置为0
'''

import numpy as np
np.random.seed(1)# 设置随机数种子---保证每次生成的随机数相同
C = np.random.randint(0,20,(5,5))
print('随机数组：')
print(C)
print('\n')

print('找出数组中大于10的元素：')
print(C[C>10])
print('\n')

print('将所有大于10的元素设置为0：')
C[C>10] = 0# 将数组中大于10的元素设置为0
print(C)
print('\n')

随机数组：
[[ 5 11 12  8  9]
 [11  5 15  0 16]
 [ 1 12  7 13  6]
 [18  5 18 11 10]
 [14 18  4  9 17]]


找出数组中大于10的元素：
[11 12 11 15 16 12 13 18 18 11 14 18 17]


将所有大于10的元素设置为0：
[[ 5  0  0  8  9]
 [ 0  5  0  0  0]
 [ 1  0  7  0  6]
 [ 0  5  0  0 10]
 [ 0  0  4  9  0]]

'''
题目七:统计函数应用
某公司六个月的销售额(万元)为[120,135,110,125,130,140]
---计算销售额的总和，均值和方差
---找出销售额最高的月份和最低的月份
'''

import numpy as np
sales = np.array([120,135,110,125,130,140])
print('销售额(万元)：')
print(sales)
print('\n')

print('计算销售额的总和：')
total_sales = np.sum(sales)
print('总销售额(万元)：',total_sales)
print('\n')

print('计算销售额的均值：')
mean_sales = np.mean(sales)
print('平均销售额(万元)：',mean_sales)
print('\n')

print('计算销售额的方差：')
var_sales = np.var(sales)
print('方差(万元)：',var_sales)
print('\n')

print('找出销售额最高的月份：')
max_month = np.argmax(sales)# 返回最大值的索引
print('最高月份：',max_month+1)
print('\n')

print('找出销售额最低的月份：')
min_month = np.argmin(sales)# 返回最小值的索引
print('最低月份：',min_month+1)
print('\n')

销售额(万元)：
[120 135 110 125 130 140]


计算销售额的总和：
总销售额(万元)： 760


计算销售额的均值：
平均销售额(万元)： 126.66666666666667


计算销售额的方差：
方差(万元)： 97.22222222222223


找出销售额最高的月份：
最高月份： 6


找出销售额最低的月份：
最低月份： 3

'''
题目八:数组拼接
给定A = [1,2,3] and B = [4,5,6]
---将A和B水平拼接位一个数组
---将A和B竖直拼接位一个数组
'''

import numpy as np
A = np.array([1,2,3])
B = np.array([4,5,6])
print('数组A：')
print(A)
print('数组B：')
print(B)
print('\n')

print('水平拼接：')
# 方法1：
print(np.hstack((A,B)))# 按行拼接-----返回拼接后的数组
print('\n')
# 方法2：
C = np.concatenate((A,B))
print(C)
print('\n')

print('竖直拼接：')
# 方法1：
print(C.reshape(2,3))
print('\n')
# 方法2：
D = np.vstack((A,B))
print(D)
print('\n')

数组A：
[1 2 3]
数组B：
[4 5 6]


水平拼接：
[1 2 3 4 5 6]


[1 2 3 4 5 6]


竖直拼接：
[[1 2 3]
 [4 5 6]]


[[1 2 3]
 [4 5 6]]

'''
题目九：唯一值与排序
给定数组[2,1,2,3,1,4,3]
---找出数组中的唯一值并排序
---计算每个唯一值出现的次数
'''

import numpy as np
arr = np.array([2,1,2,3,1,4,3])
print('数组：')
print(arr)
print('\n')

print('找出数组中的唯一值并排序：')
unique_arr,counts = np.unique(arr,return_counts=True)# 找出数组中的唯一值---返回排序后的数组
print('唯一值：',unique_arr)# 找出数组中的唯一值
print('每个唯一值出现的次数：',counts)# 计算每个唯一值出现的次数
print('\n')

print('计算每个唯一值出现的次数：')
count_arr = np.bincount(arr)
print('每个唯一值出现的次数：',count_arr)
print('\n')

数组：
[2 1 2 3 1 4 3]


找出数组中的唯一值并排序：
唯一值： [1 2 3 4]
每个唯一值出现的次数： [2 2 2 1]


计算每个唯一值出现的次数：
每个唯一值出现的次数： [0 2 2 2 1]

'''
题目十:综合应用
某商店 5 天的销售额(万元)和成本(万元)如下:
销售额:[20,25,22,30,28]
成本:[15,18,16,22,20]
--计算每天的利润(利润=销售额-成本)
--计算利润的平均值和标准差
--找出利润最高的天数

'''

import numpy as np
sales = np.array([20,25,22,30,28])
cost = np.array([15,18,16,22,20])
print('销售额(万元)：')
print(sales)
print('\n')
print('成本(万元)：')
print(cost)
print('\n')

print('计算每天的利润(利润=销售额-成本)：')
profit = sales - cost
print('利润(万元)：',profit)
print('\n')

print('计算利润的平均值和标准差：')
mean_profit = np.mean(profit)
std_profit = np.std(profit)
print('平均利润(万元)：',mean_profit)
print('标准差(万元)：',std_profit)
print('\n')

print('找出利润最高的天数：')
max_profit = np.max(profit)
print('利润最高的天数：',len(profit[profit==max_profit]))# 计算利润最高的天数
print('\n')

销售额(万元)：
[20 25 22 30 28]


成本(万元)：
[15 18 16 22 20]


计算每天的利润(利润=销售额-成本)：
利润(万元)： [5 7 6 8 8]


计算利润的平均值和标准差：
平均利润(万元)： 6.8
标准差(万元)： 1.16619037896906


找出利润最高的天数：
利润最高的天数： 2