Day3

第二部分 numpy学习

1.什么是numpy

2.numpy基础

3.numpy常用方法

4.numpy常用统计方法

为什么要学习numpy

1.快速

2.方便

3.科学计算的基础库

什么是numpy

一个在Python中做科学计算的基础库，重在数值计算，也是大部分PYTHON科学计算库的基础库，多用于在大型、多维数组（各种列表形式，例如列表嵌套）上执行数值运算

numpy创建数组(矩阵)

 

【示例】

#coding=utf-8 import numpy as np #使用numpy生成数组，得到ndarray的数据类型 t1=np.array([1,2,3,]) print(t1) print(type(t1)) #数据属性 print(t1.dtype) t2=np.array(range(10)) print(t2) print(type(t2)) #npy.arange(start,stopm,step) t3 = np.arange(4,10,2) print(t3) print(type(t3))

结果：

[1 2 3]

<class 'numpy.ndarray'>

int32

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

<class 'numpy.ndarray'>

[4 6 8]

<class 'numpy.ndarray'>

numpy中常见的更多数据类型

 数据类型的操作

 

【示例】

#numpy中的数据类型 t4 = np.array(range(1,4),dtype='float32') print(t4) print(t4.dtype) #numpy中的布尔类型 t5 = np.array([1,1,0,1,0,0],dtype=bool) print(t5) print(t5.dtype) #修改数据类型.astype t6 = t5.astype('int8') print(t6) print(t6.dtype) #numpy中的小数 t7 = numpy.array([random.random() for i in range(10)]) print(t7) print(t7.dtype)

结果：

<class 'numpy.ndarray'>

[1. 2. 3.]

float32

[ True  True False  True False False]

bool

[1 1 0 1 0 0]

int8

[0.77605271 0.83797713 0.21914121 0.00532719 0.40877846 0.46288983

 0.92196868 0.60972947 0.88912385 0.60868958]

float64

那么问题来了,python中如何保留固定位数的小数?

使用round（）

【操作】

#numpy中的小数 t7 = numpy.array([random.random() for i in range(10)]) print(t7) print(t7.dtype) #round取小数 t8 = np.round(t7,2) print(t8)

结果：

[0.77605271 0.83797713 0.21914121 0.00532719 0.40877846 0.46288983

 0.92196868 0.60972947 0.88912385 0.60868958]

float64

[0.78 0.84 0.22 0.01 0.41 0.46 0.92 0.61 0.89 0.61]

数组的形状（几行几列的数组）

 ——————————————————————————————————————————

 

 —————————————————————————————————————————

【示例】

#coding=utf-8 import numpy as np t=np.array(range(24)) #查看数组形状 print(t.shape) #改变数组形状(reshape自带return函数，所以t本身不会发生变化) print(t.reshape((4,6))) #把数组转化为一维数组① print(t.reshape((1,24))) #② print(t.flatten())

结果：

(24,)

[[ 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 12 13 14 15 16 17 18 19 20 21 22 23]]

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

数组和数的计算（会应用于数组中的每一个数字）

这是一个numpy的广播机制造成的，在运算过程中，加减乘除的值1被广播到所有的元素上面

 

【示例】数组和数组的运算（对应位置上的数进行计算）

#coding=utf-8 import numpy as np t1=np.array([[1,2,3],[4,5,6]]) t2=np.array([[3,2,1],[6,5,4]]) print(t1) print(t2) print('*******') print('t1+t2\n',t1+t2) print('t1*t2\n',t1*t2)

结果：
[[1 2 3]

 [4 5 6]]

[[3 2 1]

 [6 5 4]]

*******

t1+t2

 [[ 4  4  4]

 [10 10 10]]

t1*t2

 [[ 3  4  3]

 [24 25 24]]

【示例】除以0

t=np.array(range(24))

print(t/0)

结果：
[nan inf inf inf inf inf inf inf inf inf inf inf inf inf inf inf inf inf

 inf inf inf inf inf inf]

 

结果：（行和列两个维度都不相同不能进行计算）

ValueError: cannot reshape array of size 13 into shape (3,4)

——————————————————————————

 

 

【示例】不同维度数组计算

#coding=utf-8 import numpy as np t5=np.array(range(24)).reshape((4,6)) print(t5) t8=np.array(range(4)).reshape((4,1)) print(t8) print('t5-t8\n',t5-t8)

