'''
【课程1.2】 Numpy基础数据结构
NumPy数组是一个多维数组对象（可以理解为向量），称为ndarray。其由两部分组成：
① 实际的数据
② 描述这些数据的元数据(类变量 ndim shape size dtype itemsize data等)
'''
'\n【课程1.2】 Numpy基础数据结构\n\nNumPy数组是一个多维数组对象，称为ndarray。其由两部分组成：\n① 实际的数据\n② 描述这些数据的元数据\n\n'
#秩数，维数，轴数看图能更好理解轴数的概念
#（推荐看本人转载的博文https://blog.csdn.net/weixin_40974922/article/details/93496508）
#大家不用太纠结三维以及高维数组，大部分情况都是用二维数组即矩阵
import numpy as np
#注意写法 n维向量最左/右端 有n个【/ 】!!!!!!
ar=np.array([[1,2,3,4,5,6],[2,3,4,5,6,7],[1,2,3,4,5,6]])
# ar输出数组，注意数组的格式：中括号，元素之间没有逗号（和列表区分）
print(ar)
# ar.ndim输出数组轴数，或者说“秩”，维度的数量也称rank
print(ar.ndim)
# ar.shape数组的维度，对于n行m列的数组，shape为（n，m）
print(ar.shape)
# ar.size数组的元素总数，对于n行m列的数组，元素总数为n*m
print(ar.size)
# ar.dtype数组中元素的类型，类似type()
#注，type()是函数查看该数组类型，ar.dtype是类变量，查看该数组的元素data的数据类型
print(ar.dtype)
print(type(ar))
# ar.itemsize数组中每个元素的字节大小，int32l类型字节为4，float64的字节为8
print(ar.itemsize)
# 包含实际数组元素的缓冲区的首地址，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。
print(ar.data)
[[1 2 3 4 5 6]
[2 3 4 5 6 7]
[1 2 3 4 5 6]]
2
(3, 6)
18
int32
<class 'numpy.ndarray'>
4
<memory at 0x000001FA2580E630>
# 创建数组：array()函数，括号内可以是
#1嵌套序列（list tup）
#只有嵌套序列可以生成多维数组
#2生成器range和arange一样只能生成一维数组
# 整型
ar1=np.array(range(10))
print(ar1,ar1.dtype)
# 浮点型
ar2=np.array([1,2,3.14,4.5])
print(ar2,ar2.dtype)
# 二维数组：嵌套序列（列表，元祖均可）
#只要出现一个str就会把所有元素都变成str
ar3=np.array([[1,2,3],[3,2,'4']])
print(ar3,ar3.shape,ar3.ndim,ar3.size,ar3.dtype)
# 注意嵌套序列数量不一样会从二维数组将为一维数组,即将最外层【】拆除
ar4=np.array([[1,2,3,4],['a',2,4]])
print(ar4,ar4.shape,ar4.ndim,ar4.size,ar4.dtype)
[0 1 2 3 4 5 6 7 8 9] int32
[1. 2. 3.14 4.5 ] float64
[['1' '2' '3']
['3' '2' '4']] (2, 3) 2 6 <U11
[list([1, 2, 3, 4]) list(['a', 2, 4])] (2,) 1 2 object
#创建一维数组还可以用arange()
#类似range(),只不过支持小数，在给定间隔内返回均匀间隔的值。
#依然左闭右开
# 返回0-9，整型
print(np.arange(10))
# 返回0.0-9.0，浮点型
print(np.arange(10.0))
#返回5-11
print(np.arange(5,12))
#返回5.0-12.0，步长为2.5
#注起点 终点 步长只要有一个是float则都转换为float
print(np.arange(5.0,12,2.5))
# 如果数组太大而无法打印，NumPy会自动跳过数组的中心部分，并只打印边角
print(np.arange(10000))
[0 1 2 3 4 5 6 7 8 9]
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
[ 5 6 7 8 9 10 11]
[ 5. 7.5 10. ]
[ 0 1 2 ... 9997 9998 9999]
# numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
# start：起始值，stop：结束值
# num：生成样本数，默认为50
# endpoint：如果为真，则stop是最后一个样本。否则，不包括在内。默认值为True。
# retstep：如果为真，返回（样本，步骤），其中步长是样本之间的间距
#→ 输出为一个包含2个元素的元祖，第一个元素为array，第二个为步长实际值
#注意linspace（a，b）是迄今为止唯一一个默认左闭右闭生成方式
#如下 2.0-3.0左闭右闭 等距取5个值
#1/（num（5）-1=4）取值要num-1 因为起点算入num了 !!!重点
ar1=np.linspace(2,3,num=5)
print(ar1)
#如果要左闭右开即生成的数组不含stop 则令endpoint=False
ar2=np.linspace(2,3,num=5,endpoint=False)
print(ar2)
ar3=np.linspace(2,3,5,retstep=True)
print(ar3,type(ar3))
[2. 2.25 2.5 2.75 3. ]
[2. 2.2 2.4 2.6 2.8]
(array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) <class 'tuple'>
# 创建数组：zeros()/zeros_like()/ones()/ones_like()
# numpy.zeros(shape, dtype=float, order='C'):返回给定形状和类型的新数组，用零填充。
# shape：数组纬度，二维以上需要用()，且输入参数为整数
# dtype：数据类型，默认numpy.float64
# order：是否在存储器中以C或Fortran连续（按行或列方式）存储多维数据。
ar1=np.zeros(5)
ar2=np.zeros((2,2),dtype=float)
print(ar1,ar1.dtype)
print(ar2,ar2.dtype)
print('------')
ar3=np.array([list(range(10)),list(range(10,20))])
ar4=np.zeros_like(ar3)
print(ar3)
print(ar4)
[0. 0. 0. 0. 0.] float64
[[0. 0.]
[0. 0.]] float64
------
[[ 0 1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18 19]]
[[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]]
# 创建单位矩阵数组：eye()
print(np.eye(5))
[[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.]]
'''
补充
ndarray的数据类型
bool 用一个字节存储的布尔类型（True或False）
inti 由所在平台决定其大小的整数（一般为int32或int64）
int8 一个字节大小，-128 至 127
int16 整数，-32768 至 32767
int32 整数，-2 ** 31 至 2 ** 32 -1
int64 整数，-2 ** 63 至 2 ** 63 - 1
uint8 无符号整数，0 至 255
uint16 无符号整数，0 至 65535
uint32 无符号整数，0 至 2 ** 32 - 1
uint64 无符号整数，0 至 2 ** 64 - 1
float16 半精度浮点数：16位，正负号1位，指数5位，精度10位
float32 单精度浮点数：32位，正负号1位，指数8位，精度23位
float64或float 双精度浮点数：64位，正负号1位，指数11位，精度52位
complex64 复数，分别用两个32位浮点数表示实部和虚部
complex128或complex 复数，分别用两个64位浮点数表示实部和虚部
'''
'\n补充\nndarray的数据类型\nbool 用一个字节存储的布尔类型（True或False）\ninti 由所在平台决定其大小的整数（一般为int32或int64）\nint8 一个字节大小，-128 至 127\nint16 整数，-32768 至 32767\nint32 整数，-2 ** 31 至 2 ** 32 -1\nint64 整数，-2 ** 63 至 2 ** 63 - 1\nuint8 无符号整数，0 至 255\nuint16 无符号整数，0 至 65535\nuint32 无符号整数，0 至 2 ** 32 - 1\nuint64 无符号整数，0 至 2 ** 64 - 1\nfloat16 半精度浮点数：16位，正负号1位，指数5位，精度10位\nfloat32 单精度浮点数：32位，正负号1位，指数8位，精度23位\nfloat64或float 双精度浮点数：64位，正负号1位，指数11位，精度52位\ncomplex64 复数，分别用两个32位浮点数表示实部和虚部\ncomplex128或complex 复数，分别用两个64位浮点数表示实部和虚部\n'
#作业answer
import numpy as np
a1=np.array([1,2,'a','hello',[1,2,3],{'two':200,"one":100}])
print(a1,a1.shape)
a2=np.array([list(range(6)),list('abcdef'),[True,False,True,False,True,True]])
print(a2,a2.shape)
[1 2 'a' 'hello' list([1, 2, 3]) {'two': 200, 'one': 100}] (6,)
[['0' '1' '2' '3' '4' '5']
['a' 'b' 'c' 'd' 'e' 'f']
['True' 'False' 'True' 'False' 'True' 'True']] (3, 6)
a3=np.arange(5,14)
print(a3)
a4=np.linspace(5,14,num=10,endpoint=True)
[ 5 6 7 8 9 10 11 12 13]
a5=np.zeros((4,4),dtype=float)
print(a5)
print('---')
a6=np.array([[2,3,4],[4,5,6]])
a7=np.ones_like(a6,dtype=float)
print(a7)
print('---')
a8=np.eye(3)
print(a8)
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
---
[[1. 1. 1.]
[1. 1. 1.]]
---
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
'''
【课程1.3】 Numpy通用函数
基本操作
'''
'\n【课程1.3 Numpy通用函数】 课程作业\n\n'
# 数组形状：.T/.reshape()/.resize()
# 注意了：.T/.reshape()/.resize()都是生成新的数组！！！
#是否生成新对象不用死记，需要时用is语句判断一下或者查api
#转置ar.T注意一维数组转置不变，二维数组转置即矩阵转置
ar1=np.arange(10)
ar2=np.ones((5,2))
print(ar1 is ar1.T)
print(ar1,'\n',ar1.T)
print(ar2,'\n',ar2.T)
print('----')
False
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]
[[1. 1.]
[1. 1.]
[1. 1.]
[1. 1.]
[1. 1.]]
[[1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1.]]
----
#两种用法reshape()（变形不变大小）
#reshape必须保证元素数量和newshape要求数量相同
# 用法1：直接将已有数组改变形状
ar3 = ar1.reshape(2,5)
# 用法2：生成数组后直接改变形状
ar4=np.arange(10).reshape((2,5))
# 用法3：np.reshape()参数内添加数组，目标形状
ar5 = np.reshape(np.arange(12),(3,4))
print(ar1 is ar3)
print(ar3)
print(ar4)
print(ar5)
print('----')
False
[[0 1 9 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 10 11]]
----
# numpy.resize(a, new_shape)（变形也变大小）
#返回具有指定形状的新数组，如有必要可重复填充所需数量的元素。
ar6=np.resize(np.arange(5),(2,3))
ar7=np.resize(np.arange(5),(2,2))
print(ar6)
print(ar7)
print('----')
#注意resize（）只能np.resize()一种用法
ar8=np.arange(6)
ar9=np.resize(ar8,(2,2))
print(ar8 is ar9)
print(ar9)
[[0 1 2]
[3 4 0]]
[[0 1]
[2 3]]
----
False
[[0 1]
[2 3]]
# 数组的复制
#python中is语句用来判断两个对象的引用是否相同（即两个对象是否指向同一个实体）
#==语句用来判断内容是否相同
ar1=np.arange(10)
ar2=ar1
print(ar1 is ar2)
#这里ar1和ar2指向同一个值，所以ar1改变，ar2一起改变
ar1[2]=9
print(ar1,ar2)
#copy方法生成数组及其数据的完整拷贝
# 再次提醒：.T/.reshape()/.resize()都是生成新的数组！！！
ar3=ar1.copy()
print(ar3 is ar1)
print(ar3 == ar1)
print(ar1 ,ar3)
True
[0 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
False
[ True True True True True True True True True True]
[0 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
# 数组类型转换：.astype()
# 可以在参数位置设置数组类型
ar1=np.arange(10,dtype=np.float)
print(ar1,ar1.dtype)
ar2=np.array([2,3,3,4],dtype=np.float)
print(ar2,ar2.dtype)
print("----")
ar3=ar1.astype(np.int32)
print(ar3,ar3.dtype)
# a.astype()：转换数组类型
# 注意：养成好习惯，数组类型用np.int32，而不是直接int32
ar3=ar1.astype
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64
[2. 3. 3. 4.] float64
----
[0 1 2 3 4 5 6 7 8 9] int32
# 数组堆叠
#横着叠加 np.hstack((a,b)) or np.stack((a,b),axis=0(缺省也可))
#竖着叠加 np.vstack((a,b)) or np.stack((a,b),axis=1)
#横着叠加可以理解为给每组数据增加几个属性
#竖着叠加可以理解为增加几组数据
#堆叠原则：a、b两数组与堆叠轴垂直方向的元素个数必须相同！
# numpy.hstack(tup)：水平（按列顺序）堆叠数组
a = np.arange(5) # a为一维数组，5个元素
b = np.arange(7,10)# b为一维数组,4个元素
#一维数组横着加
c = np.hstack((a,b))
print(a,a.shape)
print(b,b.shape)
print(c,c.shape)
print("----------")
#用np.stack（axis=1）方法和np.vstack()效果相同
#一维数组竖着加会变成二维数组
a = np.arange(5)
b = np.arange(5,10)
ar1 = np.stack((a,b))
ar2 = np.stack((a,b),axis = 1)
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
print(ar2,ar2.shape)
print("----------")
#二维数组横竖都可以加但和堆叠轴垂直方向的元素个数必须相同
a = np.array([[1],[2],[3]]) # a为二维数组，3行1列
b = np.array([['a'],['b'],['c']]) # b为二维数组，3行1列
ar2 = np.hstack((a,b)) # 注意:((a,b))，这里形状必须一样
print(a,a.shape)
print(b,b.shape)
print(ar2,ar2.shape)
print("----------")
a = np.array([[1],[2],[3]])
b = np.array([['a'],['b'],['c'],['d']])
ar2 = np.vstack((a,b))
print(a,a.shape)
print(b,b.shape)
print(ar2,ar2.shape)
print("----------")
[0 1 2 3 4] (5,)
[7 8 9] (3,)
[0 1 2 3 4 7 8 9] (8,)
----------
[0 1 2 3 4] (5,)
[5 6 7 8 9] (5,)
[[0 1 2 3 4]
[5 6 7 8 9]] (2, 5)
[[0 5]
[1 6]
[2 7]
[3 8]
[4 9]] (5, 2)
----------
[[1]
[2]
[3]] (3, 1)
[['a']
['b']
['c']] (3, 1)
[['1' 'a']
['2' 'b']
['3' 'c']] (3, 2)
----------
[[1]
[2]
[3]] (3, 1)
[['a']
['b']
['c']
['d']] (4, 1)
[['1']
['2']
['3']
['a']
['b']
['c']
['d']] (7, 1)
----------
# 数组拆分
# numpy.hsplit(ary, indices_or_sections)：将数组水平（逐列）拆分为多个子数组 → 按列拆分
# numpy.vsplit(ary, indices_or_sections)：:将数组垂直（行方向）拆分为多个子数组 → 按行拆
# 输出结果为列表，列表中元素为数组
ar=np.arange(100).reshape((10,10))
ar1=np.hsplit(ar,[1,3,6,100])#中间点列划分原则：左闭右开
print(ar)
print(ar1,type(ar1))
print('--------------')
ar2=np.vsplit(ar,[1,3,6,100])
print(ar2,type(ar2))
[[ 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 48 49]
[50 51 52 53 54 55 56 57 58 59]
[60 61 62 63 64 65 66 67 68 69]
[70 71 72 73 74 75 76 77 78 79]
[80 81 82 83 84 85 86 87 88 89]
[90 91 92 93 94 95 96 97 98 99]]
[array([[ 0],
[10],
[20],
[30],
[40],
[50],
[60],
[70],
[80],
[90]]), array([[ 1, 2],
[11, 12],
[21, 22],
[31, 32],
[41, 42],
[51, 52],
[61, 62],
[71, 72],
[81, 82],
[91, 92]]), array([[ 3, 4, 5],
[13, 14, 15],
[23, 24, 25],
[33, 34, 35],
[43, 44, 45],
[53, 54, 55],
[63, 64, 65],
[73, 74, 75],
[83, 84, 85],
[93, 94, 95]]), array([[ 6, 7, 8, 9],
[16, 17, 18, 19],
[26, 27, 28, 29],
[36, 37, 38, 39],
[46, 47, 48, 49],
[56, 57, 58, 59],
[66, 67, 68, 69],
[76, 77, 78, 79],
[86, 87, 88, 89],
[96, 97, 98, 99]]), array([], shape=(10, 0), dtype=int32)] <class 'list'>
--------------
[array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]), array([[10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
[20, 21, 22, 23, 24, 25, 26, 27, 28, 29]]), array([[30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
[40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
[50, 51, 52, 53, 54, 55, 56, 57, 58, 59]]), array([[60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
[70, 71, 72, 73, 74, 75, 76, 77, 78, 79],
[80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]]), array([], shape=(0, 10), dtype=int32)] <class 'list'>
# 数组简单运算
#运算对象都是列表内的每个元素
ar = np.arange(6).reshape(2,3)
print(ar+10)
print(ar*2)
print(1/(ar+1))
print(ar ** 0.5)
print('------')
# 求平均值
print(ar.mean())
# 求最大值
print(ar.max())
# 求最小值
print(ar.min())
# 求标准差
print(ar.std())
# 求方差
print(ar.var())
# 求和，np.sum() → axis为0，按列求和；axis为1，按行求和
print(np.sum(ar,axis=0),np.sum(ar,axis=1))
# 排序
print(np.sort(ar))
[[10 11 12]
[13 14 15]]
[[ 0 2 4]
[ 6 8 10]]
[[1. 0.5 0.33333333]
[0.25 0.2 0.16666667]]
[[0. 1. 1.41421356]
[1.73205081 2. 2.23606798]]
------
2.5
5
0
1.707825127659933
2.9166666666666665
[3 5 7] [ 3 12]
[[0 1 2]
[3 4 5]]
#作业answer
ar1 = np.resize(np.arange(20),(4,5))
ar2 = np.resize(np.arange(20),(5,6))
print(ar1)
print('--------')
print(ar2)
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
--------
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 0 1 2 3]
[ 4 5 6 7 8 9]]
ar1 = np.resize(np.arange(16),(4,4))
ar2=ar1.astype(str)
print(ar2)
[['0' '1' '2' '3']
['4' '5' '6' '7']
['8' '9' '10' '11']
['12' '13' '14' '15']]
ar1 = np.resize(np.arange(16),(4,4))
print(ar1)
result=ar1 *10 +100
print(result)
m=result.mean()
print(m)
s=result.sum()
print(s)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
[[100 110 120 130]
[140 150 160 170]
[180 190 200 210]
[220 230 240 250]]
175.0
2800
'''
【课程1.4】 Numpy索引及切片
核心：基本索引及切片 / 布尔型索引及切片
二维arr[][]第一个[]选第几行
第二个[]选第几列
'''
'\n【课程1.4】 Numpy索引及切片\n\n核心：基本索引及切片 / 布尔型索引及切片\n\narr[][]第一个[]选第几行\n第二个[]选第几列\n'
# 基本索引及切片
#一维arr切片和list切片相似
arr=np.arange(20)
print(arr[3])
print(arr[3:9:2])
print('----------')
# 二维数组索引及切片
#二维arr[][]第一个[]选第几行
#第二个[]选第几列
ar=np.arange(16).reshape(4,4)
print(ar)
print('----------')
print(ar[1],'维数%i'%ar[1].ndim)
print('----------')
#ar[,]和ar[][]有本质区别
#ar[][]是先对ar取行得到ar[] 再对ar[]取行得到ar【】【】
#ar【，】是同时对ar取行和列
print(ar[1:3][2:4],ar[1:3,2:4])
#故选列只有唯一写法ar[:,]，不能ar[:][1:3]此写法相当于此一次选行选全部行第二次依然对ar选行1：3
print(ar[:,1:3],'维数%i'%ar[:,1:3].ndim)
3
[3 5 7]
----------
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
----------
[4 5 6 7] 维数1
----------
[] [[ 6 7]
[10 11]]
[[ 1 2]
[ 5 6]
[ 9 10]
[13 14]] 维数2
# 布尔型索引及切片（重点）
# 布尔型索引：以布尔型的矩阵去做筛选
ar = np.arange(12).reshape(3,4)
i = np.array([True,False,True])
j = np.array([True,True,False,False])
print(ar)
print(i)
print(j)
print('----------')
# 在第一维度做判断，只保留True，这里第一维度就是行，ar[i,:] = ar[i]（简单书写格式）
print(ar[i])
#也可以写成
print(ar[i,:])
print('----------')
# 在第二维度做判断，这里如果ar[:,i]会有警告，因为i是3个元素，而ar在列上有4个
print(ar[:,j])
m=ar>5
print(m) # 这里m是一个判断矩阵
# 用m判断矩阵去筛选ar数组中>5的元素 → 重点！后面的pandas判断方式原理就来自此处
print(ar[m])
#两步写在一起
print(ar[ar>5])
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[ True False True]
[ True True False False]
----------
[[ 0 1 2 3]
[ 8 9 10 11]]
[[ 0 1 2 3]
[ 8 9 10 11]]
----------
[[0 1]
[4 5]
[8 9]]
[[False False False False]
[False False True True]
[ True True True True]]
[ 6 7 8 9 10 11]
[ 6 7 8 9 10 11]
# 数组索引及切片的值更改、复制
ar = np.arange(10)
print(ar)
ar[5] = 100
ar[7:9] = 200
print(ar)
# 一个标量赋值给一个索引/切片时，会自动改变/传播原始数组
ar = np.arange(10)
b = ar.copy()
b[7:9] = 200
print(ar)
print(b)
# 复制
[0 1 2 3 4 5 6 7 8 9]
[ 0 1 2 3 4 100 6 200 200 9]
[0 1 2 3 4 5 6 7 8 9]
[ 0 1 2 3 4 5 6 200 200 9]
#作业answer
ar=np.arange(25).reshape(5,5)
print(ar)
#第5行
print(ar[4])
#行列都选
print(ar[:2,3:])
#选两次行
print(ar[3][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 24]]
[20 21 22 23 24]
[[3 4]
[8 9]]
17
ar=np.arange(10).reshape(2,5)
print(ar)
ar1=ar[ar>5]
print(ar1)
[[0 1 2 3 4]
[5 6 7 8 9]]
[6 7 8 9]
'''
【课程1.5】 Numpy随机数
numpy.random包含多种概率分布的随机样本，是数据分析辅助的重点工具之一
1包含很多不同分布
2numpy.random.rand(d0, d1, ..., dn)
生成一个[0,1)之间的随机浮点数或N维浮点数组
注意是numpy.random.rand(2,3)而不是numpy.random.rand((2.3))
3numpy.random.randn(d0, d1, ..., dn)
生成一个浮点数或N维浮点数组 —— 标准正态分布N(0,1)
4
numpy.random.randint(low, high=None, size=None, dtype='l')：生成一个整数或N维整数数组
若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数，且high必须大于low
dtype参数：只能是int类型
'''
'\n【课程1.5】 Numpy随机数\n\nnumpy.random包含多种概率分布的随机样本，是数据分析辅助的重点工具之一\n\n'
#1np.random 模块带有很多不同分布的随机数生成器
#例如正态分布
samples=np.random.normal(size=(4,4))
print(samples)
[[ 0.00349639 -0.17851364 -0.06657346 2.80743748]
[ 0.62752024 -0.46410744 -1.49233935 0.48407116]
[-1.37509951 -0.95990995 -0.42126827 1.54242407]
[-1.10079455 1.42429884 -0.52925043 -2.0277138 ]]
# numpy.random.rand(d0, d1, ..., dn)：生成一个[0,1)之间的随机浮点数或N维浮点数组 —— 均匀分布
import matplotlib.pyplot as plt # 导入matplotlib模块，用于图表辅助分析
# 魔法函数，每次运行自动生成图表
%matplotlib inline
# 生成一个随机浮点数
a=np.random.rand()
print(a,type(a))
print('--------')
# 生成形状为4的一维数组
b=np.random.rand(4)
print(b,type(b))
print('--------')
# 生成形状为2*3的二维数组，注意这里不是((2,3))
c=np.random.rand(2,3)
print(c,type(c))
print('--------')
# 分布生成1000个均匀分布的样本值 作为x y值画图
samples1=np.random.rand(1000)
samples2=np.random.rand(1000)
plt.scatter(samples1,samples2)
# numpy.random.randn(d0, d1, ..., dn)：生成一个浮点数或N维浮点数组 —— 正态分布
# randn和rand的参数用法一样
# 生成1000个正太的样本值 可以发现聚集在均值0处
samples1=np.random.randn(1000)
samples2=np.random.randn(1000)
plt.scatter(samples1,samples2)
# numpy.random.randint(low, high=None, size=None, dtype='l')：生成一个整数或N维整数数组
# 若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数，且high必须大于low
# dtype参数：只能是int类型 ！！！
# low=2：生成1个[0,2)之间随机整数
print(np.random.randint(2))
# low=2,size=5 ：生成5个[0,2)之间随机整数
print(np.random.randint(2,size=5))
# low=2,high=6,size=5：生成5个[2,6)之间随机整数
print(np.random.randint(2,6,size=5))
# low=2,size=(2,3)：生成一个2x3整数数组,取数范围：[0,2)随机整数
print(np.random.randint(2,size=(2,3)))
# low=2,high=6,size=(2,3)：生成一个2*3整数数组,取值范围：[2,6)随机整
print(np.random.randint(2,6,size=(2,3)))
1
[1 1 0 0 1]
[5 3 4 4 4]
[[0 0 0]
[1 0 1]]
[[5 2 5]
[5 5 3]]
#作业answer
ar=np.arange(25,dtype=float).reshape(5,5)
for i in range(2):
for j in range(2):
ar[i,j]=np.random.rand()
print(ar)
#简单写法!!!
ar=np.arange(25,dtype=float).reshape(5,5)
ar[:2,:2] = np.random.rand(2,2)
print(ar)
[[ 0.34728371 0.70927325 2. 3. 4. ]
[ 0.71795438 0.51960233 7. 8. 9. ]
[10. 11. 12. 13. 14. ]
[15. 16. 17. 18. 19. ]
[20. 21. 22. 23. 24. ]]
[[ 0.16817561 0.24502865 2. 3. 4. ]
[ 0.15747558 0.57022017 7. 8. 9. ]
[10. 11. 12. 13. 14. ]
[15. 16. 17. 18. 19. ]
[20. 21. 22. 23. 24. ]]
ar1=np.random.randn(2,5)
ar2=np.random.randn(2,5)
ar3=np.vstack((ar1,ar2))
print(ar3)
[[-0.45279157 -0.23768002 0.39852735 -0.76711387 1.32067678]
[ 0.63628318 -2.50505989 -1.70924198 0.69569756 -0.12028902]
[ 0.71950624 0.67832949 -0.58387472 0.95610381 0.04767972]
[ 1.89528307 0.22299877 -0.21226804 1.66912874 0.8293707 ]]
'''
【课程1.6】 Numpy数据的输入输出
numpy读取/写入数组数据、文本数据
'''
'\n【课程1.6】 Numpy数据的输入输出\n\nnumpy读取/写入数组数据、文本数据\n\n'
# 存储数组数据 .npy文件
import os
os.chdir(r'C:\Users\HASEE\Desktop\pythontest')
ar=np.arange(10).reshape(2,5)
print(ar)
# 也可以直接不chdir np.save('C:/Users/Hjx/Desktop/arraydata.npy', ar)
# 注意存数组后缀名必须为.npy
np.save('ar_save.npy',ar)
print('finished')
[[0 1 2 3 4]
[5 6 7 8 9]]
finished
# 读取数组数据 .npy文件
# 也可以直接不chdir np.load('C:/Users/Hjx/Desktop/arraydata.npy')
ar_load=np.load('ar_save.npy')
print(ar_load)
[[0 1 2 3 4]
[5 6 7 8 9]]
# 存储/读取文本文件
#numpy.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ', encoding=None)[source]
ar=np.random.rand(5,5)
np.savetxt('ar_save.txt',ar,delimiter=",",fmt='%.2f')
print('finished')
ar_load=np.loadtxt('ar_save.txt',delimiter=",")
print(ar_load)
finished
[[0.6 0.99 0.51 0.4 0.16]
[0.83 0.18 0.15 0.45 0.78]
[0.37 0.36 0.53 0.27 0.63]
[0.94 0.41 0.35 0.16 0.87]
[0.03 0.7 0.18 0.81 0.95]]
#作业answer
import numpy as np
ar=np.random.randint(0,100,size=(10,10))
np.savetxt('ar_save_homework.txt',ar,delimiter=',')
print(ar)
[[84 82 96 96 95 67 13 22 71 80]
[10 15 84 87 49 7 60 96 48 25]
[16 15 79 17 17 94 21 4 75 7]
[20 73 0 47 92 49 28 56 14 60]
[31 23 21 90 85 47 18 63 26 70]
[27 50 77 2 56 38 39 14 5 69]
[72 21 46 1 97 82 45 51 23 98]
[88 89 48 62 94 70 38 44 68 31]
[19 3 54 90 79 48 45 52 40 43]
[20 74 84 24 1 22 7 71 94 33]]