Numpy

Numpy的常用属性

import numpy as np

## 多维数组
ar = np.array([[1,2,3],[3,5,6]])
print([1,2,3,4,5,6])
print(ar,type(ar))
print(ar.ndim) # 输出数组维度的个数（轴数），或者说“秩”，维度的数量也称rank
print(ar.shape) # 返回数组的维度，对于n行m列的数组，shape为（n，m）
print(ar.size) # 总共元素的个数 
print(type(ar),ar.dtype)  # 数组中元素的类型
print(ar.itemsize) # 元素的字节个数
print(ar.data) # 数字在内存中的位置 ，不常用
print(ar)
print('------')
ar  # 交互式輸出会加上array

[1, 2, 3, 4, 5, 6]
[[1 2 3]
 [3 5 6]] <class 'numpy.ndarray'>
2
(2, 3)
6
<class 'numpy.ndarray'> int32
4
<memory at 0x0000027BA26518B8>
[[1 2 3]
 [3 5 6]]
------





array([[1, 2, 3],
       [3, 5, 6]])

numpy创建数组

array

# 创建数组：array()函数，括号内可以是列表、元祖、数组、生成器等
ar1 = np.array(range(10))
ar2 = np.arange(10)
ar3 = np.array([1,2,3,4,5,6])
ar3 = np.array([[1,2,3],[4,5,6]])
ar4 = np.array([[1,2,3],['a','b','c']]) # 如果包含字符串，则数组中的所有对象都会变成字符串类型
ar5 = np.array([[1,2,3],['a','b','c','d']]) # 如果二维数组中的子数组中的元素个数不一致，那么它将变成一个一维数组

print(ar1)
print(ar2)
print(ar3)
print(ar4)
print(ar5,ar5.ndim)

print(np.random.rand(10).reshape(2,5)) # 10个随机数，2*5的数组形式

[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]
[[1 2 3]
 [4 5 6]]
[['1' '2' '3']
 ['a' 'b' 'c']]
[list([1, 2, 3]) list(['a', 'b', 'c', 'd'])] 1
[[0.83421774 0.32147841 0.14523585 0.3816442  0.72546904]
 [0.49809788 0.47585076 0.32133705 0.2083979  0.28646501]]

arange

# 创建数组：arange()，类似range()，在给定间隔内返回均匀间隔的值。

print(np.arange(10))    # 返回0-9，整型
print(np.arange(10.0))  # 返回0.0-9.0，浮点型
print(np.arange(5,12))  # 返回5-11
print(np.arange(5.0,12,2))  # 返回5.0-12.0，步长为2
print(np.arange(10000))  # 如果数组太大而无法打印，NumPy会自动跳过数组的中心部分，并只打印边角：

[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.  9. 11.]
[   0    1    2 ... 9997 9998 9999]

linespace

# 创建数组：linspace():返回在间隔[开始，停止]上计算的num个均匀间隔的样本。

print(np.linspace(10,14,num=4)) # 因为是前闭合后闭合，所有每段间隔是(14-10)/(num-1) = 4/3 = 1.333333
print(np.linspace(10,14,num=5)) # 4/(5-1)
print(np.linspace(10,14,num=3)) # 4/(3-1)

print(np.linspace(10,14,num=4,endpoint=False)) # 设置不包含最后一个数 此时间隔等于 (14-10)/4 = 1
print(np.linspace(10,14,num=4,retstep=True)) # 返回一个元祖，第一个元素为列表，第二个元素为步长

[10.         11.33333333 12.66666667 14.        ]
[10. 11. 12. 13. 14.]
[10. 12. 14.]
[10. 11. 12. 13.]
(array([10.        , 11.33333333, 12.66666667, 14.        ]), 1.3333333333333333)

zeros填充

# 创建数组：zeros()/zeros_like()/ones()/ones_like()

