生成0和1的数组
生成固定范围数组
生成随机数组
创建数组:arange(),类似range(),在给定间隔内返回均匀间隔的值。
创建等差数组 — 指定步长
np.arange(10, 50, 2)
返回结果:
array([10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42,
44, 46, 48])
import numpy as np
# 创建数组: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]
Process finished with exit code 0
linspace():返回在间隔[开始,停止]上计算的num个均匀间隔的样本。
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
# 生成等间隔的数组
np.linspace(0, 100, 11)
返回结果:
array([ 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100.])
import numpy as np
# 创建数组:linspace():返回在间隔[开始,停止]上计算的num个均匀间隔的样本。
ar1 = np.linspace(2.0, 3.0, num=5)
ar2 = np.linspace(2.0, 3.0, num=5, endpoint=False)
ar3 = np.linspace(2.0, 3.0, num=5, retstep=True)
print(ar1, type(ar1))
print(ar2)
print(ar3, type(ar3))
打印结果:
[2. 2.25 2.5 2.75 3. ] <class 'numpy.ndarray'>
[2. 2.2 2.4 2.6 2.8]
(array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) <class 'tuple'>
Process finished with exit code 0
np.logspace(start,stop, num)
创建等比数列
参数:
# 生成10^x
np.logspace(0, 2, 3)
返回结果:
array([ 1., 10., 100.])
生成0和1的数组
ones = np.ones([4,8])
print(ones)
返回结果:
array([[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.]])
numpy.zeros(shape, dtype=float, order=‘C’):返回给定形状和类型的新数组,用零填充。
返回具有与给定数组相同的形状和类型的零数组,这里ar4根据ar3的形状和dtype创建一个全0的数组
np.zeros_like(ones)
返回结果:
array([[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., 0., 0., 0., 0., 0., 0., 0.]])
import numpy as np
# 创建数组: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=np.int)
print('ar1 = {0}, ar1.dtype = {1}'.format(ar1, ar1.dtype))
print('ar2 = {0}, ar2.dtype = {1}'.format(ar2, ar2.dtype))
print('-' * 50)
# zeros_like(): 返回具有与给定数组相同的形状和类型的零数组,这里ar4根据ar3的形状和dtype创建一个全0的数组
ar3 = np.array([list(range(5)), list(range(5, 10))])
ar4 = np.zeros_like(ar3)
print('ar3 = ', ar3)
print('ar4 = ', ar4)
print('-' * 50)
# ones()/ones_like()和zeros()/zeros_like()一样,只是填充为1
ar5 = np.ones(9)
ar6 = np.ones((2, 3, 4))
ar7 = np.ones_like(ar3)
print('ar5 = ', ar5)
print('ar6 = ', ar6)
print('ar7 = ', ar7)
打印结果:
ar1 = [0. 0. 0. 0. 0.], ar1.dtype = float64
ar2 = [[0 0]
[0 0]], ar2.dtype = int32
--------------------------------------------------
ar3 = [[0 1 2 3 4]
[5 6 7 8 9]]
ar4 = [[0 0 0 0 0]
[0 0 0 0 0]]
--------------------------------------------------
ar5 = [1. 1. 1. 1. 1. 1. 1. 1. 1.]
ar6 = [[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]]
ar7 = [[1 1 1 1 1]
[1 1 1 1 1]]
Process finished with exit code 0
array()函数,括号内可以是列表、元祖、数组、生成器等
np.array(object, dtype)
np.asarray(a, dtype)
a = np.array([[1,2,3],[4,5,6]])
# 从现有的数组当中创建,深拷贝
a1 = np.array(a)
# 相当于索引的形式,并没有真正的创建一个新的,浅拷贝
a2 = np.asarray(a)
import numpy as np
# 整型
ar1 = np.array(range(10))
# 浮点型
ar2 = np.array([1, 2, 3.14, 4, 5])
# 二维数组:嵌套序列(列表,元祖均可)
ar3 = np.array([[1, 2, 3], ('a', 'b', 'c')]) # 二维数组,共6个元素
# 注意嵌套序列数量不一会怎么样
ar4 = np.array([[1, 2, 3], ('a', 'b', 'c', 'd')]) # 一维数组,共2个元素
print('ar1 = {0}, type(ar1) = {1}, ar1.dtype = {2}'.format(ar1, type(ar1), ar1.dtype))
print('ar2 = {0}, type(ar2) = {1}, ar2.dtype = {2}'.format(ar2, type(ar2), ar2.dtype))
print('ar3 = {0}, ar3.shape = {1}, ar3.ndim = {2}, ar3.size = {3}'.format(ar3, ar3.shape, ar3.ndim, ar3.size))
print('ar4 = {0}, ar4.shape = {1}, ar4.ndim = {2}, ar4.size = {3}'.format(ar4, ar4.shape, ar4.ndim, ar4.size))
打印结果:
main.py:10: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray
ar4 = np.array([[1, 2, 3], ('a', 'b', 'c', 'd')]) # 一维数组,共2个元素
ar1 = [0 1 2 3 4 5 6 7 8 9], type(ar1) = <class 'numpy.ndarray'>, ar1.dtype = int32
ar2 = [1. 2. 3.14 4. 5. ], type(ar2) = <class 'numpy.ndarray'>, ar2.dtype = float64
ar3 = [['1' '2' '3']
['a' 'b' 'c']], ar3.shape = (2, 3), ar3.ndim = 2, ar3.size = 6
ar4 = [list([1, 2, 3]) ('a', 'b', 'c', 'd')], ar4.shape = (2,), ar4.ndim = 1, ar4.size = 2
Process finished with exit code 0
"""
创建多维数组(二维数组):
arange(n)只能创建 0 ~ n-1 数组,只能是整数,如果需要元素是其他类型(例如:str等)无法满足
array() 创建数组元素没有类型限制
二维数组,一定是数组嵌套数组
默认元素是字符串
"""
from numpy import *
m1 = array([arange(3), arange(3), arange(3)])
print('m1 = ', m1)
m2 = array([["a", "b", 4],
[1, 2, 3],
[2.3, "2.4", 90]])
print('m2 = ', m2)
print('m2.shape = ', m2.shape) # 输出元组,第一个为行,第二个元素为列
print("{}是{}维数组".format("m2", len(m2.shape)))
打印结果:
m1 = [[0 1 2]
[0 1 2]
[0 1 2]]
m2 = [['a' 'b' '4']
['1' '2' '3']
['2.3' '2.4' '90']]
m2.shape = (3, 3)
m2是2维数组
Process finished with exit code 0
关于array和asarray的不同
numpy.random包含多种概率分布的随机样本,是数据分析辅助的重点工具之一。
函数名 | 使用 | 作用 |
---|---|---|
seed() | np.random.seed(n) | 随机种子生成器,使得用numpy各种函数生成的随机数为由种子数决定的“特定”的随机数,如果seed中参数为空,则生成的随机数“完全”随机(比如:指定n=1,则下一次生成的随机数与 1 相关,并不是完全随机) |
random() | np.random.random((1000,20)) | 生成1000个随机浮点数,从0-20中随机 |
rand() | np.random.rand(d0,d1,…,dn) | 生成一个[0,1)之间的随机浮点数或N维浮点数组 |
randn() | np.random.randn(d0,d1,…,dn) | 生成一个浮点数或N维浮点数组,取数范围:正态分布的随机样本数 |
randint() | np.random.randint(low,high=None,size=None,dtype=‘1’) | 生成一个整数或N维整数数组,取数范围:若high不为None时,取[low,high)之间的随机整数;否则取[0,low)之间的随机整数 |
normal() | np.random.normal(size=None) | 生成一个浮点数或N维浮点数组,取数范围:正态分布的随机样本 |
standard_normal() | np.random.standard_normal(size=None) | 生成一个浮点数或N维浮点数组,取数范围:标准正态分布的随机样本 |
random_integers() | np.random.random_integers(low,high=None,size=None) | 生成一个整数或N维整数数组,取数范围:若high不为None时,取[low,high]之间的随机整数;否则取[1,low]之间的随机整数 |
random_sample() | np.random.random_sample(size=None) | 生成一个[0,1)之间随机浮点数或N维浮点数组 |
choice() | np.random.choice(a,size=None,replace=True,p=None) | 从序列中获取元素,若a为整数,元素取值为np.range(a)中随机数;若a为数组,取值为a数组元素中随机元素 |
shuffle() | np.random.shuffle(X) | 对X进行重排序,若X为多维数组,只沿第一条轴洗牌,输出为None |
permutation() | np.random.permutation(X) | 与np.random.shuffle(X)功能相同,两者区别:permutation(X)不会修改X的顺序 |
uniform() | np.random.uniform(low=0.0, high=1.0, size=None) | 从一个均匀分布[low,high)中随机采样,注意定义域是左闭右开,即包含low,不包含high |
什么是正态分布:正态分布是一种概率分布。正态分布是具有两个参数μ和σ的连续型随机变量的分布,第一参数μ是服从正态分布的随机变量的均值,第二个参数σ是此随机变量的标准差,所以正态分布记作N(μ,σ )。
正态分布的应用:生活、生产与科学实验中很多随机变量的概率分布都可以近似地用正态分布来描述。
正态分布特点:μ决定了其位置,其标准差σ:决定了分布的幅度。当μ = 0,σ = 1时的正态分布是标准正态分布。
numpy.random.randn(d0, d1, …, dn):生成一个浮点数或N维浮点数组 —— 正态分布
import numpy as np
# numpy.random.randn(d0, d1, ..., dn):生成一个浮点数或N维浮点数组 —— 正态分布
import matplotlib.pyplot as plt # 导入matplotlib模块,用于图表辅助分析
# randn和rand的参数用法一样
# 生成1000个正太的样本值
samples1 = np.random.randn(1000)
samples2 = np.random.randn(1000)
plt.scatter(samples1, samples2)
plt.show()
loc:float
scale:float
size:int or tuple of ints
import numpy as np
# 随机数生成
# 生成一个标准正太分布的4*4样本值
samples = np.random.normal(size=(4, 4))
print('samples = ', samples)
打印结果:
samples = [
[-0.86201186 1.48464075 0.4467651 0.14612261]
[ 0.75834339 -0.49389563 -2.12561416 -0.47585096]
[-1.36229232 1.51312111 -0.6907586 -0.02197911]
[ 0.89089281 0.45599011 -0.06165468 -0.46591592]]
举例1:生成均值为1.75,标准差为1的正态分布数据,100000000个:
x1 = np.random.normal(1.75, 1, 100000000)
返回结果:
array([2.90646763, 1.46737886, 2.21799024, ..., 1.56047411, 1.87969135, 0.9028096 ])
import numpy as np
import matplotlib.pyplot as plt
# 生成均匀分布的随机数
x1 = np.random.normal(1.75, 1, 100000000)
# 画图看分布状况
# 1)创建画布
plt.figure(figsize=(20, 10), dpi=100)
# 2)绘制直方图
plt.hist(x=x1, bins=1000) # x代表要使用的数据,bins表示要划分区间数
# 3)显示图像
plt.show()
举例2:随机生成4支股票1周的交易日涨幅数据(模拟生成一组股票的涨跌幅的数据):
4支股票,一周(5天)的涨跌幅数据,如何获取?:随机生成涨跌幅在某个正态分布内,比如均值0,方差1
# 股票涨跌幅数据的创建
# 创建符合正态分布的4只股票5天的涨跌幅数据
stock_change = np.random.normal(0, 1, (4, 5))
stock_change
返回结果:
array([[ 0.0476585 , 0.32421568, 1.50062162, 0.48230497, -0.59998822],
[-1.92160851, 2.20430374, -0.56996263, -1.44236548, 0.0165062 ],
[-0.55710486, -0.18726488, -0.39972172, 0.08580347, -1.82842225],
[-1.22384505, -0.33199305, 0.23308845, -1.20473702, -0.31753223]])
numpy.random.rand(d0, d1, …, dn):生成一个[0,1)之间的随机浮点数或N维浮点数组 —— 均匀分布
返回[0.0,1.0)内的一组均匀分布的数。
import numpy as np
# numpy.random.rand(d0, d1, ..., dn):生成一个[0,1)之间的随机浮点数或N维浮点数组 —— 均匀分布
import matplotlib.pyplot as plt # 导入matplotlib模块,用于图表辅助分析
a = np.random.rand()
print('a = {0}, type(a) = {1}'.format(a, type(a))) # 生成一个随机浮点数
b = np.random.rand(4)
print('\nb = {0}, type(b) = {1}'.format(b, type(b))) # 生成形状为4的一维数组
c = np.random.rand(2, 3)
print('\nc = {0}, type(c) = {1}'.format(c, type(c))) # 生成形状为2*3的二维数组,注意这里不是((2,3))
samples1 = np.random.rand(1000)
samples2 = np.random.rand(1000)
# 生成1000个均匀分布的样本值
plt.scatter(samples1, samples2)
plt.show()
打印结果:
a = 0.3897322462249715, type(a) = <class 'float'>
b = [0.54630163 0.48370642 0.46426945 0.49665149], type(b) = <class 'numpy.ndarray'>
c = [[0.86019548 0.22935929 0.53218719]
[0.99057595 0.42980103 0.34768713]], type(c) = <class 'numpy.ndarray'>
Process finished with exit code 0
功能:从一个均匀分布[low,high)中随机采样,注意定义域是左闭右开,即包含low,不包含high.
从一个均匀分布中随机采样,生成一个整数或N维整数数组,
取数范围:若high不为None时,取[low,high)之间随机整数,否则取值[0,low)之间随机整数。
# 生成均匀分布的随机数
x2 = np.random.uniform(-1, 1, 100000000)
返回结果:
array([ 0.22411206, 0.31414671, 0.85655613, ..., -0.92972446, 0.95985223, 0.23197723])
画图看分布状况:
import matplotlib.pyplot as plt
# 生成均匀分布的随机数
x2 = np.random.uniform(-1, 1, 100000000)
# 画图看分布状况
# 1)创建画布
plt.figure(figsize=(10, 10), dpi=100)
# 2)绘制直方图
plt.hist(x=x2, bins=1000) # x代表要使用的数据,bins表示要划分区间数
# 3)显示图像
plt.show()
import numpy as np
# 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) = ', np.random.randint(2))
# low=2,size=5 :生成5个[0,2)之间随机整数
print('\nnp.random.randint(2, size=5) = ', np.random.randint(2, size=5))
# low=2,high=6,size=5:生成5个[2,6)之间随机整数
print('\nnp.random.randint(2, 6, size=5) = ', np.random.randint(2, 6, size=5))
# low=2,size=(2,3):生成一个2x3整数数组,取数范围:[0,2)随机整数
print('\nnp.random.randint(2, size=(2, 3)) = ', np.random.randint(2, size=(2, 3)))
# low=2,high=6,size=(2,3):生成一个2*3整数数组,取值范围:[2,6)随机整数
print('\nnp.random.randint(2, 6, (2, 3)) = ', np.random.randint(2, 6, (2, 3)))
打印结果:
np.random.randint(2) = 0
np.random.randint(2, size=5) = [1 1 1 1 1]
np.random.randint(2, 6, size=5) = [4 2 5 4 4]
np.random.randint(2, size=(2, 3)) = [[0 0 1]
[0 1 1]]
np.random.randint(2, 6, (2, 3)) = [[3 3 4]
[5 3 3]]
Process finished with exit code 0
eye():创建一个正方的N*N的单位矩阵,对角线值为1,其余为0
import numpy as np
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.]]
Process finished with exit code 0