结果：（t5的每一列减去t8的一列）

[[ 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]]

t5-t8

 [[ 0  1  2  3  4  5]

 [ 5  6  7  8  9 10]

 [10 11 12 13 14 15]

 [15 16 17 18 19 20]]

注意：

但若两个数组的行和列都不相等，则无法进行计算。必须某一维度上一样才能进行计算

广播原则

 

怎么理解呢?

可以把维度指的是shape所对应的数字个数

那么问题来了:

shape为(3,3,3)的数组能够和(3,2)的数组进行计算么?

答：不能

shape为(3,3,2)的数组能够和(3,2)的数组进行计算么?

答：可以计算

【示例】

#coding=utf-8 import numpy as np c=np.array(range(18)).reshape((3,3,2)) print(c) a=np.array(range(6)).reshape((3,2)) print(a) print(a+c)

结果：
[[[ 0  1]

  [ 2  3]

  [ 4  5]]

 [[ 6  7]

  [ 8  9]

  [10 11]]

 [[12 13]

  [14 15]

  [16 17]]]

[[0 1]

 [2 3]

 [4 5]]

[[[ 0  2]

  [ 4  6]

  [ 8 10]]

 [[ 6  8]

  [10 12]

  [14 16]]

 [[12 14]

  [16 18]

  [20 22]]]

注：2维数组只要有一个形状方向（行或列）一样，就可以计算

   

轴(axis)

在numpy中可以理解为方向,使用0,1,2...数字表示

对于一个一维数组,只有一个0轴,对于2维数组(shape(2,2)),有0轴和1轴,对于三维数组(shape(2,2, 3)),有0,1,2轴

有了轴的概念之后,我们计算会更加方便,比如计算一个2维数组的平均值,必须指定是计算哪个方向（行还是列）上面的数字的平均值

那么问题来了:

在前面的知识,轴在哪里?

回顾np.arange(0,10).reshape((2,5)),reshpe中2表示0轴长度(包含数据的条数)为2,1轴长度为5,2X5一共10个数据

二维数组的轴

 三维数组的轴

 

明白了轴的概念之后,对于shape返回的结果和reshape的结果能够更加清楚

numpy读取数据

（numpy读取数据一般用的较少）

CSV:Comma-Separated Value,逗号分隔值文件

显示：表格状态

源文件：换行和逗号分隔行列的格式化文本,每一行的数据表示一条记录

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

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

 

现在这里有一个英国和美国各自youtube1000多个视频的点击,喜欢,不喜欢,评论数量(["views","likes","dislikes","comment_total"])的csv,运用刚刚所学习的只是,我们尝试来对其进行操作

【示例】读取csv数据

#coding=utf-8 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" #np.loadtxt( #frame,dtype=np.float,delimiter=None,skiprows=0, #usecols=None,unpack=False) #frame:文件、字符串或产生器；dtype：数据类型；delimiter：分隔字符串 #skiprows：跳过前x行；usecols：读取指定的列 #unpack：True则将读入属性写入不同数组变量，（默认）False则只写入一个变量 t1 = np.loadtxt(us_file_path,delimiter=',',dtype="int",unpack=True) t2 = np.loadtxt(us_file_path,delimiter=',',dtype="int") print(t1) print('****') print(t2)

结果：
[[4394029 7860119 5845909 ...  142463 2162240  515000]

 [ 320053  185853  576597 ...    4231   41032   34727]

 [   5931   26679   39774 ...     148    1384     195]

 [  46245       0  170708 ...     279    4737    4722]]

****

[[4394029  320053    5931   46245]

 [7860119  185853   26679       0]

 [5845909  576597   39774  170708]

 ...

 [ 142463    4231     148     279]

 [2162240   41032    1384    4737]

 [ 515000   34727     195    4722]]

unpack：实现转置

 

numpy中的转置

（对unpack的拓展，转置：行和列互换）

转置是一种变换,对于numpy中的数组来说,就是在对角线方向交换数据,目的也是为了更方便的去处理数据

①.transpose()

②.swapaxes(1,0)

③.T

 

 

以上的三种方法都可以实现二维数组的转置的效果,大家能够看出来,转置和交换轴的效果一样

numpy读取和存储数据

