numpy学习记录

标签：--------------------------------------------------------------------------------

一、库的导入

import numpy as np

二、python原生列表与numpy中的n维数组（ndarray）

1、一维列表与ndarray的转换

list1 = [1, 2, 3, 4, 5]
print(list1)
print(type(list1))

# 列表转ndarray
oneArrary = np.array(list1)
print(oneArrary)
print(type(oneArrary))

输出结果：

[1, 2, 3, 4, 5]
<class 'list'>

[1 2 3 4 5]
<class 'numpy.ndarray'>

 2、列表与ndarray的效率对比

import random
import time
import numpy as np

# 随机1亿个数据
a = [random.random() for i in range(10 ** 8)]
print("随机完毕")

b = np.array(a)  # 转换为ndarray
print("转为ndarray完毕")

# ndarray的计算效率要比python原生list高很多
start_time = time.time()
sum1 = sum(a)
end_time = time.time()
print("python原生list的计算时间:", end_time - start_time)

start_time = time.time()
sum2 = np.sum(b)
end_time = time.time()
print("ndarray的计算时间:", end_time - start_time)

输出结果：

随机完毕

转为ndarray完毕

python原生list的计算时间: 0.44520044326782227
ndarray的计算时间: 0.14983391761779785

3、二维列表转ndarray

# 二维列表转ndarray
import numpy as np

list2 = [[1, 2], [3, 4], [5, 6]]
twoArray = np.array(list2)
print(type(twoArray))
print("-" * 100)
print(twoArray)
print("-" * 100)
print(list2)
print("-" * 100)
print(twoArray.tolist()) # ndarray转换为列表，无论是几维数组都可以转换为列表

输出结果：

<class 'numpy.ndarray'>
----------------------------------------------------------------------------------------------------
[[1 2]
 [3 4]
 [5 6]]
----------------------------------------------------------------------------------------------------
[[1, 2], [3, 4], [5, 6]]

----------------------------------------------------------------------------------------------------

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

三、ndarray的常用属性

# 看ndarray的各种属性
list2 = [[1, 2], [3, 4], [5, 6]]

twoArray = np.array(list2)

# 获取数组的维度
print(twoArray.ndim)

# 获取数组的形状
print(twoArray.shape)

# 获取数组的元素总数
print(twoArray.size)

# 获取数组的元素类型
print(twoArray.dtype)  # 默认int32,4字节,数据范围[-2147483648, 2147483647]

输出结果：

2
(3, 2)
6
int32

四、调整数组的形状

1、ndarray是可变类型

import numpy as np


# 通过修改shape不会分配新的内存
four = np.array([[1, 2, 3], [4, 5, 6]])
print(four)
print("-" * 100)
# ndarray也是可变数据类型
four1 = four
print(id(four1))
print("-" * 100)
four.shape = (3, 2)  # 改变数组的形状，变为三行两列
print(four)
print(id(four))
print(id(four1))  # 数组的id不变
print("-" * 100)

# 返回一个新数组，reshape后id和之前的不一样
four2 = four.reshape(2, 3)
print(id(four))
print(id(four2))
print(four2)

print("-" * 100)

# 将多维编程一维数组
five = four.reshape((6,), order='C')  # order='C'表示按行优先，'F'表示按列优先

six = four.flatten()  # 展平数组
print(five)
print(type(five))
print(five.shape)
print("-" * 100)
print(six)
print(type(six))
print(six.shape)
print("-" * 100)

seven = five.reshape(3, 2)
print(seven)

输出结果：

[[1 2 3]
 [4 5 6]]
----------------------------------------------------------------------------------------------------
2216321346032
----------------------------------------------------------------------------------------------------
[[1 2]
 [3 4]
 [5 6]]
2216321346032
2216321346032
----------------------------------------------------------------------------------------------------
2216321346032
2216321450128
[[1 2 3]
 [4 5 6]]
----------------------------------------------------------------------------------------------------
[1 2 3 4 5 6]
<class 'numpy.ndarray'>
(6,)
----------------------------------------------------------------------------------------------------
[1 2 3 4 5 6]
<class 'numpy.ndarray'>
(6,)
----------------------------------------------------------------------------------------------------
[[1 2]
 [3 4]
 [5 6]]

2、改变ndarray的形状和维数

import numpy as np

t = np.arange(24)
print(t)
print(f"shape: {t.shape}")
print(f"ndim: {t.ndim}")
print("-" * 100)
# 转换成二维
t1 = t.reshape((4, 6))
print(t1)
print(f"shape: {t1.shape}")
print(f"ndim: {t1.ndim}")
print("-" * 100)
# 转换成三维
# 最前面的是0轴，后面的是1轴，2轴
t2 = t1.reshape((2, 3, 4))
print(t2)
print(t2.shape)
print(t2.ndim)

输出结果：

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
shape: (24,)
ndim: 1
----------------------------------------------------------------------------------------------------
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
shape: (4, 6)
ndim: 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]]]
(2, 3, 4)
3

五、numpy的数据类型

1、numpy中的数据可设置类型

import numpy as np

# 返回数组中每个元素的字节单位长度，dtype设置数据类型
f = np.array([1, 2, 3, 4, 127], dtype=np.int8)
print(f.itemsize)  # f.itemsize是int8的字节单位长度
# 获取数据类型
print(f.dtype)
print("-" * 100)
print(f)
f[4] += 1  # 修改数组元素
print(f[4])  # 发生溢出
print("-" * 100)

# 调整数据类型
f1 = f.astype(np.int64)  # 转换为int16类型
print(f1.dtype)
print(f1.itemsize) # 数组中每个元素的字节数
print('-' * 100)

# np.float16 半精度
arr = np.array([np.random.random() for i in range(10)])
print(arr)
print(arr.dtype)
print(arr.itemsize)
# 去小数点后两位
# 这里的round()跟python的round()方法不一样，是numpy的函数
# round(浮点数, 保留几位小数)
print(np.round(arr, 2))

输出结果：

