numpy的使用

1数据的创建与类型

（1）np.array和np.arange

import numpy as np
# 下面三种方式等效
t1 = np.array([1,2,3,4,5])
t2 = np.array(range(5))
t3 = np.arange(5)
print(t1)
print(type(t1))		# 数组的类型
print(t1.dtype)     # t1数组中，数据的类型

输出

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

数组的类型是ndarray，数组中数据的类型是int32。
arrange的用法和range一致，即参数是start，end，seg
但与range不同的是，arange还能生成小数

t4 = np.arange(10, 15, 0.5)
print(t4)

输出

[10.  10.5 11.  11.5 12.  12.5 13.  13.5 14.  14.5]

（2）numpy中常见的数据类型

除了上面的类型，numpy还支持字符串类型，用 np.str_ 表示

可以在创建的时候，指定其类型

t5 = np.array(range(1,4),dtype="i1")
# 也可以写成t4 = np.array(range(1,4),dtype=int8)

  若在创建数组的时候没有指定数据类型，那么默认情况下，根据电脑的位数来确定是32位还是64位，如果电脑是64位，那么就是int64，如果是32位，那么就是int32。

（3）numpy中的bool型

将数值型转化为bool型时，只要不是0，那都是True

##numpy中的bool类型
t6 = np.array([1,1,0,1,0,0],dtype=bool)
print(t6)
print(t6.dtype)

输出

[ True  True False  True False False]
bool

（4）数据类型转换

使用np.astype进行转换

t7 = t6.astype("int8")
print(t7)
print(t7.dtype)

输出

[1 1 0 1 0 0]
int8

（5）numpy中的小数

# numpy中的小数
# 需要先导入random模块，import random
# random.random()表示生成一个0-1之间的随机数
t7 = np.array([random.random() for i in range(10)])
print(t7)
print(t7.dtype)

# 四舍五入
t8 = np.round(t7,2)	# 保留两位小数
print(t8)

输出

[0.86556796 0.43664234 0.75419431 0.09691071 0.95194878 0.3131914
 0.70976318 0.53698263 0.29735993 0.96115199]
float64
[0.87 0.44 0.75 0.1  0.95 0.31 0.71 0.54 0.3  0.96]

2 数组的形状

（1） 查看数组的形状np.shape

可以使用np.shape()来查看数组的形状（即几行几列）

t1是一位数组，其形状为(12, )，这是一个元组，但只有含有一个值。

（2）重塑数组的形状 np.reshape()

  t3是三维数组，的形状为(2, 3, 4)，应该从后往前读，最后一维是4，说明最里面的中括号里有四个数，然后是3，说明次里面的中括号有三个对象，最前面是2，说明最大的中括号里面有两个对象。
  对于多维数组，其元素地址的变化规律如下：下标从最后一个维度开始变化，然后倒数第二个，一直到最前面的。
  也可以这样认为，2表示有2块，(3, 4)表示每块都有一个(3, 4)的矩阵。
  需要注意的是，一维数组是(3, )，只有一对中括号，而不是(3, 1)和(1, 3)，后两者是二维的，有两对中括号。

np.flatten将矩阵打平成数组

np.flatten是从里往外，依次打开中括号

3 数组的轴

  在numpy中可以理解为方向，使用0,1,2…数字表示，对于一个一维数组，只有一个0轴，对于2维数组(shape(2,2))，有0轴和1轴，对于三维数组(shape(2,2, 3))，有0,1,2轴。
  np.arange(0,10).reshape((2,5))，reshpe的参数中2表示0轴长度(包含数据的条数)为2，1轴长度为5，2X5一共10个数据。

  在带有axis参数的二维数组上使用np.sum（）等聚合函数时，它会将二维数组折叠为一维数组，其折叠的方向由axis参数确定。
  如

t1 = np.arange(12,24).reshape((3,4))
print(t1)
print(50 * '-')

t2 = np.sum(t1, axis=0)
print(t2)

输出

[[12 13 14 15]
 [16 17 18 19]
 [20 21 22 23]]
--------------------------------------------------
[48 51 54 57]

  对于三维数组也是类似，假如t3是三维数组，其shape是（2,3,4），那么第0轴的长度是2，如果按照第0轴的方向折叠，折叠后的shape为（3,4），如下：

4 广播

不同维度的矩阵或数据进行计算，即为广播。

（1）数组（矩阵）+数字

相当于二维数组的每个元素都加了这个数字

In [6]: t2
Out[6]:
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11]])

In [7]: t2 + 10
Out[7]:
array([[10, 11, 12, 13, 14, 15],
       [16, 17, 18, 19, 20, 21]])

（2）不同维度的两个数组相加

先看下面的实例：

In [11]: t7
Out[11]: array([0, 1, 2, 3, 4, 5])