那么,结合之前的所学的matplotlib把英国和美国的数据呈现出来?

看到这个问题,我们应该考虑什么?

我们想要反映出什么样的结果,解决什么问题?

选择什么样的呈现方式?

数据还需要做什么样的处理?

写代码

#coding=utf-8 from math import nan 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" #np.loadtxt( #frame,dtype=np.float,delimiter=None,skiprows=0, #usecols=None,unpack=False) #frame:文件、字符串或产生器；dtype：数据类型；delimiter：分隔字符串 #skiprows：跳过前x行；usecols：读取指定的列 #unpack：True则将读入属性写入不同数组变量，（默认）False则只写入一个变量 #视频的点击,喜欢,不喜欢,评论数量(["views","likes","dislikes","comment_total"]) #t1 = np.loadtxt(us_file_path,delimiter=',',dtype="int",unpack=True) t2 = np.loadtxt(us_file_path,delimiter=',',dtype="int") #print(t1) print(t2)

结果：

[[4394029  320053    5931   46245]

 [7860119  185853   26679       0]

 [5845909  576597   39774  170708]

 ...

 [ 142463    4231     148     279]

 [2162240   41032    1384    4737]

 [ 515000   34727     195    4722]]

numpy索引和切片

对于刚刚加载出来的数据,我如果只想选择其中的某一列(行)我们应该怎么做呢?

其实操作很简单,和python中列表的操作一样

 

 

是不是还可以加上步长呢？

 

【示例】

#取第3行(索引从0开始）
print(t2[2])
#取连续的多行（从第3行开始）
print(t2[2:])
#取不连续的多行（取第3,9,11行）
print(t2[[2,8,10]])
#取第一列(‘：’表示每行都要)
print(t2[:,0])
#取连续的多列（从第三列开始取）
print(t2[:,2:])
#取不连续的多列（第一列和第三列）
print(t2[:,[0,2]])
#取多行和多列，取第三行，第四列的值
a = t2[2,3]
print(a)    --->170708
print(type(a))  ---><class 'numpy.int32'>
#取第3行到第5行，第2列到第4列
#取的是行和列交叉点的位置
b = t2[2:5,1:4]
print(b)
#取多个不相邻的点（0，0)，（2,1），（2,3）
c = t2[[0,2,2],[0,1,3]]
print(c)

numpy中数值的修改

 

 

修改行列的值，我们能够很容易的实现，但是如果条件更复杂呢？

比如我们想要把t中小于10的数字替换为3

numpy中布尔索引

t[t<10]=0

 

 

那么问题来了：

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

numpy中三元运算符

np.where(t<10,0,18)

把t中小于10的数字替换为0，把大于10的替换为10

那么问题来了：

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

numpy中的clip(裁剪)

t.clip(10,18)

把t中小于10的数字替换为10，把大于18的替换为18

 

观察操作：

小于10的替换为10，大于18的替换为了18，但是nan没有被替换，那么nan是什么？

numpy中的nan和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的注意点

 

np.count_nonzero(t!=t) 判断nan是因为np.nan!=np.nan 所以t!=t可以判断nan的个数

【示例】

#coding=utf-8 import numpy as np from math import nan t=np.array([1.,2., nan, 20.]) print(np.nan==np.nan) print(np.nan!=np.nan) #判断数组中nan个数 print(np.count_nonzero(t!=t)) #为nan则返回True print(np.isnan(t)) #把nan替换为0 t[np.isnan(t)]=0 print(t)

结果：

False

True

1

[False False  True False]

[ 1.  2.  0. 20.]

【示例】关于nan的计算

#coding=utf-8 import numpy as np from math import nan t=np.array([[0.,1., nan, 2.],[3.,4.,5.,6.],[7.,8.,9.,10.]]) print(t) #sum求和 #nan和任何数字进行计算都为nan print(np.sum(t)) print(np.sum(t,axis=0)) print(np.sum(t,axis=1))

结果：

[[ 0.  1. nan  2.]

 [ 3.  4.  5.  6.]

 [ 7.  8.  9. 10.]]

nan

[10. 13. nan 18.]

[nan 18. 34.]

numpy中的nan的注意点

那么问题来了，在一组数据中单纯的把nan替换为0，合适么？会带来什么样的影响？