1
int8
----------------------------------------------------------------------------------------------------
[  1   2   3   4 127]
-128
----------------------------------------------------------------------------------------------------
int64
8
----------------------------------------------------------------------------------------------------
[0.15037276 0.11349101 0.99236528 0.24160144 0.16387933 0.03918661
 0.86973957 0.63909148 0.31000019 0.81043944]
float64
8
[0.15 0.11 0.99 0.24 0.16 0.04 0.87 0.64 0.31 0.81]

六、ndarray和ndarray的运算

1、维度（ndim）相同时

a、形状（shape）相同可进行加减乘除操作（对应元素）

import numpy as np

# 形状相同，才可以进行加减乘除
t1 = np.arange(24).reshape((6, 4))
t2 = np.arange(100, 124).reshape((6, 4))
print(t1)
print("-" * 100)
print(t2)
print("-" * 100)
print(t1 + t2)
print("-" * 100)
print(t1 * t2)  # 对应元素相乘

输出结果：

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]
 [16 17 18 19]
 [20 21 22 23]]
----------------------------------------------------------------------------------------------------
[[100 101 102 103]
 [104 105 106 107]
 [108 109 110 111]
 [112 113 114 115]
 [116 117 118 119]
 [120 121 122 123]]
----------------------------------------------------------------------------------------------------
[[100 102 104 106]
 [108 110 112 114]
 [116 118 120 122]
 [124 126 128 130]
 [132 134 136 138]
 [140 142 144 146]]
----------------------------------------------------------------------------------------------------
[[   0  101  204  309]
 [ 416  525  636  749]
 [ 864  981 1100 1221]
 [1344 1469 1596 1725]
 [1856 1989 2124 2261]
 [2400 2541 2684 2829]]

b、形状（shape）不同时，可以进行加减乘除操作的情况

总结：当维数（ndim）相同，形状（shape）不同时还能进行加减乘除运算，则数组之间只有一个轴的size不同，且低维数组在该轴的size必须是1

import numpy as np

# 此处就是广播机制的应用
# 一维数组和二维数组运算时，一维的元素个数和列数相同
t1 = np.arange(24).reshape((4, 6))  # 四行六列
t2 = np.arange(6).reshape((1, 6))  # 一行六列
print(t1)
print("-" * 100)
print(t2)
print("-" * 100)
# 在底层中，广播机制会将低纬数组拓展为高维数组然后计算
# 即低纬的t2会被复制拓展为4行6列，然后再跟t1进行运算
print(t1 - t2)
print("-" * 100)
print((t1 - t2).shape)
print("-" * 100)
print(t2 - t1)
print("-" * 100)
print((t2 - t1).shape)
print("-" * 100)
# 随机三维数组
a = np.arange(24).reshape((2, 3, 4))
b = np.arange(12).reshape((1, 3, 4))
print(a - b)

输出结果：

 [[ 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]]
----------------------------------------------------------------------------------------------------
[[ 0  0  0  0  0  0]
 [ 6  6  6  6  6  6]
 [12 12 12 12 12 12]
 [18 18 18 18 18 18]]
----------------------------------------------------------------------------------------------------
(4, 6)
----------------------------------------------------------------------------------------------------
[[  0   0   0   0   0   0]
 [ -6  -6  -6  -6  -6  -6]
 [-12 -12 -12 -12 -12 -12]
 [-18 -18 -18 -18 -18 -18]]
----------------------------------------------------------------------------------------------------
(4, 6)
----------------------------------------------------------------------------------------------------

[[[ 0  0  0  0]
  [ 0  0  0  0]
  [ 0  0  0  0]]

 [[12 12 12 12]
  [12 12 12 12]
  [12 12 12 12]]]

c、形状（shape）不同时，不能进行加减乘除操作的情况

t1 = np.arange(24).reshape((4, 6))
t2 = np.arange(18).reshape((3, 6))
print(t1 - t2)  # 形状不同，维度相同，但是低维数组的行数不为1，执行报错

输出结果：

Traceback (most recent call last):
  File "D:/PyProject/temp.py", line 5, in <module>
    print(t1 - t2)  # 形状不同，不能进行加减乘除
ValueError: operands could not be broadcast together with shapes (4,6) (3,6)

2、维度（ndim）不同时

import numpy as np

# 进行 维度不同的数组运算 时，低维度的大小必须相同
t1 = np.arange(24).reshape(4, 6)  # 二维数据 4行6列
t2 = np.arange(6)  # 一维数据
t3 = np.arange(48).reshape(2, 4, 6)  # 三维数据
print(t1.shape)
print(t2.shape)
print("-" * 100)
print(t1)
print("-" * 100)
print(t2)
print("-" * 100)
print(t1 - t2)  # 广播机制在计算时会将t2转化为1行6列
print("-" * 100)
print(t2 - t1)
print("-" * 100)
print(t3)
print("-" * 100)
print(t3 - t2) # 广播机制在计算时会将t2的shape转化为(1,1,6)
print("-" * 100)

输出结果：

(4, 6)
(6,)
----------------------------------------------------------------------------------------------------
[[ 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]
----------------------------------------------------------------------------------------------------
[[ 0  0  0  0  0  0]
 [ 6  6  6  6  6  6]
 [12 12 12 12 12 12]
 [18 18 18 18 18 18]]
----------------------------------------------------------------------------------------------------
[[  0   0   0   0   0   0]
 [ -6  -6  -6  -6  -6  -6]
 [-12 -12 -12 -12 -12 -12]
 [-18 -18 -18 -18 -18 -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]]

 [[24 25 26 27 28 29]
  [30 31 32 33 34 35]
  [36 37 38 39 40 41]
  [42 43 44 45 46 47]]]
----------------------------------------------------------------------------------------------------
[[[ 0  0  0  0  0  0]
  [ 6  6  6  6  6  6]
  [12 12 12 12 12 12]
  [18 18 18 18 18 18]]

 [[24 24 24 24 24 24]
  [30 30 30 30 30 30]
  [36 36 36 36 36 36]
  [42 42 42 42 42 42]]]
