numpy ndarray数组的创建

ndarray 数组的创建

​ numpy中最重要的数据类型：数组–numpy （列表–python）
数组被称为是n_d array数组 多维数组，跟列表一样的是：都是能够存储多个元素的容器。Numpy提供了很多方式（函数）来创建数组对象，常用的方式如下：

array (重要)
arange (重要)
ones / ones_like (重要)
zeros / zeros_like
empty / empty_like
full / full_like (重要)
eye / identity
linspace (重要)
logspace

说明：
注意arange函数，不是arrange。
arange与linspace的区别。

1. array()

​ 第一个位置参数object:创建数组的类型,需要传入一个python下的列表或者迭代对象(元组) range(1,101)，习惯上使用python下的列表
通过array()将列表（迭代对象）转换成ndarray数组，ndarray数组，其实就是我们线性代数中的矩阵。

# 使用array()创建了一个一维的数组

a = np.array()

# 使用array（）创建一个二维的数组,将下面的二维列表，转换成二维数组

a = np.array([[1,2],[3,4]])

# result
[[1 2]
 [3 4]]

#使用array()创建一个三维度数组,只要传过来的list列表是三维，对应创建的数组自然就是三维的

a = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12] ]])

# result

[[[ 1  2  3]
  [ 4  5  6]]

 [[ 7  8  9]
  [10 11 12]]]

​ 上面的三维的数组理解成，最高维度（最外层的[]）中包含2个元素，这两个元素中，每个元素又包含两个元素，内部的两个元素又是列表，列表中包含了3个元素。
最高维度—最外层
次高维-----中间
最低维-----最内层
array，是直接创建，自己往里面写值，属于自定义添加每个元素。

2. arange()

​ 会被经常误写成arrange，range指的就是python中的range(start,end,step)函数，将range产生的内容转换成数组 。
np.arange(start,end,step) start ，到end结束，不包含end，step步长，默认值1
arange中的range要比python中的range函数多一个功能，step可以是小数
np中的小数1.0显示成1.

a=np.arange(1,10)
a=np.arange(1,10,2)
a=np.arange(1,10,0.5)

arange:里面需要传入三个参数，但是是个一维的，前两个元素是范围，最后一个参数是步长。 创建的是一维数组。

3. ones()和oneslike()

ones

创建一个值全都是1的数组
shape：数组的shape叫做数组的形状：一个数组，从高维，到低维，每个维度中元素的个数。
(高维元素的个数,次高维元素的个数,…最低维元素的个数)

a1 = np.ones(shape = (10,))  # 十个内容是包含1的数组
a1 = np.ones(shape = (5,3))
a1 = np.ones(shape = (2,2,3))

ones_like

传入的是数组
ones_like(数组)：创建一个值全部是1，形状和参数数组一样形状的数组

b = np.array([[1,2],[3,4]])
b1=np.ones_like(b)

ones()里面的参数是shape,里面可以传入shape形状，
oneslike()里面传的是已经有的数组，可以仿照他的形状建立一个为1的数组。

4. zeros() 和 zeros_like()

zeros()能够创建值全部都是0的数组，参数需要shape

a = np.zeros(shape = (5,))

a = np.zeros(shape=(2,3))

a = np.zeros_like(b)

与ones一样，但是填充的是0

5. empty() 和 empty_like()

用法和ones()和zeros()类似，都是empty填充，不是空值，使用原来内存中存储的值来进行填充。

a = np.empty(shape = (3,4,5))

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

a = np.empty(np.array([1,2]))
# [[4.24399158e-314 8.48798317e-314]]

6. eye() 和 identity()

能够创建的数组是一个方阵 。
n代表的是n行和n列的方阵。方阵填充值：对角线上都是1，其余都是0

a = np.eye(5)
a = np.identity(5)

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

7. linspace()

创建等差数列的数组,关注点在于num，一维数组

# param: start 起始位置
# param: end 结束位置
# param: num 等差数列需要的元素,默认值是50
# endpoint = True 默认包含end，可以通过设置为False来不包含 end

np.linspace(start,end,num,endpoint)

a = np.linspace(1,50)
# result 默认50个元素
[ 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.]

a = np.linspace(1,50,num = 10)

# result  10个元素
[ 1.          6.44444444 11.88888889 17.33333333 22.77777778 28.22222222
 33.66666667 39.11111111 44.55555556 50.        ]

num是等差数列的个数，只关心个数，而不关心等差数列的差

8. logspace()

创建等比数列，创建对数（指数）等差数列， 一维数组
比如底数是10 10^1 10^2 10^3…等比数列
默认的底数base = 10

# start 和 end 起始位置和终止位置, 他们代表是指数，指数的最小值和最大值
a = np.logspace(1,10,10)

num 是等比数列的个数，只关心个数，而不关心等比数列的比值

9. full() 和 full_like()

full填充，可定填充的值。比之前的ones 或者zeros或者empty多了一个参数，是设置的填充值。

第一个参数，指定要创建什么形状的数组
第二个参数，指定数组的每一个值是什么
np.full(shape,full_value)
a=np.full((3,4,5),100)
a=np.full_like(np.array([[1,2],[3,4]]),500)

linspace()和arange()区别

【共同点】

都是用来产生数组的，都有起始位置，和终止位置。都是一维数组

【不同点】

arange(start,end,step)  # 包含start，不包含end，关注的是步长，不在意产生的数组元素的个数。
linspace(start,end,num) # 包含start，默认包含end，关注的是元素的个数，但是不关注步长（等差的值）。

【应用场合】

当我们明确知道start和end的时候，产生数组，会选择以上两种方法；
再进行进一步选择的时候，如果明确知道产生的元素的个数，那么适合使用linspace，num=个数；
如果明确知道每两个元素之间的间隔，则适合使用arange，step=间隔 。