ar1 = np.zeros(5)  # 创建一个一维数组，用0填充
ar2 = np.zeros((2,2), dtype = np.int) # 创建一个2*2的二维数组，用0填充，并指定填充元素类型为int
print(ar1,ar1.dtype)
print(ar2,ar2.dtype)
print('------')
# numpy.zeros(shape, dtype=float, order='C'):返回给定形状和类型的新数组，用零填充。
# shape：数组纬度，二维以上需要用()，且输入参数为整数
# dtype：数据类型，默认numpy.float64
# order：是否在存储器中以C或Fortran连续（按行或列方式）存储多维数据。

ar3 = np.array([list(range(5)),list(range(5,10))]) 
ar4 = np.zeros_like(ar3) # 根据指定的模具数据用0填充
print(ar3)
print(ar4)
print('------')
# 返回具有与给定数组相同的形状和类型的零数组，这里ar4根据ar3的形状和dtype创建一个全0的数组

ar5 = np.ones(9)
ar6 = np.ones((2,3,4))
ar7 = np.ones_like(ar3)
print(ar5)
print(ar6)
print(ar7)
# ones()/ones_like()和zeros()/zeros_like()一样，只是填充为1

[0. 0. 0. 0. 0.] float64
[[0 0]
 [0 0]] int32
------
[[0 1 2 3 4]
 [5 6 7 8 9]]
[[0 0 0 0 0]
 [0 0 0 0 0]]
------
[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.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]]
[[1 1 1 1 1]
 [1 1 1 1 1]]

eye N*N单位矩阵

# 创建数组：eye()

print(np.eye(5))
# 创建一个正方的N*N的单位矩阵，对角线值为1，其余为0