----------------------------------------------------------------------------------------------------

七、轴axis的选择

import numpy as np

# axis选择对行还是哪个轴进行操作，axis越小就代表是越外围的轴

a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
print("-" * 100)
print(np.sum(a, axis=0))  # 按列求和
print("-" * 100)
print(np.sum(a, axis=1))  # 按行求和
print("-" * 100)
print(np.sum(a))  # 所有元素求和

输出结果：

[[1 2 3]
 [4 5 6]]
----------------------------------------------------------------------------------------------------
[5 7 9]
----------------------------------------------------------------------------------------------------
[ 6 15]
----------------------------------------------------------------------------------------------------
21

八、索引和切片

1、连续取值

import numpy as np

# 对一维数组的索引和切片
a = np.arange(10)
# 如果只放置一个参数，如[2]，将返回与该索引对应的单个元素
print(a[0], a)
# 如果为[2:]，表示从该索引开始到结尾的所有元素
print(a[2:])

print(a[2:8:2])  # 切片是左闭右开的
print(a[::-1])  # 逆序
print("-" * 100)

# 对二维数组的索引和切片
t1 = np.arange(24).reshape((4, 6))
print(t1)
print("-" * 100)
print(t1[1])
print("-" * 100)
print(t1[1:])
print("-" * 100)
print(t1[1:3, :])  # 第一个维度是行，第二个维度是列，表示从1行到3行，所有列
print("-" * 100)
print(t1[[0, 2, 3]])  # 选中第0，2，3行，没有设置列，默认选中所有列

输出结果：

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

2、非连续取值

import numpy as np

# 对二维数组的索引和切片
t1 = np.arange(24).reshape((4, 6))
print(t1[:, [0, 2, 3]]) # 所有行，第0,2,3列
print("-" * 100)
print(t1[2, 3]) # 取出特定位置元素
print("-" * 100)
# 选中的三个元素分别是(0,0), (1,1), (1,3)，行列参数数量要相同
print(t1[[0, 1, 1], [0, 1, 3]]) # 离散取值

输出结果：

[[ 0  2  3]
 [ 6  8  9]
 [12 14 15]
 [18 20 21]]
----------------------------------------------------------------------------------------------------
15
----------------------------------------------------------------------------------------------------
[0 7 9]

九、数组中的数值修改

1、常用方法

import numpy as np

t = np.arange(24).reshape((4, 6))
print(t)
print(id(t))
print("-" * 100)

# 修改某一行的值
t[1, :] = 0
print(t)
print("-" * 100)

# 修改某一列的值
t[:, 2] = 1000
print(t)
print("-" * 100)

# 修改连续多行的值
t[1:3, :] = 999
print(t)
print("-" * 100)

# 修改多行多列，取第二行到第四行，第三列到第五列
t[1:4, 2:5] = 888
print(t)
print("-" * 100)

# 修改多个不相邻的点
t[[0, 2], [1, 3]] = 777
print(t)
print("-" * 100)

# 根据条件修改
t[(t > 777) & (t < 999)] = 666
print(t)
print("-" * 100)

# ~ 代表取反
# print(t > 6) # 数组通过条件判断得到的相同维度的bool数组
# print("-" * 100)
t[~(t > 6)] = 0
print(t)
print("-" * 100)

# 使用逻辑判断修改
# t中大于11小于16的元素为True，其余为False，out=t表示将结果赋值给t
# np.logical_and(t > 11, t < 16, out=t)
# print(t)
# print("-" * 100)

# np.logical_or(t > 11, t < 16, out=t)
# print(t)
# print("-" * 100)


# clip()方法把大于10的元素替换为10，小于0的元素替换为0
t.clip(0, 10, out=t)
print(t)
print(id(t)) # 经过上面这么多变化，其实t的内存地址还是原来的

print("-" * 100)

输出结果：

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
1861142996816
----------------------------------------------------------------------------------------------------
[[ 0  1  2  3  4  5]
 [ 0  0  0  0  0  0]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
----------------------------------------------------------------------------------------------------
[[   0    1 1000    3    4    5]
 [   0    0 1000    0    0    0]
 [  12   13 1000   15   16   17]
 [  18   19 1000   21   22   23]]
----------------------------------------------------------------------------------------------------
[[   0    1 1000    3    4    5]
 [ 999  999  999  999  999  999]
 [ 999  999  999  999  999  999]
 [  18   19 1000   21   22   23]]
----------------------------------------------------------------------------------------------------
[[   0    1 1000    3    4    5]
 [ 999  999  888  888  888  999]
 [ 999  999  888  888  888  999]
 [  18   19  888  888  888   23]]
----------------------------------------------------------------------------------------------------
[[   0  777 1000    3    4    5]
 [ 999  999  888  888  888  999]
 [ 999  999  888  777  888  999]
 [  18   19  888  888  888   23]]
----------------------------------------------------------------------------------------------------
[[   0  777 1000    3    4    5]
 [ 999  999  666  666  666  999]
 [ 999  999  666  777  666  999]
 [  18   19  666  666  666   23]]
----------------------------------------------------------------------------------------------------
[[   0  777 1000    0    0    0]
 [ 999  999  666  666  666  999]
 [ 999  999  666  777  666  999]
 [  18   19  666  666  666   23]]
----------------------------------------------------------------------------------------------------
[[ 0 10 10  0  0  0]
 [10 10 10 10 10 10]
 [10 10 10 10 10 10]
 [10 10 10 10 10 10]]
1861142996816
----------------------------------------------------------------------------------------------------

2、拓展：三目运算符

import numpy as np

# python的三目运算符
a = 10
b = 15
c = a if a > b else b
print(c)
print("-" * 100)

# 三目运算函数（np.where(condition, x, y)）满足条件(condition),输出x,否则输出y
score = np.array([[85, 90], [82, 81], [75, 81]])
print(score)
print("-" * 100)
result = np.where(score < 80, True, False)
print(result)
print("-" * 100)
score[result] = 0  # 将result为True的元素的位置赋值为0
print(score)
print("-" * 100)

输出结果：

15
----------------------------------------------------------------------------------------------------
[[85 90]
 [82 81]
 [75 81]]
----------------------------------------------------------------------------------------------------
[[False False]
 [False False]
 [ True False]]
----------------------------------------------------------------------------------------------------
[[85 90]
 [82 81]
 [ 0 81]]
----------------------------------------------------------------------------------------------------

十、数据的添加、删除、去重

1、数据的添加：numpy.append()

# 1 numpy.append() 函数在数组的末尾添加元素。追加操作会分配新的内存，并复制原数组中的元素。
# 此外，输入数组的维度必须匹配否则会报错。添加到哪个轴，哪个轴的长度就发生改变
"""
参数说明：
axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）
"""
import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
print(a.shape)
print("-" * 100)
# axis=0时，代表添加在第0轴，第1轴的长度要相同
b = np.append(a, [[7, 8, 9]], axis=0)
print(b)
print(b.shape)
print("-" * 100)
# axis=1时，代表添加到第1轴，第0轴的长度要相同
c = np.append(a, [[7, 8, 9], [10, 11, 12]], axis=1)
print(c)
print(c.shape)
print("-" * 100)

print("向数组添加元素：")
# 如果不指定axis，则原数组和要追加的数组都会被展平为一维数组，最后进行普通的相加
print(np.append(a, [[7, 8, 9]]))
print("-" * 100)
print(a)
print("-" * 100)

输出结果：

[[1 2 3]
 [4 5 6]]
(2, 3)
----------------------------------------------------------------------------------------------------
[[1 2 3]
 [4 5 6]
 [7 8 9]]
(3, 3)
----------------------------------------------------------------------------------------------------
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]
(2, 6)
----------------------------------------------------------------------------------------------------
向数组添加元素：
[1 2 3 4 5 6 7 8 9]
----------------------------------------------------------------------------------------------------
[[1 2 3]
 [4 5 6]]