比如，全部替换为0后，替换之前的平均值如果大于0，替换之后的均值肯定会变小，所以更一般的方式是把缺失的数值替换为均值（中值（中位数））或者是直接删除有缺失值的一行

那么问题来了：

      如何计算一组数据的中值或者是均值

      如何删除有缺失数据的那一行（列）[在pandas中介绍]

numpy中常用统计函数

求和：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)

 

注1：

标准差是一组数据平均值分散程度的一种度量。一个较大的标准差，代表大部分数值和其平均值之间差异较大；一个较小的标准差，代表这些数值较接近平均值，反映出数据的波动稳定情况，越大表示波动越大，约不稳定

注2.

默认返回多维数组的全部的统计结果,如果指定axis则返回一个当前轴上的结果

【示例】nan统计函数

#coding=utf-8 import numpy as np t=np.array([[0.,1., 0., 2.],             [3.,4.,5.,6.],             [7.,8.,9.,10.]]) print(t) #sum求和 print(t.sum(axis=0)) #.mean求均值 print(t.mean(axis=0)) #.median求中值 print(np.median(t,axis=0)) #max最大值，min最小值 print(t.max(axis=0)) print(t.min(axis=0)) #.ptp极值，即最大最小值之差 print(np.ptp(t,axis=0)) #.std求标准差 print(t.std(axis=0))

结果：
[[ 0.  1.  0.  2.]

 [ 3.  4.  5.  6.]

 [ 7.  8.  9. 10.]]

[10. 13. 14. 18.]

[3.33333333 4.33333333 4.66666667 6.        ]

[3. 4. 5. 6.]

[ 7.  8.  9. 10.]

[0. 1. 0. 2.]

[7. 7. 9. 8.]

[2.86744176 2.86744176 3.68178701 3.26598632]

ndarry缺失值填充均值

t中存在nan值，如何操作把其中的nan填充为每一列的均值

t = array([[  0.,   1.,   2.,   3.,   4.,   5.],

       [  6.,   7.,  nan,   9.,  10.,  11.],

       [ 12.,  13.,  14.,  nan,  16.,  17.],

       [ 18.,  19.,  20.,  21.,  22.,  23.]])

 

【示例】

#coding=utf-8 import numpy from math import nan import numpy as np def fill_ndarray(t1): #遍历列,shape[0]表示行，shape[1]表示列     for i in range(t1.shape[1]):         temp_col = t1[:,i]  #当前的一列         nan_num = np.count_nonzero(temp_col!=temp_col) #统计nan个数         if nan_num !=0: #不为0，说明当前这一列中有nan             # 只有不为nan，temp_col==temp_col，当前一列不为nan的array             temp_not_nan_col = temp_col[temp_col==temp_col]             #选中当前为nan的值，把值赋值为不为nan的均值             temp_col[np.isnan(temp_col)]= temp_not_nan_col.mean()     return t1 if __name__=='__main__':     t1 = np.arange(12).reshape((3, 4)).astype("float")     # 把第2行，从第3列开始变为nan     t1[1, 2:] = np.nan     print(t1)     print('---------------------')     t1 = fill_ndarray(t1)     print(t1)

结果：

[[ 0.  1.  2.  3.]

 [ 4.  5. nan nan]

 [ 8.  9. 10. 11.]]

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

[[ 0.  1.  2.  3.]

 [ 4.  5.  6.  7.]

 [ 8.  9. 10. 11.]]

麻烦么？学完pandas我们有更容易的方法处理缺失值

小结

1.如何选择一行或者多行的数据（列）？

切片（选一部分）和索引（选一个值）——

选择行t[2]、t[3:,:]/选择列t[:,4:]

/选择行列，连续的多行t[2:,:3];不连续的多行 t[[1,3],[2,4]]：选择的是（1,2），（3,4）两个位置的值

索引：t[2,3]：第3行第4列的值

2.如何给选取的行或者列赋值？

赋值：t[2:,3]=3 把从第3行开始，第4列赋值为3

3.如何大于把大于10的值替换为10？

布尔索引 t[t>10]=10

4.np.where如何使用？

三元运算符  t=np.where(t>10,20,0) 把t中大于10的替换为20，其他的替换为0

5.np.clip如何使用？

裁剪  t=t.clip(10,20) 把t中小于10的替换为10，大于20的替换为20