[[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位浮点数表示实部和虚部

####### 课后作业 ########

import numpy as np

ar1 = np.array([range(1,3),'a','hello',range(1,4),{'two':200,'one':100}])
print(ar1,ar1.shape)

ar2 = np.array([range(6),[chr(i) for i in range(97,103)],[bool(i%2) for i in range(1,7)]])
print(ar2,ar2.shape)

[range(1, 3) 'a' 'hello' range(1, 4) {'two': 200, 'one': 100}] (5,)
[['0' '1' '2' '3' '4' '5']
 ['a' 'b' 'c' 'd' 'e' 'f']
 ['True' 'False' 'True' 'False' 'True' 'False']] (3, 6)

ar3  = np.linspace(5,15,num=10,endpoint=False,dtype = np.int)
print(ar3)

[ 5  6  7  8  9 10 11 12 13 14]

print(np.zeros((4,4)))
print('--------')
print(np.ones((2,3),dtype = np.int))
print('-'*10)
print(np.eye(3))

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

numpy通用函数

'''
【课程1.3】  Numpy通用函数

基本操作

'''

# 数组形状：.T/.reshape()/.resize()

ar1 = np.arange(10)
ar2 = np.ones((5,2))
print(ar1,'\n',ar1.T)
print(ar2,'\n',ar2.T)
print('------')
# .T方法：转置，例如原shape为(3,4)/(2,3,4)，转置结果为(4,3)/(4,3,2) → 所以一维数组转置后结果不变

ar3 = ar1.reshape(2,5)     # 用法1：直接将已有数组改变形状,必须保证元素数量一致 10 = 2*5             
ar4 = np.zeros((4,6)).reshape(3,8)   # 用法2：生成数组后直接改变形状
ar5 = np.reshape(np.arange(12),(3,4))   # 用法3：参数内添加数组，目标形状
print(ar1,'\n',ar3)
print(ar4)
print(ar5)
print('------')
# numpy.reshape(a, newshape, order='C')：为数组提供新形状，而不更改其数据，所以元素数量需要一致！！

ar6 = np.resize(np.arange(5),(3,4)) # 元素数量可以不一致，少于，默认排序，大于，默认迭代
ar7 = np.arange(10)

print(ar6)
print(ar7.resize((3,4))) # None，因为如果是使用的实例方法而不是类方法的resize时，要求元素个数必须保持一致，
                        # 因为他不会返回一个新的数组，而是改变的这个数组本身

# numpy.resize(a, new_shape)：类方法返回具有指定形状的新数组，如有必要可重复填充所需数量的元素。
# 注意了：.T/.reshape()/.resize()都是生成新的数组！！！

[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.]]
------
[0 1 2 3 4 5 6 7 8 9] 
 [[0 1 2 3 4]
 [5 6 7 8 9]]
[[0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0.]]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
------
[[0 1 2 3]
 [4 0 1 2]
 [3 4 0 1]]
None

copy数组的复制

# 数组的复制

ar1 = np.arange(10)
ar2 = ar1
print(ar2 is ar1)
ar1[2] = 9
print(ar1,ar2)
# 回忆python的赋值逻辑：指向内存中生成的一个值 → 这里ar1和ar2指向同一个值，所以ar1改变，ar2一起改变

ar3 = ar1.copy()
print(ar3 is ar1)
ar1[0] = 9
print(ar1,ar3)
# copy方法生成数组及其数据的完整拷贝
# 再次提醒：.T/.reshape()/.resize()都是生成新的数组！！！

True
[0 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
False
[9 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]

astype 数组类型转换

# 数组类型转换：.astype()

ar1 = np.arange(10,dtype=float)
print(ar1,ar1.dtype)
print('-----')
# 可以在参数位置设置数组类型

ar2 = ar1.astype(np.int32)
print(ar2,ar2.dtype)
print(ar1,ar1.dtype)
# a.astype()：转换数组类型
# 注意：养成好习惯，数组类型用np.int32，而不是直接int32

[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64
-----
[0 1 2 3 4 5 6 7 8 9] int32
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64

stack数组堆叠

# 数组堆叠

a = np.arange(5)    # a为一维数组，5个元素
b = np.arange(5,9) # b为一维数组,4个元素
ar1 = np.hstack((a,b))  # 注意:((a,b))，这里形状可以不一样
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
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('-----')
# numpy.hstack(tup)：水平（按列顺序）堆叠数组

a = np.arange(5)    
b = np.arange(5,10)
ar1 = np.vstack((a,b))
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
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('-----')
# numpy.vstack(tup)：垂直（按列顺序）堆叠数组

a = np.arange(5)    
b = np.arange(5,10)
ar1 = np.stack((a,b))
ar2 = np.stack((a,b),axis = 1) # 默认是0，意思是竖直堆叠，1是代表水平堆叠
print(a,a.shape)
print(b,b.shape)
print(ar1,ar1.shape)
print(ar2,ar2.shape)
# numpy.stack(arrays, axis=0)：沿着新轴连接数组的序列，形状必须一样！
# 重点解释axis参数的意思，假设两个数组[1 2 3]和[4 5 6]，shape均为(3,0)
# axis=0：[[1 2 3] [4 5 6]]，shape为(2,3)
# axis=1：[[1 4] [2 5] [3 6]]，shape为(3,2)

[0 1 2 3 4] (5,)
[5 6 7 8] (4,)
[0 1 2 3 4 5 6 7 8] (9,)
[[1]
 [2]
 [3]] (3, 1)
[['a']
 ['b']
 ['c']] (3, 1)
[['1' 'a']
 ['2' 'b']
 ['3' 'c']] (3, 2)
-----
[0 1 2 3 4] (5,)
[5 6 7 8 9] (5,)
[[0 1 2 3 4]
 [5 6 7 8 9]] (2, 5)
[[1]
 [2]
 [3]] (3, 1)
[['a']
 ['b']
 ['c']
 ['d']] (4, 1)
[['1']
 ['2']
 ['3']
 ['a']
 ['b']
 ['c']
 ['d']] (7, 1)
-----
[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)

split数组拆分

# 数组拆分 

ar = np.arange(16).reshape(4,4)
ar1 = np.hsplit(ar,2)
print(ar)
print(ar1,type(ar1))
# numpy.hsplit(ary, indices_or_sections)：将数组水平（逐列）拆分为多个子数组 → 按列拆分
# 输出结果为列表，列表中元素为数组

ar2 = np.vsplit(ar,4)
print(ar2,type(ar2))
# numpy.vsplit(ary, indices_or_sections)：:将数组垂直（行方向）拆分为多个子数组 → 按行拆

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])] <class 'list'>
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]]), array([[12, 13, 14, 15]])] <class 'list'>