In [12]: t8
Out[12]:
array([[10, 11, 12, 13, 14, 15],
       [16, 17, 18, 19, 20, 21]])

In [13]: t9
Out[13]:
array([[10, 11],
       [12, 13],
       [14, 15],
       [16, 17],
       [18, 19],
       [20, 21]])

In [14]: t7 + t8
Out[14]:
array([[10, 12, 14, 16, 18, 20],
       [16, 18, 20, 22, 24, 26]])

t7能和t8相加

In [15]: t7 + t9
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-15-e3cd48b39d92> in <module>
----> 1 t7 + t9

ValueError: operands could not be broadcast together with shapes (6,) (6,2)

t7+t9就会报错

（6,1）的数组能和（6,2）的相加吗？

根据上面的规律，可以提炼出广播的规律：

  注意什么是后缘维度，所谓的后缘维度就是从后面开始算起，从前面开始算起的（前缘维度）有若干维度相同的，不能进行广播，如

其他基本运算，包括地板除，与加法相同
二维或者更高维度的数组和一维数据进行运算，那么一维数组，其长度就是后缘维度

5 读数据

  由于csv便于展示,读取和写入,所以很多地方也是用csv的格式存储和传输中小型的数据,为了方便教学,我们会经常操作csv格式的文件,但是操作数据库中的数据也是很容易的实现的

np.loadtxt(fname,dtype=np.float,delimiter=None,skiprows=0,usecols=None,unpack=False)

其中 unpack 若为True，则相当于将原来的数据进行了转置

练习：
  现有英国和美国各自在youtube的1000多个视频的“点击,喜欢,不喜欢,评论”数量([“views”,“likes”,“dislikes”,“comment_total”])的csv文件，使用刚刚介绍的方法读取数据：

import numpy as np

us_file_path = "./youtube_video_data/US_video_data_numbers.csv"
uk_file_path = "./youtube_video_data/GB_video_data_numbers.csv"

# 读取第1列和第3列
t1 = np.loadtxt(us_file_path,delimiter=",",dtype="int",usecols=(1, 3))

# 不指定读取哪一列，默认读取全部，让每一列代表一个记录
t2 = np.loadtxt(us_file_path,delimiter=",",dtype="int",unpack=True)

print(t1)
print(50*'*')
print(t2)

输出

[[320053  46245]
 [185853      0]
 [576597 170708]
 ...
 [  4231    279]
 [ 41032   4737]
 [ 34727   4722]]
**************************************************
[[4394029 7860119 5845909 ...  142463 2162240  515000]
 [ 320053  185853  576597 ...    4231   41032   34727]
 [   5931   26679   39774 ...     148    1384     195]
 [  46245       0  170708 ...     279    4737    4722]]

6 数组的切片

（1）取行或列

In [17]: t1
Out[17]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

In [18]: t1[2]  # 取行
Out[18]: array([10, 11, 12, 13, 14])

In [19]: t1[-1] # 取最后一行
Out[19]: array([15, 16, 17, 18, 19])

取连续多行，像列表切片一样，startseg

