python 构建数组的方法

最新推荐文章于 2025-03-18 14:19:29 发布

cuisidong1997

最新推荐文章于 2025-03-18 14:19:29 发布

阅读量1.5k

点赞数

文章标签： python numpy 开发语言

本文链接：https://blog.youkuaiyun.com/cuisidong1997/article/details/134427494

版权

生成0和1的数组

np.ones()
np.ones_like()
从现有数组中生成
np.array – 深拷贝
np.asarray – 浅拷贝
生成固定范围数组

np.linspace()
nun – 生成等间隔的多少个
np.arange()
step – 每间隔多少生成数据
np.logspace()
生成以10的N次幂的数据
生成随机数组

正态分布
里面需要关注的参数:均值:u, 标准差:σ
u – 决定了这个图形的左右位置
σ – 决定了这个图形是瘦高还是矮胖
np.random.randn()
np.random.normal(0, 1, 100)
均匀
np.random.rand()
np.random.uniform(0, 1, 100)
np.random.randint(0, 10, 10)
一、生成固定范围的数组
1、arange：等差数组
创建数组：arange()，类似range()，在给定间隔内返回均匀间隔的值。

创建等差数组 — 指定步长

np.arange(10, 50, 2)
1
返回结果：

array([10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42,
44, 46, 48])
1
2
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会自动跳过数组的中心部分，并只打印边角：
1
2
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.]
[ 5 6 7 8 9 10 11]
[ 5. 7. 9. 11.]
[ 0 1 2 … 9997 9998 9999]

Process finished with exit code 0
1
2
3
4
5
6
7
2、linspace：等差数组
linspace():返回在间隔[开始，停止]上计算的num个均匀间隔的样本。

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

start：起始值，stop：结束值
num：生成样本数，默认为50
endpoint：如果为真，则停止是最后一个样本。否则，不包括在内。默认值为True。
retstep：如果为真，返回（样本，步长），其中步长是样本之间的间距 → 输出为一个包含2个元素的元祖，第一个元素为array，第二个为步长实际值

生成等间隔的数组

np.linspace(0, 100, 11)
1
2
返回结果：

array([ 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100.])
1
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))
1
2
3
4
5
6
7
8
9
10
打印结果：

[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
1
2
3
4
5
3、logspace：等比数列
np.logspace(start,stop, num)

创建等比数列

参数:

num:要生成的等比数列数量，默认为50

生成10^x

np.logspace(0, 2, 3)
1
2
返回结果:

array([ 1., 10., 100.])
1
三、生成0和1的数组
生成0和1的数组

np.ones(shape, dtype)
np.ones_like(a, dtype)
np.zeros(shape, dtype)
np.zeros_like(a, dtype)
1、ones()
ones = np.ones([4,8])
print(ones)
1
2
返回结果:

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.]])
1
2
3
4
2、ones_like()
3、numpy.zeros()
numpy.zeros(shape, dtype=float, order=‘C’):返回给定形状和类型的新数组，用零填充。

shape：数组纬度，二维以上需要用()，且输入参数为整数
dtype：数据类型，默认numpy.float64
order：是否在存储器中以C或Fortran连续（按行或列方式）存储多维数据。
4、zeros_like()
返回具有与给定数组相同的形状和类型的零数组，这里ar4根据ar3的形状和dtype创建一个全0的数组

np.zeros_like(ones)
1
返回结果:

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.]])
1
2
3
4
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)

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
打印结果：

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
四、从现有数组生成
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)
1
2
3
4
5
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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
打印结果：

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
1
2
3
4
5
6
7
8
9
“”"
创建多维数组(二维数组):

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)))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
打印结果：

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
1
2
3
4
5
6
7
8
9
10
关于array和asarray的不同

五、生成随机数组：np.random 模块
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
1、正态分布概念
什么是正态分布：正态分布是一种概率分布。正态分布是具有两个参数μ和σ的连续型随机变量的分布，第一参数μ是服从正态分布的随机变量的均值，第二个参数σ是此随机变量的标准差，所以正态分布记作N(μ，σ )。

正态分布的应用：生活、生产与科学实验中很多随机变量的概率分布都可以近似地用正态分布来描述。

正态分布特点：μ决定了其位置，其标准差σ：决定了分布的幅度。当μ = 0,σ = 1时的正态分布是标准正态分布。

方差：是在概率论和统计方差衡量一组数据时离散程度的度量

其中M为平均值，n为数据总个数，σ 为标准差，σ ^2可以理解一个整体为方差

标准差与方差的意义：可以理解成数据的一个离散程度的衡量

2、正态分布创建方式
2.1 np.random.randn(d0, d1, …, dn)
numpy.random.randn(d0, d1, …, dn)：生成一个浮点数或N维浮点数组 —— 正态分布

功能：从标准正态分布中返回一个或多个样本值
其中：d0，d1，dn表示需要在哪些维度生成数据
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()
1
2
3
4
5
6
7
8
9
10
11
12
13

2.2 np.random.normal(loc=0.0, scale=1.0, size=None)
loc：float

此概率分布的均值（对应着整个分布的中心centre）
scale：float

此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）
size：int or tuple of ints

输出的shape，默认为None，只输出一个值
import numpy as np

随机数生成

生成一个标准正太分布的4*4样本值

samples = np.random.normal(size=(4, 4))
print('samples = ', samples)
1
2
3
4
5
6
7
打印结果：

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
2
3
4
5
举例1：生成均值为1.75，标准差为1的正态分布数据，100000000个：

x1 = np.random.normal(1.75, 1, 100000000)
1
返回结果：

array([2.90646763, 1.46737886, 2.21799024, …, 1.56047411, 1.87969135, 0.9028096 ])
1
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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

举例2：随机生成4支股票1周的交易日涨幅数据（模拟生成一组股票的涨跌幅的数据）：

4支股票，一周(5天)的涨跌幅数据，如何获取？：随机生成涨跌幅在某个正态分布内，比如均值0，方差1

股票涨跌幅数据的创建

创建符合正态分布的4只股票5天的涨跌幅数据

stock_change = np.random.normal(0, 1, (4, 5))
stock_change
1
2
3
4
返回结果：

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]])
1
2
3
4
2.3 np.random.standard_normal(size=None)
返回指定形状的标准正态分布的数组。
3、均匀分布
3.1 np.random.rand(d0, d1, …, dn)
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的一维数组

samples1 = np.random.rand(1000)
samples2 = np.random.rand(1000)

生成1000个均匀分布的样本值

plt.scatter(samples1, samples2)
plt.show()

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

打印结果：

a = 0.3897322462249715, type(a) = <class ‘float’>

b = [0.54630163 0.48370642 0.46426945 0.49665149], type(b) = <class ‘numpy.ndarray’>

Process finished with exit code 0
1
2
3
4
5
6
7
8
3.2 np.random.uniform(low=0.0, high=1.0, size=None)
功能：从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high.

low: 采样下界，float类型，默认值为0；
high: 采样上界，float类型，默认值为1；
size: 输出样本数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出mnk个样本，缺省时输出1个值。
返回值：ndarray类型，其形状和参数size中描述一致。
3.3 np.random.randint(low, high=None, size=None, dtype=‘l’)
从一个均匀分布中随机采样，生成一个整数或N维整数数组，
取数范围：若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数。