Numpy基础3：创建对象

Numpy

基础3：创建对象

ndarray对象

	ndarray 类具有六个参数，它们分别是：
    shape # 数组的形状。
    dtype # 数据类型。
    buffer # 对象暴露缓冲区接口。
    offset # 数组数据的偏移量。
    strides # 数据步长。
    order # {'C'，'F'}，以行或列为主排列顺序。  

创建方法

python基础类型转换

在 numpy 中，我们使用 numpy.array 将python基础类型转换为 ndarray 数组。其方法为：

numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0) 

	object：列表、元组等。
	dtype：数据类型。如果未给出，则类型为被保存对象所需的最小类型。
	copy：布尔来写，默认 True，表示复制对象。

list强制转换为ndarray类型

li = [1,2,3,4,5]
np.array(li),np.array(li)[-1]

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

array强制转换为ndarray类型

tup = 1,2,3,4,5
np.array(tup),np.array(tup)[-1]

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

set 强制转换为ndarray类型

set = {1,2,3,4,5,4,3,2,1}
np.array(set)

array({1, 2, 3, 4, 5}, dtype=object)

dict的key是set类型

di = dict(a=1,b=2,c=3)
np.array(di)

array({‘a’: 1, ‘b’: 2, ‘c’: 3}, dtype=object)

arange 方法创建

除了直接使用 array 方法创建 ndarray，在 numpy 中还有一些方法可以创建一些有规律性的多维数。首先，我们来看一看 arange()。arange() 的功能是在给定区间内创建一系列均匀间隔的值。方法如下：

numpy.arange(start, stop, step, dtype=None)  

你需要先设置值所在的区间，这里为 [开始， 停止），你应该能发现这是一个半开半闭区间。然后，在设置step步长用于设置值之间的间隔。最后的可选参数dtype可以设置返回ndarray` 的值类型。

np.arange(1,100,2)

array([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33,
35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67,
69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99])

linspace 方法创建

linspace方法也可以像arange方法很像，创建数值有规律的数组。inspace用于在指定的区间内返回间隔均匀的值。其方法如下：

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

	start：序列的起始值。
	stop：序列的结束值。
	num：生成的样本数。默认值为50。
	endpoint：布尔值，如果为真，则最后一个样本包含在序列内。
	retstep：布尔值，如果为真，返回间距。
	dtype：数组的类型。

np.linspace(-10,10,10)

array([-10. , -7.77777778, -5.55555556, -3.33333333,-1.11111111, 1.11111111, 3.33333333, 5.55555556,7.77777778, 10. ])

logspace 方法创建

logspace是线性生成，并且以什么为底

	start从几开始
	stop 到数字结尾
	num  生成多少个数
	base 表示的是底数 默认以10为底

np.logspace(1,10,10)

array([1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07, 1.e+08,
1.e+09, 1.e+10])

np.logspace(1,2,10)

array([ 10. , 12.91549665, 16.68100537, 21.5443469 ,27.82559402, 35.93813664, 46.41588834, 59.94842503,77.42636827, 100. ])

ones 方法创建

numpy.ones 用于快速创建数值全部为 1 的多维数组。其方法如下：

numpy.ones(shape, dtype=None, order='C')

	shape：用于指定数组形状，例如（1， 2）或 3。
	dtype：数据类型。
	order：{'C'，'F'}，按行或列方式储存数组。

np.ones(shape=(5,4),dtype='int8')

array([[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]], dtype=int8)

o.dtype

dtype(‘int8’)

zeros 方法创建

zeros 方法和上面的 ones 方法非常相似，不同的地方在于，这里全部填充为 0。zeros 方法和 ones 是一致的。

numpy.zeros(shape, dtype=None, order='C')

	shape：用于指定数组形状，例如（1， 2）或3。
	dtype：数据类型。
	order：{'C'，'F'}，按行或列方式储存数组。

np.zeros(shape=(3,3),dtype='int8')

array([[0, 0, 0],
[0, 0, 0],
[0, 0, 0]], dtype=int8)

full方法创建

numpy.full用于创建一个自定义形状的数组，可以自己指定一个值，该值填满整个矩阵。

numpy.full(shape,fill_value=num)

np.full(shape=(3,3), fill_value=10)

array([[10, 10, 10],
[10, 10, 10],
[10, 10, 10]])

eye 方法创建

numpy.eye 用于创建一个二维数组，其特点是k 对角线上的值为 1，其余值全部为0。方法如下：

numpy.eye(N, M=None, k=0, dtype=<type 'float'>)  

	N：输出数组的行数。
	M：输出数组的列数。
	k：对角线索引：0（默认）是指主对角线，正值是指上对角线，负值是指下对角线。表示从下标第几个开始。

np.eye(3)

array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])

np.eye(4,M=3,k=1)

array([[0., 1., 0.],
[0., 0., 1.],
[0., 0., 0.],
[0., 0., 0.]])

np.eye(3,M=4,k=-2)

array([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[1., 0., 0., 0.]])

diag 方法创建

对角矩阵，主对角线上有值

np.diag([1,2,3])

array([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])

整数型随机矩阵

生成随机的整数型矩阵

  np.random.randint(low=0,high=150,size=(5,4))

	low 表示的是最小值
	high 表示最大值
	size 是一个元组类型或整型

np.random.randint(1000,10000,size=(5,4))

array([[4978, 9324, 6563, 9781],
[7715, 1498, 2272, 1576],
[5791, 8365, 4297, 3114],
[3476, 7938, 6702, 2477],
[6193, 3482, 9470, 4883]])

生成随机的矩阵

np.random.randn(10,5)没有固定的参数，每多加一个数字，代表多真假一个维度
rand 和 random 的区别：random 需要 size来描述形状，而rand只需要我们直接给值,通过值的数量来确定形状

np.random.random(size=(456,730,3))

	size 表示形状 random随即生产的范围是0-1之间

np.random.random(size=(2,3,4))

array([[[0.44087042, 0.56201533, 0.29860639, 0.74863463],
[0.89053983, 0.90372709, 0.1974021 , 0.28676568],
[0.87047092, 0.5941074 , 0.55817556, 0.1172316 ]],
[[0.92110405, 0.11879152, 0.61405184, 0.17196971],
[0.97346584, 0.74209702, 0.3385801 , 0.49291098],
[0.03932628, 0.13211999, 0.20205492, 0.35373043]]])

np.random.rand(4,3,2)

array([[[8.70178786e-03, 4.77632471e-01],
[5.02853513e-01, 3.47265529e-01],
[8.62488951e-01, 7.05401236e-01]],

[[6.21816785e-01, 1.50235737e-01],
[8.84794680e-01, 3.02021777e-01],
[2.39958830e-01, 7.37170772e-01]],

[[5.35055675e-01, 7.08142187e-01],
[7.60646075e-02, 1.84738441e-01],
[9.05785332e-01, 3.03236650e-01]],

[[5.76716168e-04, 8.78046274e-01],
[4.67437551e-02, 8.89701572e-01],
[4.70559819e-01, 9.69439179e-02]]])

生成高斯分布矩阵

生成一个一维数组

np.random.normal(loc=170,scale=100,size=50)

	location 是定位的的值
	scale 是波动值
	size 是数据长度

normal=np.random.normal(loc=12500,scale=2500,size=10)
normal

array([13816.11988865, 10547.71512672, 13862.79314516, 13648.95445771,
12646.57164565, 9813.74235725, 10838.48063407, 11689.67990981,
13027.97184294, 18526.68967625])