In [21]: t1[1:3] # 取连续多行
Out[21]:
array([[ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

取不连续的多行

In [23]: t1[[1,3]]  # 取第1行和第3行
Out[23]:
array([[ 5,  6,  7,  8,  9],
       [15, 16, 17, 18, 19]])

  对列的操作和行类似，但是在取列的时候，行的位置处要有冒号（:），否则报错
  取列的时候，返回值是一维数组，一维数组是以行的形式展示的。

In [27]: t1
Out[27]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

In [28]: t1[:,2] # 取列的时候，行的位置冒号（：）不能省略
Out[28]: array([ 2,  7, 12, 17])

In [29]: t1[:,::2]
Out[29]:
array([[ 0,  2,  4],
       [ 5,  7,  9],
       [10, 12, 14],
       [15, 17, 19]])

（2）取元素

  取某个具体元素上的值，返回的将不再是数组，而是一个numpy.int或numpy.float的数据

In [31]: t1[2,3]
Out[31]: 13

In [32]: type(t1[2,3])
Out[32]: numpy.int32

取多个不相邻的元素，例如要取（0,0），（2,1），（2,3）这三个位置上的值
返回值将是包含上述三个位置值的一位数组

In [34]: t1
Out[34]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

In [35]: t1[[0,2,2],[0,1,3]]	# 第一个方括号里确定行数，第二个方括号确定列数
Out[35]: array([ 0, 11, 13])

取多行多列交叉的值

In [36]: t1[2:5,1:4]
Out[36]:
array([[11, 12, 13],
       [16, 17, 18]])

（3）切片引用

观察下面四个例子

a2[1] = 100不会对a1造成影响，因为a2 = a1[2:]传递的是若干个元素的地址
  b2[1] = 100之所以会对b1造成影响，因为b2 = b1[1]是浅拷贝，只拷贝引用，不拷贝对象
  c2[1] = 100会对c1造成影响，因为 c2 = c1[2:] 传递的是切片的引用，是把切片作为一个整体，而非“若干元素的”引用，这个和列表有明显的区别
  d2[1] = 100也会对d1造成影响，因为d2 = d1[1]同样传递的是切片的引用

• 回忆“若干个元素的引用”与“整个列表的引用的区别”
  
  a3 = a1，是把列表的地址赋给a3，列表是一个整体，传递的是列表的地址
  a2 = a1[2:]，是把a1的第2个以后的所有元素的地址赋给a2，传递的是若干个元素的地址

7 数组值的修改

（1）赋值修改

同前面的切片一样，再在右边加上一个赋值号，通过赋值号进行修改

对数组切片的复制，如果类型不一致，则强制转化为数组的数据类型

比如我们想要把t中小于10的数字替换为3，该如何实现？

（2）三元运算符

（3）范围裁剪numpy.clip

如果我们想把 t 中小于10的数字替换为10，把大于18的替换为18，应该怎么做？

8 关于numpy.nan和numpy.inf

nan(NAN,Nan):not a number表示不是一个数字

什么时候numpy中会出现nan：
  当我们读取本地的文件为float的时候，如果有缺失，就会出现nan
  当做了一个不合适的计算的时候(比如无穷大(inf)减去无穷大)

inf(-inf,inf):infinity,inf表示正无穷，-inf表示负无穷

什么时候回出现inf包括（-inf，+inf）
  比如一个数字除以0，（python中直接会报错，numpy中是一个inf或者-inf）

那么如何指定一个nan或者inf呢？
注意他们的type类型

  可以给某个元素直接赋numpy.nan或numpy.inf，但是必须先把原来的数据类型改成浮点型，否则会报错或者出现一些奇怪的数字。


两个np.nan是不相同的

np.isnan(t) 返回一个和t形状相同的数组，数据类型为bool型
np.count_nonzero(t) 返回一个数组t中0（或者False）的个数

  那么问题来了，在一组数据中单纯的把nan替换为0，合适么？会带来什么样的影响？
  比如，全部替换为0后，替换之前的平均值如果大于0，替换之后的均值肯定会变小，所以更一般的方式是把缺失的数值替换为均值（中值）或者是直接删除有缺失值的一行

9 布尔索引

10 常用统计函数

求和：t.sum(axis=None)
均值：t.mean(a,axis=None) 受离群点的影响较大
中值：np.median(t,axis=None)
最大值：t.max(axis=None)
最小值：t.min(axis=None)
极值：np.ptp(t,axis=None) 即最大值和最小值只差
标准差：t.std(axis=None)
  若未指定axis，默认返回多维数组的全部的统计结果,如果指定axis则返回一个当前轴上的结果

练习，将t1中的np.nan，替换成整个数组剩余元素的平均值。
其中t1为

t1 = np.arange(12).reshape(3,4).astype("float")
t1[2,:] = np.nan

相关代码

import numpy as np

t1 = np.arange(12).reshape(3,4).astype("float")
t1[2,:] = np.nan


def fill_ndarray(t1):
    for i in range(t1.shape[1]):
        temp_col = t1[:,i]	# 当前的一列
        nan_num = np.count_nonzero(temp_col!=temp_col)
        # 因为temp_col != temp_col返回的是一个bool型的矩阵，
        # 而np.nan!=np.nan的结果为True，np.count_nonzero统计的是矩阵中非零的个数
        # 因此可以统计其中True的个数，此即为temp_col中np.nan的个数

        if nan_num != 0:
            temp_not_nan_col = temp_col[temp_col == temp_col]
            # 如果temp_col中，某个位置的元素不是nan，那么这个位置上的结果则为True

            temp_col[np.isnan(temp_col)] = temp_not_nan_col.mean()
            # 在nan的位置上，赋上整个矩阵的均值

    # 由于切片赋值是浅拷贝，因此temp_col发生变化，t1也会发生变化
    return t1


if __name__ == '__main__':  # 直接敲入main，然后回车就行
    print(t1)
    t1 = fill_ndarray(t1)

    print(50*'-')
    print(t1)

11 数组的拼接

（1）一维数组的拼接

类似于列表的拼接，可以使用 np.append 方法

（1）二维数组的拼接

hstack也能用于一维数组的拼接
注意，上面两个方法中，参数都是元组。

（3）高维数组的拼接

定义两个三维数组



上面的三张图片可以看到，concatenate 可以实现在指定轴上的拼接，axis=0，则表示在0轴，即拼接的时候，只打开一个方括号，axis=1，则打开两个方括号，axis=2，则打开三个方括号，即 concatenate 不仅可以拼接高维数组，也能拼接低维数组。

12 数组的切割

（1）水平竖直分割

竖直分割

可以看到，hsplit返回的是由分割结果得到的列表。
上面的hsplit第二个参数是 3，表示均匀分割成三份，每份的列数一样

如果不想均匀分怎么办？可以用一个元组代替，元组中的数字表示划线位置

水平分割 vsplit 的用法与 hsplit 一致。

（2）按指定轴分割

同前面np.contenate类似，在第几个轴上分割，axis就设置为几


如果不想均分，也可以用元组的方法，指定划线位置

（3）按深度分割

把最深的索引一致的元素拿出来构成新的数组

上图红色框中，a[0, 0, 0]，a[0, 1, 0]，a[1, 0, 0]，a[1, 1, 0]这四个数的最后一个索引都是0，将它们取出，组成一个数组，维度数与前面保持一致，都保持三维。
b中的另外两个元素，与b[0]一致。

13 行与行的交换、列与列的交换

14 线性代数相关操作

下面的操作适合二维数组

（1）转置

最简单的是t.T，常用的还有t.transpose()

In [40]: t
Out[40]:
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])

In [41]: t.T
Out[41]:
array([[0, 5],
       [1, 6],
       [2, 7],
       [3, 8],
       [4, 9]])

In [42]: t.transpose()
Out[42]:
array([[0, 5],
       [1, 6],
       [2, 7],
       [3, 8],
       [4, 9]])

transpose还可以实现对多个维度的转置

可以看到，np.transpose(a, (1, 2, 0))其实就是进行了下面的操作

b[k, i, j] = a[i, j, k]

（2）矩阵乘法

a 对应位置乘积

既可以用 * 号，也可以用 np.multiply

b 矩阵乘积

使用 np.dot 实现

（3）求行列式

np.linalg.det()

（4）求逆

np.linalg.inv 对矩阵求逆

A = np.array([[0,1,2],
              [1,0,3],
              [4,-3,8]])

print("A = ")
print(A)
print()

inverse = np.linalg.inv(A)
print("A的逆矩阵:")
print(inverse)
print()

输出

A = 
[[ 0  1  2]
 [ 1  0  3]
 [ 4 -3  8]]

A的逆矩阵:
[[-4.5  7.  -1.5]
 [-2.   4.  -1. ]
 [ 1.5 -2.   0.5]]

（5）解线性方程组

np.linalog.solve

这里要注意b的维度，深度学习中，即便是向量，也是将其当成二维数组来，这样可以避免一些未知的错误。

当然，b如果为一维的，也能得到结果

（6）特征值和特征向量

15 随机函数

（1）随机抽样

np.random.

如果指定np.seed(1)，那么程序每次运行的时候，生成的随机数都是相同的，如果未指定，则不同

以 np.random.rand 为例介绍 random 模块的使用

（2）打乱顺序

a 原地打乱 shuffle

现场修改序列，改变自身内容。（类似洗牌，打乱顺序）

shuffle 只能对第一个索引（即axis=0）进行操作

b 非原地打乱 permutation

permutation(x)

x若为数组，那么就返回打乱后的结果，但 x 不变

x若为一个整数，那么就生成一个 0-x 序列，并打乱

random模块的其他常用函数，可以见这篇博客（其实帖子也没必要看，上面介绍的抽样和打乱的几个方法，已经完全够用了）：
https://www.cnblogs.com/zuoshoushizi/p/8727773.html

16 其他常用方法

（1）获取最大值最小值的索引

  np.argmax(t,axis=0) （对0轴数据进行折叠）
  np.argmin(t,axis=1) （对1轴数据进行折叠）

（2）全零数组，全一数组，单位矩阵

  创建一个全0的数组: np.zeros((3,4))
  创建一个全1的数组:np.ones((3,4))
  创建一个对角线为1的正方形数组(方阵)：np.eye(3)

（3）真值测试函数

  np.all 如果全为True，则返回True，否则返回 False
  np.any 只要存在一个True，就返回True，如果一个都没有，那就返回False

17 练习

  现有英国用户在youtube的1000多个视频的“点击,喜欢,不喜欢,评论”数量([“views”,“likes”,“dislikes”,“comment_total”])的csv文件，绘制评论数和喜欢数的散点图

import numpy as np
from matplotlib import pyplot as plt

uk_file_path = "./youtube_video_data/GB_video_data_numbers.csv"

t_uk = np.loadtxt(uk_file_path,delimiter=",",dtype="int")

t_uk = t_uk[t_uk[:,-1]<50000]   # 通过bool索引来筛选，将评论大于5万的去掉
# 之所以要筛选5万以下的，是因为评论数超过5万视频，太少了
# print(t_uk)

plt.figure(figsize=(10,6), dpi=80)
plt.scatter(t_uk[:,1],t_uk[:,-1])
# 第一列是喜欢数，最后一列是评论数
plt.show()

输出