----------------------------------------------------------------------------------------------------

2、数据插入：numpy.insert()

a、基本操作

import numpy as np

# numpy.insert()
# 函数在给定索引之前，沿给定轴在输入数组中插入值
# 函数在数组的指定位置插入元素。插入操作会分配新的内存，并复制原数组中的元素。
a = np.array([[1, 2], [3, 4], [5, 6]])
print("第一个数组：")
print(a)
print("-" * 100)

print("未传递axis参数。在插入之前输入数组会被展平")
print(np.insert(a, 1, [11, 22]))
print("-" * 100)

# 将[11,12]作为元素插入，由axis=0插入到第0轴
print(np.insert(a, 1, [11, 12], axis=0))  # 哪个轴插入，哪个轴的size就变大
print("-" * 100)

# [[1,2,3]]相当于将[1,2,3]作为元素
print(np.insert(a, 0, [[11, 22, 33]], axis=1))
# print(np.insert(a, 0, [11,22,33], axis=1)) # 写入的是一维数组，底层同样会调整为三行一列
print("-" * 100)

print("沿轴0广播")
print(np.insert(a, 1, 11, axis=0))
print("-" * 100)
print("沿轴1广播")
print(np.insert(a, 1, 11, axis=1))

输出结果：

 第一个数组：
[[1 2]
 [3 4]
 [5 6]]
----------------------------------------------------------------------------------------------------
未传递axis参数。在插入之前输入数组会被展平
[ 1 11 22  2  3  4  5  6]
----------------------------------------------------------------------------------------------------
[[ 1  2]
 [11 12]
 [ 3  4]
 [ 5  6]]
----------------------------------------------------------------------------------------------------
[[11  1  2]
 [22  3  4]
 [33  5  6]]
----------------------------------------------------------------------------------------------------
沿轴0广播
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]
----------------------------------------------------------------------------------------------------
沿轴1广播
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]

 b、拓展问题

import numpy as np

a = np.array([[1, 2], [3, 4], [5, 6]])
b = np.array([10, 11, 12]).reshape(3, 1)
print(a)
print("-" * 100)
print(b)
print("-" * 100)
# insert操作会将b中的每个元素[10],[11],[12]分别按照axis=1插入到a中
# 所以相当于分别进行了三次广播操作，将[10],[11],[12]插入到a中，所以没有得到预期
print(np.insert(a, 0, b, axis=1))
print("-" * 100)
# 预期得到结果：

[[10  1  2]
 [11  3  4]
 [12  5  6]]

# 实际得到结果：
[[10 11 12  1  2]
 [10 11 12  3  4]
 [10 11 12  5  6]]

输出结果：

[[1 2]
 [3 4]
 [5 6]]
----------------------------------------------------------------------------------------------------
[[10]
 [11]
 [12]]
----------------------------------------------------------------------------------------------------
[[10 11 12  1  2]
 [10 11 12  3  4]
 [10 11 12  5  6]]

问题：为什么明明提前做了reshape将b转换为3行1列了，插入后得到的却不是我们所想的矩阵呢？

numpy.insert(原数组, 插入位置, 插入元素（数组）, axis)，其中插入的如果是数组，则数组中的的每个[ ]都相当于要插入到该位置的元素，所以有多少个[ ]，则会有多少次插入操作，对于上面的例子，由于b实际是3行1列数组，故有3个[ ]，则会重复进行3次不同元素的插入操作，最终得到的结果才会与我们的预期不符合

3、数据删除

# numpy.delete() 函数删除数组中的元素。删除操作会分配新的内存，并复制原数组中的元素。
# 参数说明：
# 第一个参数：输入数组
# 第二个参数：索引，可以是整数，也可以是整数数组。如果是整数，表示删除指定位置的元素；如果是整数数组，表示删除指定位置的元素。
# 第三个参数：axis，表示删除的轴。
import numpy as np

a = np.arange(24).reshape(4, 6)
print(a)
print("-" * 100)

print("未传递axis参数。在删除之前输入数组会被展平")
print(np.delete(a, 9))
print("-" * 100)