6.如何转置（交换轴）？

转置  ①t.T   ②t.transpose()  ③t.swapaxes()

7.读取和保存数据为csv

dtype：数据类型 delimiter:字符分割符

读取本地文件 np.loadtxt(file_path,delimiter,dtype)

8.np.nan和np.inf是什么

nan：不是一个数字

_number_nan = np.count_nonzero(t!=t) #统计t中nan的个数

nan的性质：np.nan!=np.nan

np.isnan(t) #统计t中哪些为nan，返回布尔值，效果和np.nan!=np.nan相同

t[np.isnan(t)]=1  #把t中为nan的替换为1

inf表示无穷

9.常用的统计函数你记得几个？

求和：t.sum（axis=0） #axis计算每列的值，每行第一个数的和，每行第二个数的和...所以为求列的和

求均值：t.mean（axis=0）

求中位数:np.median(t,axis=0)

最值:t.max(),t.min()

计算极差（最大-最小）:np.ptp（t,axis=0）

计算标准差：t.std

10.标准差反映出数据的什么信息

反映数据的离散程度，稳定程度

练习：

①英国和美国各自youtube1000的数据结合之前的matplotlib绘制出各自的评论数量的直方图

②希望了解英国的youtube中视频的评论数和喜欢数的关系，应该如何绘制改图（散点图）

【操作】：

#coding=utf-8 #英国和美国各自youtube1000的数据结合之前的 #matplotlib绘制出各自的评论数量的直方图 import numpy as np from matplotlib import pyplot as plt us_file_path = "./youtube_video_data/US_video_data_numbers.csv" uk_file_path = "./youtube_video_data/GB_video_data_numbers.csv" #视频的点击,喜欢,不喜欢,评论数量(["views","likes","dislikes","comment_total"]) t_uk = np.loadtxt(uk_file_path,delimiter=',',dtype="int") t_us = np.loadtxt(us_file_path,delimiter=',',dtype="int") #取评论的数据 t_us_comments = t_us[:,-1] #行都要，-1表示取最后一列 #先看最大值，最小值为多少 print(t_us_comments.max(),t_us_comments.min()) #选取比5000小的数据(因为大于5000的数据较少）,考虑较为集中的数据 t_us_comments = t_us_comments[t_us_comments<=5000] #组距最大50多W，最小0，假设50组的话，组距10000 d = 50 #组数（极差/组距） bin_nums = (t_us_comments.max()-t_us_comments.min())//d #绘图 plt.figure(figsize=(20,8),dpi=80) #plt.hist(a，bin_nums) plt.hist(t_us_comments,bin_nums) plt.grid() plt.show()

结果：

 

【操作】

#coding=utf-8 #希望了解英国的youtube中视频的评论数和喜欢数的关系 #应该如何绘制改图（散点图） import numpy as np from matplotlib import pyplot as plt from matplotlib import font_manager #设置字体 my_font = font_manager.FontProperties(fname='C:/Windows/Fonts/simhei.ttf') uk_file_path = "./youtube_video_data/GB_video_data_numbers.csv" #视频的点击,喜欢,不喜欢,评论数量(["views","likes","dislikes","comment_total"]) t_uk = np.loadtxt(uk_file_path,delimiter=',',dtype="int") #选择t_uk中喜欢数小于50W的数据，数据更集中 t_uk = t_uk[t_uk[:,1]<=500000] #评论数 t_uk_comment = t_uk[:,-1] #喜欢 t_uk_like = t_uk[:,1] #绘图 plt.figure(figsize=(20,8),dpi=80) #绘制散点图scatter() plt.scatter(t_uk_like,t_uk_comment) #添加描述信息 plt.xlabel('喜欢数',fontproperties=my_font) plt.ylabel('评论数',fontproperties=my_font) plt.title('喜欢和评论的关系',fontproperties=my_font) plt.show()

结果：

 

数组的拼接

现在我希望把之前案例中两个国家的数据方法一起来研究分析，那么应该怎么做？

np.vstack((t1,t2)) 竖直拼接        np.hstack((t1,t2))  水平拼接

（竖直分割和水平分割与拼接为互逆）

 

数组的行列交换

数组水平或者竖直拼接很简单，但是拼接之前应该注意什么？