数字的简单运算函数

# 数组简单运算

ar = np.arange(6).reshape(2,3)
print(ar + 10)   # 加法
print(ar * 2)   # 乘法
print(1 / (ar+1))  # 除法
print(ar ** 0.5)  # 幂
# 与标量的运算

print(ar.mean())  # 求平均值
print(ar.max())  # 求最大值
print(ar.min())  # 求最小值
print(ar.std())  # 求标准差
print(ar.var())  # 求方差
print(ar.sum(), np.sum(ar,axis = 0))  # 求和，np.sum() → axis为0，按列求和；axis为1，按行求和
print(np.sort(np.array([1,4,3,2,5,6])))  # 排序
# 常用函数

[[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
15 [3 5 7]
[1 2 3 4 5 6]

课后作业

import numpy as np

ar1 = np.arange(20)
print(ar1.reshape(4,5))
print('-'*20)
print(np.resize(ar1,(5,6)))

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

ar3 = np.arange(16).reshape(4,4)
ar4 = ar3.astype(np.str)

print(ar3)
print(ar4)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
[['0' '1' '2' '3']
 ['4' '5' '6' '7']
 ['8' '9' '10' '11']
 ['12' '13' '14' '15']]

ar5 = np.arange(16).reshape(4,4)
ar6 = ar5*10+100
ar7 = ar6.mean()
ar8 = ar6.sum()

print('创建数组为：')
print(ar5)
print('-'*20)
print('计算后数组为：')
print(ar6)
print('-'*20)
print('result均值为：')
print(ar7)
print('-'*20)
print('result求和为：')
print(ar8)
print('-'*20)

创建数组为：
[[ 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]]
--------------------
result均值为：
175.0
--------------------
result求和为：
2800
--------------------

数组的索引及切片

'''
【课程1.4】  Numpy索引及切片

核心：基本索引及切片 / 布尔型索引及切片

'''

基本索引和切片

# 一维数组的索引和切片

ar1 = np.arange(20)
print(ar1)
print(ar1[4])
print(ar1[1:3])
print(ar1[:3])
print(ar1[::2])

print('------')

# 二维数组的索引和切片

ar2 = np.arange(20).reshape(5,4)
print(ar2)
print(ar2[4])
print(ar2[1:3])
print(ar2[:3])
print(ar2[::2])
print(ar2[2][2]) # 第三行，第三列
print(ar2[2,2]) # 同上
print(ar2[:1,2:]) # 索引为【0,1)的行，加上索引为【2,..]的列

print('------')

#三维数组的索引及切片
ar = np.arange(12).reshape(3,2,2)  # 3个2维的2*2数组
print(ar, '数组轴数为%i' %ar.ndim)   # 3*2*2的数组
print(ar[0],  '数组轴数为%i' %ar[0].ndim)  # 三维数组的下一个维度的第一个元素 → 一个二维数组
print(ar[0][0],  '数组轴数为%i' %ar[0][0].ndim)  # 三维数组的下一个维度的第一个元素下的第一个元素 → 一个一维数组
print(ar[0][0][1],  '数组轴数为%i' %ar[0][0][1].ndim)  

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

 [[ 4  5]
  [ 6  7]]

 [[ 8  9]
  [10 11]]] 数组轴数为3
[[0 1]
 [2 3]] 数组轴数为2
[0 1] 数组轴数为1
1 数组轴数为0

布尔类型索引及切片

# 布尔型索引及切片

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(ar[i,:])  # 在第一维度做判断，只保留True，这里第一维度就是行，ar[i,:] = ar[i]（简单书写格式）
print(ar[:,j])  # 在第二维度做判断，这里如果ar[:,i]会有警告，因为i是3个元素，而ar在列上有4个
# 布尔型索引：以布尔型的矩阵去做筛选

m = ar > 5
print(m)  # 这里m是一个判断矩阵
print(ar[m])  # 用m判断矩阵去筛选ar数组中>5的元素 → 重点！后面的pandas判断方式原理就来自此处

[[ 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]
 [4 5]
 [8 9]]
[[False False False False]
 [False False  True  True]
 [ True  True  True  True]]
[ 6  7  8  9 10 11]

# 数组索引及切片的值更改、复制

ar = np.arange(10)
ar[5] = 100
ar[7:9] = 200
print(ar)
print(ar)
# 一个标量赋值给一个索引/切片时，会自动改变/传播原始数组

ar = np.arange(10)
b = ar.copy()
b[7:9] = 200
print(ar)
print(b)
# 复制

[  0   1   2   3   4 100   6 200 200   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]

课后作业 #####

import numpy as np

# print(np.arange(25).reshape(5,5))
# print(np.arange(25).resize(5,5)) # None 不知道为什么
# ar = np.arange(25)
# ar.resize(5,5) # 有值，不知道为什么
# print(ar)
'''-------'''

ar1 = np.arange(25).reshape(5,5)
print(ar1)
print(ar1[4])
print(ar1[:2,3:]) # 行[0,2) 0 1 列 [3,..] 4 5
print(ar1[3][2],ar1[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 17

ar2 = np.arange(10).reshape(2,5)
print(ar2)
print(ar2>3,type(ar2>3))
print(ar2[ar2>3])

[[0 1 2 3 4]
 [5 6 7 8 9]]
[[False False False False  True]
 [ True  True  True  True  True]] <class 'numpy.ndarray'>
[4 5 6 7 8 9]

numpy生成随机数

'''
【课程1.5】  Numpy随机数

numpy.random包含多种概率分布的随机样本，是数据分析辅助的重点工具之一

'''

简单生成

# 随机数生成

samples = np.random.normal(size=(4,4))
print(samples)
# 生成一个标准正太分布的4*4样本值

[[-0.18160338  0.20622924 -0.21799183 -0.6241566 ]
 [ 1.214906    1.03613652 -1.27345685 -0.3485424 ]
 [-0.054222    1.35853345  1.10045646 -1.14334348]
 [-0.07831668  0.49175591 -1.77743151 -0.46343997]]

生成均匀分布随机数

# 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))  # 生成一个随机浮点数

b = np.random.rand(4)
print(b,type(b))  # 生成形状为4的一维数组

c = np.random.rand(2,3)
print(c,type(c))  # 生成形状为2*3的二维数组，注意这里不是((2,3))

samples1 = np.random.rand(1000)
samples2 = np.random.rand(1000)
plt.scatter(samples1,samples2)
# 生成1000个均匀分布的样本值

0.6862741724874453 <class 'float'>
[0.50254093 0.61065126 0.75185139 0.24764904] <class 'numpy.ndarray'>
[[0.5794343  0.10450978 0.76653299]
 [0.65061612 0.54301952 0.93364683]] <class 'numpy.ndarray'>





<matplotlib.collections.PathCollection at 0x27ba9734978>

生成正态分布随机数

#  numpy.random.randn(d0, d1, ..., dn)：生成一个浮点数或N维浮点数组 —— 正态分布

samples1 = np.random.randn(1000)
samples2 = np.random.randn(1000)
plt.scatter(samples1,samples2)
# randn和rand的参数用法一样
# 生成1000个正太的样本值

print(np.random.randn())

-0.1789700086145213

随机整数

  # numpy.random.randint(low, high=None, size=None, dtype='l')：生成一个整数或N维整数数组
# 若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数，且high必须大于low 
# dtype参数：只能是int类型  

print(np.random.randint(2))
# low=2：生成1个[0,2)之间随机整数  

print(np.random.randint(2,size=5))
# low=2,size=5 ：生成5个[0,2)之间随机整数

print(np.random.randint(2,6,size=5))
# low=2,high=6,size=5：生成5个[2,6)之间随机整数  

print(np.random.randint(2,size=(2,3)))
# low=2,size=(2,3)：生成一个2x3整数数组,取数范围：[0,2)随机整数 

print(np.random.randint(2,6,(2,3)))
# low=2,high=6,size=(2,3)：生成一个2*3整数数组,取值范围：[2,6)随机整数  

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

课堂作业 ######

Numpy数据的输入输出

'''
【课程1.6】  Numpy数据的输入输出

numpy读取/写入数组数据、文本数据

'''

存储为 .npy文件

# 存储为 .npy文件
import os

os.chdir('D:/data/numpyData')
data = np.random.rand(5,5) # 5*5均匀分布数据
print(data)
np.save('test.npy',data)
print('finish')

[[0.54850602 0.58373907 0.18795401 0.0226424  0.22199667]
 [0.35694879 0.59009754 0.28728852 0.67566864 0.47790463]
 [0.76710413 0.94102186 0.75688097 0.84601074 0.31978614]
 [0.08589456 0.93248349 0.07761082 0.64532422 0.95388631]
 [0.70568787 0.12863345 0.67776179 0.80407273 0.9225071 ]]
finish

读取 .npy文件

# 读取 .npy文件
ar_data = np.load('test.npy')
print(ar_data)

[[0.54850602 0.58373907 0.18795401 0.0226424  0.22199667]
 [0.35694879 0.59009754 0.28728852 0.67566864 0.47790463]
 [0.76710413 0.94102186 0.75688097 0.84601074 0.31978614]
 [0.08589456 0.93248349 0.07761082 0.64532422 0.95388631]
 [0.70568787 0.12863345 0.67776179 0.80407273 0.9225071 ]]

存储读取 .txt文件

# 存储为 .txt文件

data = np.random.randn(6,6) # 6*6 正态分布数据
print(data)
np.savetxt('test2.txt',data,delimiter=',',fmt='%.2f') #  fmt='%.18e' 计数规则默认为科学计数法
# np.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ')：存储为文本txt文件
print('finish')

# 读取 .txt 文件
text_data = np.loadtxt('test2.txt',delimiter=',')
print(text_data,text_data.dtype)  # 注意，这里读取的数据类型是数字，而不是字符串

[[-0.3791861  -1.50700702  0.11987358 -1.24965132 -0.65090045  0.12503085]
 [-1.25927883  2.0463003  -0.12510273  0.43390981  2.46500607  0.01940709]
 [-1.23873254 -0.99864883 -0.46457897  0.58459999  0.58592385  1.07350085]
 [-0.40642553 -1.27612175 -0.38542822  1.63223615  0.66626078  1.43785756]
 [-0.39442504 -2.28657061 -0.93061411  1.88317675  0.82825446 -0.56481557]
 [-0.66478508  0.58641393  0.73772497 -1.04481532  0.58578931 -1.8321912 ]]
finish
[[-0.38 -1.51  0.12 -1.25 -0.65  0.13]
 [-1.26  2.05 -0.13  0.43  2.47  0.02]
 [-1.24 -1.   -0.46  0.58  0.59  1.07]
 [-0.41 -1.28 -0.39  1.63  0.67  1.44]
 [-0.39 -2.29 -0.93  1.88  0.83 -0.56]
 [-0.66  0.59  0.74 -1.04  0.59 -1.83]] float64