print("删除第一行")
print(np.delete(a, 1, axis=0))
print("-" * 100)

print("删除第零列")
print(np.delete(a, 0, axis=1))
print("-" * 100)

输出结果：

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
----------------------------------------------------------------------------------------------------
未传递axis参数。在删除之前输入数组会被展平
[ 0  1  2  3  4  5  6  7  8 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
----------------------------------------------------------------------------------------------------
删除第一行
[[ 0  1  2  3  4  5]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
----------------------------------------------------------------------------------------------------
删除第零列
[[ 1  2  3  4  5]
 [ 7  8  9 10 11]
 [13 14 15 16 17]
 [19 20 21 22 23]]
----------------------------------------------------------------------------------------------------

4、数据去重

# numpy.unique() 函数用于去除数组中的重复元素，并返回不重复元素组成的新数组。
# 参数说明：
# 第一个参数：输入数组
# 第二个参数：axis，表示去除重复元素的轴。
"""
arr:输入数组。
return_index：如果为True，返回索引数组，否则不返回。
return_inverse：如果为True，返回反向索引数组，否则不返回。
return_counts：如果为True，返回重复元素的计数，否则不返回。
"""

import numpy as np

a = np.array([1, 2, 3, 2, 4, 1, 5, 6, 5, 1, 2, 3, 4, 5, 6])
print("第一个数组：")
print(a)
print("-" * 100)

# 去除重复元素，输出的是有序数组
print("第一个数组的去重值：")
u = np.unique(a)
print(u)
print("-" * 100)

print("去重数组的索引数组：")
u, indices = np.unique(a, return_index=True)
print(u)
print("去重后数组每个元素在未去重数组的位置：")
print(indices)
print("-" * 100)

u, indices = np.unique(a, return_inverse=True)
print(u)
print("去重前数组每个元素在去重后数组的位置：")
print(indices)
print("-" * 100)

输出结果：

第一个数组：
[1 2 3 2 4 1 5 6 5 1 2 3 4 5 6]
----------------------------------------------------------------------------------------------------
第一个数组的去重值：
[1 2 3 4 5 6]
----------------------------------------------------------------------------------------------------
去重数组的索引数组：
[1 2 3 4 5 6]
去重后数组每个元素在未去重数组的位置：
[0 1 2 4 6 7]
----------------------------------------------------------------------------------------------------
[1 2 3 4 5 6]
去重前数组每个元素在去重后数组的位置：
[0 1 2 1 3 0 4 5 4 0 1 2 3 4 5]
----------------------------------------------------------------------------------------------------

十一、numpy的数学计算

1、常用方法

import numpy as np

score = np.array([[85, 90], [82, 81], [75, 81]])
print(score)
print("-" * 100)

# 1 获取所有数据最大值
result = np.max(score)
print(result)
print("-" * 100)
# 2 获取某个轴上数据最大值
result = np.max(score, axis=1)
print(result)
print("-" * 100)
# 3 获取最小值
result = np.min(score)
print(result)
print("-" * 100)
# 4 获取某一个轴上的数据最小值
result = np.min(score, axis=0)
print(result)
print("-" * 100)
# 5 数据的比较
print("数据比较：maximum和minimum")
result = np.maximum([-2, -1, 0, 1, 2], 0)  # 第一个参数中的每一个数与第二个参数中的数比较，返回较大的数
print(result)
result = np.minimum([-2, -1, 0, 1, 2], 0)  # 第一个参数中的每一个数与第二个参数中的数比较，返回较小的数
print(result)
result = np.maximum([-2, -1, 5, 1, 2], [1, 2, 3, 4, 5])
print(result)
print("-" * 100)

# 6 求平均值
print("求平均值")
result = np.mean(score)
print(result)
print("-" * 100)
result = np.mean(score, axis=0)
print(result)
print("-" * 100)

# 7 求前缀和
print("求前缀和：")
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)
print("-" * 100)
print(arr.cumsum(axis=0))
print("-" * 100)

# 8 argmin求最小值的索引
print("argmin求最小值索引：")
result = np.argmin(score, axis=0)  # axis=0表示沿着列求最小值，返回的是索引
res = np.min(score, axis=0)
print(score)
print("-" * 100)
print(result)
print("-" * 100)
print(res)
print("-" * 100)

# 9 求每一列的标准差（这里是总体标准差）
# 标准差是一组数据平均值分散程度的一种度量。一个较大的标准差，代表大部分数值和其平均值的差距较大
# 一个较小的标准差，代表数据集中数值分散较小，代表数据稳定，反之则代表数据不稳定。
print("求每一列的标准差：")
result = np.std(score, axis=0)  # axis=0表示沿着列求标准差
print(result)
print("-" * 100)

# 10 求最大值与最小值的差
print("求最大值与最小值的差：")
result = np.ptp(score, axis=None)  # 求最大值与最小值的差
print(result)

输出结果：

[[85 90]
 [82 81]
 [75 81]]
----------------------------------------------------------------------------------------------------
90
----------------------------------------------------------------------------------------------------
[90 82 81]
----------------------------------------------------------------------------------------------------
75
----------------------------------------------------------------------------------------------------
[75 81]
----------------------------------------------------------------------------------------------------
数据比较：maximum和minimum
[0 0 0 1 2]
[-2 -1  0  0  0]
[1 2 5 4 5]
----------------------------------------------------------------------------------------------------
求平均值
82.33333333333333
----------------------------------------------------------------------------------------------------
[80.66666667 84.        ]
----------------------------------------------------------------------------------------------------
求前缀和：
[[1 2 3]
 [4 5 6]]
----------------------------------------------------------------------------------------------------
[[1 2 3]
 [5 7 9]]
----------------------------------------------------------------------------------------------------
argmin求最小值索引：
[[85 90]
 [82 81]
 [75 81]]
----------------------------------------------------------------------------------------------------
[2 1]
----------------------------------------------------------------------------------------------------
[75 81]
----------------------------------------------------------------------------------------------------
求每一列的标准差：
[4.18993503 4.24264069]
----------------------------------------------------------------------------------------------------
求最大值与最小值的差：
15

2、通用函数

#通用函数：
numpy.sqrt(array)	平方根函数
numpy.exp(array)	e^array[i]的数组
numpy.abs/fabs(array)	计算绝对值
numpy.square(array)	计算各元素的平方 等于array	2
numpy.log/log10/log2(array)	计算各元素的各种对数
numpy.sign(array)	计算各元素正负号
numpy.isnan(array)	计算各元素是否为NaN
numpy.isinf(array)	计算各元素是否为NaN
numpy.cos/cosh/sin/sinh/tan/tanh(array) 三角函数
numpy.modf(array)	将array中值得整数和小数分离，作两个数组返回
numpy.ceil(array)	向上取整,也就是取比这个数大的整数
numpy.floor(array)	向下取整,也就是取比这个数小的整数
numpy.rint(array)	四舍五入
numpy.trunc(array)	向0取整
numpy.cos(array)	正弦值
numpy.sin(array)	余弦值
numpy.tan(array)	正切值

numpy.add(array1,array2)	元素级加法
numpy.subtract(array1,array2)	元素级减法
numpy.multiply(array1,array2)	元素级乘法
numpy.divide(array1,array2)	元素级除法 array1./array2
numpy.power(array1,array2)	元素级指数 array1.^array2
numpy.maximum/minimum(array1,aray2) 元素级最大值
numpy.fmax/fmin(array1,array2)	元素级最大值，忽略NaN
numpy.mod(array1,array2)	元素级求模
numpy.copysign(array1,array2)	将第二个数组中值得符号复制给第一个数组中值
numpy.greater/greater_equal/less/less_equal/equal/not_equal (array1,array2)
元素级比较运算，产生布尔数组
numpy.logical_end/logical_or/logic_xor(array1,array2)元素级的真值逻辑运算
'''

十二、数组的拼接和分割

1、数组拼接

# 有时候我们需要将两个数据加起来一起研究分析，
# 我们就可以将其进行拼接然后分析。
import numpy as np

# 1 根据轴连接的数组序列，concatenate()没有改变原数组的维度
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
c = np.array([[9, 10], [11, 12]])

# 要求a b两个数组在第0轴以外的其他轴的长度要相同
print("沿着轴0连接两个数组：")
print(np.concatenate((a, b), axis=0))  # 写哪个轴哪个轴就发生变化
print("-" * 100)

print("沿着轴1连接三个数组：")
print(np.concatenate((a, b, c), axis=1))
print("-" * 100)

# 堆叠数组，stack()会改变数组的维度，同样要求除拼接轴之外的其他轴的长度要相等
print(np.stack((a, b, c), axis=0))
print(np.stack((a, b, c), axis=0).shape)
print("-" * 100)

# 根据轴进行堆叠，二维会变成三维
arrays = [np.arange(12).reshape(3, 4) for i in range(10)]
print(len(arrays))
print("沿轴0连接两个数组：")
result = np.stack(arrays, axis=0)  # 把列表中的数组元素沿着轴0进行堆叠
print(result)
print(result.shape)
print("-" * 100)

print("沿轴1连接两个数组：")
result = np.stack(arrays, axis=1)
print(result)
print(result.shape)
print("-" * 100)

print("沿轴2连接两个数组：这里的-1和2是等价的")
result = np.stack(arrays, axis=-1)
print(result)
print(result.shape)
print("-" * 100)

# 3 .矩阵垂直拼接，vstack没有增加维度，类似于concatenate(axis=0) -- vertical
v1 = [[0, 1, 2, 3, 4, 5],
      [6, 7, 8, 9, 10, 11]]
v2 = [[12, 13, 14, 15, 16, 17],
      [18, 19, 20, 21, 22, 23]]
result = np.vstack((v1, v2))
print(result)
print("-" * 100)

# 4 .矩阵水平拼接，hstack没有增加维度，类似于concatenate(axis=1) -- horizontal
h1 = [[0, 1, 2, 3, 4, 5],
      [6, 7, 8, 9, 10, 11]]
h2 = [[12, 13, 14, 15, 16, 17],
      [18, 19, 20, 21, 22, 23]]
result = np.hstack((h1, h2))
print(result)
print("-" * 100)

输出结果：

沿着轴0连接两个数组：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
----------------------------------------------------------------------------------------------------
沿着轴1连接三个数组：
[[ 1  2  5  6  9 10]
 [ 3  4  7  8 11 12]]
----------------------------------------------------------------------------------------------------
[[[ 1  2]
  [ 3  4]]

 [[ 5  6]
  [ 7  8]]

 [[ 9 10]
  [11 12]]]
(3, 2, 2)
----------------------------------------------------------------------------------------------------
10
沿轴0连接两个数组：
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

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

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

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

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

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

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

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

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

 [[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]]
(10, 3, 4)
----------------------------------------------------------------------------------------------------
沿轴1连接两个数组：
[[[ 0  1  2  3]
  [ 0  1  2  3]
  [ 0  1  2  3]
  [ 0  1  2  3]
  [ 0  1  2  3]
  [ 0  1  2  3]
  [ 0  1  2  3]
  [ 0  1  2  3]
  [ 0  1  2  3]
  [ 0  1  2  3]]

 [[ 4  5  6  7]
  [ 4  5  6  7]
  [ 4  5  6  7]
  [ 4  5  6  7]
  [ 4  5  6  7]
  [ 4  5  6  7]
  [ 4  5  6  7]
  [ 4  5  6  7]
  [ 4  5  6  7]
  [ 4  5  6  7]]

 [[ 8  9 10 11]
  [ 8  9 10 11]
  [ 8  9 10 11]
  [ 8  9 10 11]
  [ 8  9 10 11]
  [ 8  9 10 11]
  [ 8  9 10 11]
  [ 8  9 10 11]
  [ 8  9 10 11]
  [ 8  9 10 11]]]
(3, 10, 4)
----------------------------------------------------------------------------------------------------
沿轴2连接两个数组：这里的-1和2是等价的
[[[ 0  0  0  0  0  0  0  0  0  0]
  [ 1  1  1  1  1  1  1  1  1  1]
  [ 2  2  2  2  2  2  2  2  2  2]
  [ 3  3  3  3  3  3  3  3  3  3]]

 [[ 4  4  4  4  4  4  4  4  4  4]
  [ 5  5  5  5  5  5  5  5  5  5]
  [ 6  6  6  6  6  6  6  6  6  6]
  [ 7  7  7  7  7  7  7  7  7  7]]

 [[ 8  8  8  8  8  8  8  8  8  8]
  [ 9  9  9  9  9  9  9  9  9  9]
  [10 10 10 10 10 10 10 10 10 10]
  [11 11 11 11 11 11 11 11 11 11]]]
(3, 4, 10)
----------------------------------------------------------------------------------------------------
[[ 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 12 13 14 15 16 17]
 [ 6  7  8  9 10 11 18 19 20 21 22 23]]
----------------------------------------------------------------------------------------------------

2、数组分割

# 1 将一个数组分割成多个子数组，split()
"""
参数说明：
arr：被分割的数组
indices_or_sections：整数或整数数组，表示分割的位置。
axis：整数，表示沿着哪个轴进行分割。
"""
import numpy as np

arr = np.arange(12).reshape(4, 3)
print(arr)
print("-" * 100)

print("将数组按列分为三个大小相等的子数组：b是一个列表")
b = np.split(arr, 3, axis=1)  # 按那个轴，哪个轴就发生变化，参数3表示分割成三个子数组
print(b)
print(b[0].shape)
print("-" * 100)

print("将数组按行分为四个大小相等的子数组：b是一个列表")
b = np.split(arr, 4, axis=0)
print(b)
print("-" * 100)

print("水平分割：")
c = np.hsplit(arr, 3)  # 水平分割，相当于axis=1
print(c)
print(c[0].shape)
print("-" * 100)

print("竖直分割：")
d = np.vsplit(arr, 4)  # 竖直分割，相当于axis=0
print(d)
print(d[0].shape)
print("-" * 100)

输出结果：

[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
----------------------------------------------------------------------------------------------------
将数组按列分为三个大小相等的子数组：b是一个列表
[array([[0],
       [3],
       [6],
       [9]]), array([[ 1],
       [ 4],
       [ 7],
       [10]]), array([[ 2],
       [ 5],
       [ 8],
       [11]])]
(4, 1)
----------------------------------------------------------------------------------------------------
将数组按行分为四个大小相等的子数组：b是一个列表
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]]), array([[ 9, 10, 11]])]
----------------------------------------------------------------------------------------------------
水平分割：
[array([[0],
       [3],
       [6],
       [9]]), array([[ 1],
       [ 4],
       [ 7],
       [10]]), array([[ 2],
       [ 5],
       [ 8],
       [11]])]
(4, 1)
----------------------------------------------------------------------------------------------------
竖直分割：
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]]), array([[ 9, 10, 11]])]
(1, 3)
----------------------------------------------------------------------------------------------------

十三、数组中的nan和inf

1、基本使用

"""
C 语言中表示最大的正整数值是 0x7FFF FFFF，最小的负整数是 0x8000 0000。
查阅资料后，发现 inf 表示无穷大，需要使用 float(‘inf’) 函数来转化，那么对应的就有，
float('-inf') 表示无穷小了。这样你就可以使用任意数来判断和它的关系了。
那什么时候会出现inf呢？ 比如一个数字除以0，Python中会报错，但是numpy中会是一个inf或者-inf
另外还有 nan，这种写法在 pandans 中常见，表示缺失的数据，所以一般用 nan 来表示。
任何与nan做运算结果都是 nan
"""

import numpy as np

# nan 是not a number的缩写，表示非数字，在numpy中表示一个非数字值，可以用来表示缺失数据
# 创建一个nan和inf
a = np.nan
b = np.inf
c = -np.inf

print(a)  # 非数字
print(type(a))
print(b)  # 正无穷
print(type(b))
print(c)  # 负无穷
print(type(c))
print("-" * 100)

# 并且 np.nan !=  np.nan 结果是True
# 所以我们可以使用这两个结合使用判断nan的个数:
print(np.nan == np.nan)  # False
print(True == 1)
print(False == 0)
print(np.isnan(np.nan))  # 判断是否为nan
print("-" * 100)

# 判断数组中nan的个数
t = np.arange(1, 25, dtype=float).reshape(4, 6)

# 将三行四列的数改为nan
t[3, 4] = np.nan
print(t)

# 可以使用np.count_nonzero()函数来统计非零元素的个数
print("非零数字数目统计：")
print(np.count_nonzero(t))  # nan既不是0也不是False
print("-" * 100)
print(t != t)  # 如果元素不等于nan，则为True，否则为False
print("-" * 100)
print("nan元素的个数")
print(np.count_nonzero(t != t))  # 统计非nan元素的个数
print("-" * 100)
# 将nan替换为0
# t[t != t] = 0
t[np.isnan(t)] = 0
print(t)

输出结果：

nan
<class 'float'>
inf
<class 'float'>
-inf
<class 'float'>
----------------------------------------------------------------------------------------------------
False
True
True
True
----------------------------------------------------------------------------------------------------
[[ 1.  2.  3.  4.  5.  6.]
 [ 7.  8.  9. 10. 11. 12.]
 [13. 14. 15. 16. 17. 18.]
 [19. 20. 21. 22. nan 24.]]
非零数字数目统计：
24
----------------------------------------------------------------------------------------------------
[[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元素的个数
1
----------------------------------------------------------------------------------------------------
[[ 1.  2.  3.  4.  5.  6.]
 [ 7.  8.  9. 10. 11. 12.]
 [13. 14. 15. 16. 17. 18.]
 [19. 20. 21. 22.  0. 24.]]

2、拓展练习：处理数组中的nan

import numpy as np

# --- 练习：处理数组中的nan
t = np.arange(24).reshape(4, 6).astype(float)

# 将数组中的一部分替换为nan
t[1, 2:4] = np.nan
t[2, 1:3] = np.nan
print(t)
print(t.shape[1])
print("-" * 100)
# 遍历每一列，然后判断每一列是否有nan
for i in range(t.shape[1]):
    # 获取当前列数据
    col = t[:, i]  # 取出的是可变数据类型

    # 判断当前列的数据中是否含有nan
    # nan_num = np.count_nonzero(np.isnan(col))
    nan_num = np.count_nonzero(col != col)
    if nan_num != 0:
        # 将这一列不为nan的数据拿出来，并计算平均值
        col_no_nan = col[col == col]
        print(col_no_nan)
        # 将nan替换成这一列的平均值
        col[np.isnan(col)] = np.mean(col_no_nan)
print("-" * 100)
print(t)
print("-" * 100)
print(id(t))

输出结果：

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

十四、转置和轴滚动

1、转置

# 对换数组的维度
import numpy as np

a = np.arange(12).reshape(3, 4)
print("原数组：")
print(a)
print("-" * 100)

print("对换数组：")
print(np.transpose(a))  # 转置
print("-" * 100)

# 与transpose函数一致
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]]
----------------------------------------------------------------------------------------------------
转置后数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

2、轴滚动

# 对换数组的维度
import numpy as np

# 函数用于交换数组的两个轴
print("二维数组的轴滚动")
t1 = np.arange(24).reshape(4, 6)
ret = t1.swapaxes(0, 1)  # 交换第0轴和第1轴
print(t1)
print(t1.shape)
print("-" * 100)
print(ret)
print(ret.shape)
print("-" * 100)

print("三维数组的轴滚动：")
t3 = np.arange(60).reshape(3, 4, 5)
print(t3.shape)
print("-" * 100)
t3 = np.swapaxes(t3, 0, 2)  # 交换第0轴和第2轴
print(t3.shape)
print("-" * 100)

# 数组的轴滚动，swapaxes()每次只能交换两个轴
# rollaxis(数组, 轴号1, 轴号2) 将轴号1的轴滚动到轴号2的轴之前，并且不改变其他轴的相对位置
print("rollaxis函数的使用：")
a = np.ones((3, 4, 5, 6))
print(a.shape)
b = np.rollaxis(a, 3, 1)  # 将第3轴放到第1轴之前
print(b.shape)
c = np.rollaxis(b, 2, 1)  # 将b的2号轴放到1号轴之前
print(c.shape)

输出结果：

二维数组的轴滚动
[[ 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, 6)
----------------------------------------------------------------------------------------------------
[[ 0  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]
(6, 4)
----------------------------------------------------------------------------------------------------
三维数组的轴滚动：
(3, 4, 5)
----------------------------------------------------------------------------------------------------
(5, 4, 3)
----------------------------------------------------------------------------------------------------
rollaxis函数的使用：
(3, 4, 5, 6)
(3, 6, 4, 5)
(3, 4, 6, 5)

十五、numpy读取数据

import numpy as np
import matplotlib.pyplot as plt

us_file_path = './youtube_video_data/US_video_data_numbers.csv'

# delimiter参数指定了文件中数据的分隔符，这里是逗号,将每行数据分割为多个字段并保存到numpy数组中
t_us = np.loadtxt(us_file_path, delimiter=',', dtype=int)

# 取美国的电影的评论的数据
t_us_comments = t_us[:, -1]

# 选择比5000小的数据
t_us_comments = t_us_comments[t_us_comments <= 5000]

# 剩余多少数据
print(t_us_comments.shape)

# 再看最小值和最大值
print(t_us_comments.max(), t_us_comments.min())

# 每步长50设置一个等级，同一个范围内的属于同一等级，放在一起统计
d = 50
bin_nums = (t_us_comments.max() - t_us_comments.min()) // d

# 绘图
plt.figure(figsize=(20, 8), dpi=80)

plt.hist(t_us_comments, bin_nums)

plt.grid(True)

plt.show()

输出结果：

(1373,)
4995 0

图像显示：

十六、numpy自带生成随机数函数

函数名称	功能	参数
np.random.rand	生成均匀分布的随机数数组，范围 [0, 1)	d0, d1, …, dn - 数组的形状
np.random.randn	生成标准正态分布的随机数数组（均值 0，标准差 1）	d0, d1, …, dn - 数组的形状
np.random.randint	生成随机整数数组，范围 [low, high)	low - 起始值；high - 结束值；size - 输出形状；dtype - 数据类型
np.random.random	生成均匀分布的浮点数数组，范围 [0, 1)	size - 输出形状
np.random.uniform	生成均匀分布的随机数数组，范围 [low, high)	low - 下限；high - 上限；size - 输出形状
np.random.normal	生成正态分布的随机数数组	loc - 均值；scale - 标准差；size - 输出形状
np.random.choice	从数组 a 中随机选择元素	a - 输入数组；size - 输出形状；replace - 是否允许重复；p - 每个元素的概率
np.random.seed	设置随机数生成器的种子，保证可复现性	seed - 随机数生成的种子
np.random.permutation	返回数组 a 的一个随机排列的副本	a - 输入数组
np.random.shuffle	对数组 a 进行原地随机排列	a - 输入数组

十七、视图和副本

操作类型	是否创建视图	是否创建副本	修改后影响
切片操作：a[1:3]	是	否	修改视图会影响原始数据
reshape：a.reshape((2, 3))	是	否	修改视图会影响原始数据
transpose：a.T	是	否	修改视图会影响原始数据
view()：a.view()	是	否	修改视图会影响原始数据
copy()：a.copy()	否	是	修改副本不会影响原始数据
对切片赋值：a[1:3] = b	否	是	切片赋值后，会将赋值内容复制为新的数组，影响赋值的副本
np.copy(a)	否	是	创建副本后修改副本不会影响原数组

标签：--------------------------------------------------------------------------------
From： https://blog.csdn.net/python1_1/article/details/145258412