竖直拼接的时候：每一列代表的意义相同！！！否则牛头不对马嘴

如果每一列的意义不同，这个时候应该交换某一组的数的列，让其和另外一类相同

那么问题来了？

如何交换某个数组的行或者列呢？

 

练习：现在希望把之前案例中两个国家的数据方法一起来研究分析，同时保留国家的信息（每条数据的国家来源），应该怎么办

【操作】

#coding=utf-8 #数组的拼接：现在希望把之前案例中两个国家的数据方法一起来研究分析 #同时保留国家的信息（每条数据的国家来源），应该怎么办 import numpy as np us_data = "./youtube_video_data/US_video_data_numbers.csv" uk_data = "./youtube_video_data/GB_video_data_numbers.csv" #视频的点击,喜欢,不喜欢,评论数量(["views","likes","dislikes","comment_total"]) #加载国家信息 us_data = np.loadtxt(us_data,delimiter=',',dtype="int") uk_data = np.loadtxt(uk_data,delimiter=',',dtype="int") #添加国家信息美国为0，英国为1 #构造全为0的数据np.zeros((行，列)) zeros_data = np.zeros((us_data.shape[0],1)).astype(int) ones_data = np.ones((uk_data.shape[0],1)).astype(int) #水平拼接np.hstack((t1,t2))（分别添加一列全为0，1的数据） us_data = np.hstack((us_data,zeros_data)) uk_data = np.hstack((uk_data,ones_data)) #拼接两组数据（np.vstack((t1,t2))竖直拼接） final_data = np.vstack((us_data,uk_data)) print(final_data)

结果：
[[4394029  320053    5931   46245       0]

 [7860119  185853   26679       0       0]

 [5845909  576597   39774  170708       0]

 ...

 [ 109222    4840      35     212       1]

 [ 626223   22962     532    1559       1]

 [  99228    1699      23     135       1]]

numpy更多好用的方法

1.获取最大值最小值的位置

  np.argmax(t,axis=0)

  np.argmin(t,axis=1)

【示例】

#coding=utf-8 import numpy as np t = np.eye(4) print(t) print(np.argmax(t,axis=0)) t[t==1]=-1 print(t) print(np.argmin(t,axis=1))

结果：
[[1. 0. 0. 0.]

 [0. 1. 0. 0.]

 [0. 0. 1. 0.]

 [0. 0. 0. 1.]]

[0 1 2 3]   ——>最大值的位置

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

 [ 0. -1.  0.  0.]

 [ 0.  0. -1.  0.]

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

[0 1 2 3]   ——>最小值的位置

2.创建一个全0的数组: np.zeros((3,4))

3.创建一个全1的数组:np.ones((3,4))

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

【示例】

#coding=utf-8 import numpy as np print(np.ones((2,3))) print('-------') print(np.zeros((2,3))) print('-------') print(np.eye(3))

结果：

[[1. 1. 1.]

 [1. 1. 1.]]

-------

[[0. 0. 0.]

 [0. 0. 0.]]

-------

[[1. 0. 0.]

 [0. 1. 0.]

 [0. 0. 1.]]

numpy生成随机数

 

【示例】np.random.rand()

#coding=utf-8 import numpy as np t = np.random.rand() t1 = np.random.rand(1) t2 = np.random.rand(2,2) print(t) print(t1) print(t2)

结果：

0.18760242455098486

[0.65982013]

[[0.52775828 0.84049786]

 [0.89130358 0.71245619]]

【示例】randint,uniform

#coding=utf-8 import numpy as np t1 = np.random.randint(0,20,(3,4)) t2 = np.random.uniform(0,10,5) print(t1) print(t2)

结果：

[[15 13 19  0]

 [ 6 10  2 17]

 [ 3  4 18 19]]

[4.59312834 9.60812837 2.73907317 9.21329994 5.75528342]

【示例】seed():使得每次生成的随机数都一样

#coding=utf-8 import numpy as np np.random.seed(10) t1 = np.random.randint(0,20,(3,4)) print(t1)

结果：

[[ 9  4 15  0]

 [17 16 17  8]

 [ 9  0 10  8]]

分布的补充

均匀分布：在相同的大小范围内的出现概率是等可能的

 正态分布：呈钟型，两头低，中间高，左右对称（平均数为0）