一、Numpy基础：创建数组

h2 { font-size: 24px; height: 35px; line-height: 35px !important; width: 95%; background-color: #169FE6; padding-left: 10px; color: white }
table { border: 1px solid #d3d3d3; background: #fefefe; width: 90% }
th,td { padding: 0.5% 1% 0.5% }
th { background: #e8eaeb }
td { border-top: 1px solid #e0e0e0; border-right: 1px solid #e0e0e0 }
tr:nth-child(2n+1) { background: #f6f6f6 }
td.first,th.first { text-align: left }
td.last { border-right: none }
td { background: -webkit-gradient(linear, 0% 0%, 0% 25%, from(#f9f9f9), to(#fefefe)) }
tr:nth-child(2n+1) td { background: -webkit-gradient(linear, 0% 0%, 0% 25%, from(#f1f1f1), to(#f6f6f6)) }
th { background: -webkit-gradient(linear, 0% 0%, 0% 20%, from(#ededed), to(#e8eaeb)) }
tr:first-child th.first { }
tr:first-child th.last { }
tr:last-child td.first { }
tr:last-child td.last { }
.syntaxhighlighter { width: 95% !important }

Numpy是Python的一个科学计算的库，提供了矩阵运算的功能，其一般与Scipy、matplotlib一起使用。其实，list已经提供了类似于矩阵的表示形式，不过numpy为我们提供了更多的函数。如果接触过matlab、scilab，那么numpy很好入手。

一、模块引用

import numpy as np

二、数组的创建

这里先看一下多维度数组的格式，下例是一个三维数组，以楼房的方式理解最直观。

[#数组一层
    [1, 3, 4, 6],#一层1单元
    [2, 5, 6, 7]#一层2单元
],
[#数组二层
    [1, 3, 4, 6],#二层1单元
    [2, 5, 6, 7]#二层2单元
]

注意，数组元素必须放入[]或()之间

2.1普通创建

一维数组创建

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

多维数组创建

c=np.array([
    [
        [
            [1,2],[3,4]#3维层(内部元素为思维)
        ],#2维层
        [
            [5,6],[7,8]
        ]
    ],#1维层
    [
        [
            [9,10],[11,12]
        ],
        [
            [13,14],[15,16]#3维层(内部元素为思维)
        ]#2维层
    ]#1维层
])
print(c)
>>>
[[[[ 1  2]
   [ 3  4]]
  [[ 5  6]
   [ 7  8]]]
 [[[ 9 10]
   [11 12]]
  [[13 14]
   [15 16]]]]?

2.1.1内置方法创建(arange创建)

arange的使用方法与python内置方法range相同，这里不再赘述，看程序

import numpy as np
a=np.arange(20)
b=np.arange(10,20)
c=np.arange(10,20,2)
d=np.arange(20,10,-1)
print("普通玩法：",a)
print("带起始点的玩法：",b)
print("带步长的玩法：",c)
print("倒着玩：",d)
>>>
普通玩法： [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
带起始点的玩法： [10 11 12 13 14 15 16 17 18 19]
带步长的玩法： [10 12 14 16 18]
倒着玩： [20 19 18 17 16 15 14 13 12 11]

2.1.2内置方法创建(random创建)

与random模块不同，这个random是numpy内置的方法，用法上是相同的，同样看程序

import numpy as np
a=np.random.random((2,2))#0~1的随机数
b=np.random.randn(2,2)#符合正态分布的随机数
c=np.random.randint(2,10,(2,2))#从2~10的随机整数
print("0~1的随机数：",a)
print("正态分布的随机数：",b)
print("从2~10的随机整数：",c)
>>>0~1的随机数： [[0.93614432 0.56444734]
 [0.29267612 0.38625066]]
正态分布的随机数： [[-1.26606533  0.68466118]
 [ 0.34377799  0.1318619 ]]
从2~10的随机整数： [[4 8]
 [9 6]]

numpy.random下所有创建方式如下表所示：

2.1.3内置方法创建(等差等比创建)

np.linspace (起始值,终止值,元素总数)：创建一维等差数组。
np.logspace(起始值,终止值,元素总数)：创建一维等比数组。

import numpy as np
a=np.linspace(0,10,5)
b=np.logspace(0,2,5)
print("等差数组：",a)
print("等比数组：",b)>>>
等差数组： [ 0.   2.5  5.   7.5 10. ]
等比数组： [  1.           3.16227766  10.          31.6227766  100.        ]

2.1.4内置方法创建(特殊构造)

np.zeros(shape, dtype=float, order=‘C‘):创建一个全0数组，shape要以元组格式传入。
np.ones(shape, dtype=None, order=‘C‘)：创建一个全1数组，shape要以元组格式传入。
np.empty(shape, dtype=None, order=‘C‘)：创建一个拥有趋近0值的数组，shape要以元组格式传入。
np.eye(N, M=None, k=0, dtype=float, order=‘C‘)：创建一个对角矩阵，N代表行，M代表列。其中有个参数k默认值为0，它代表偏移量，正1时向主对角线右上偏移1位，负1时向主对角线左下偏移1位。
np.full(shape, fill_value, dtype=None, order=‘C‘)：创建一个以fill_value进行填充的数组，fill_value为想要填充的值

import numpy as np
a=np.zeros((2,2))
b=np.ones((2,2))
c=np.empty((2,2))
d=np.eye(2, 2, 0)
e=np.full((2,2), 17)
print("全0数组：",a)
print("全1数组：",b)
print("趋近0数组：",c)
print("对角矩阵：",d)
print("全17数组：",e)
>>>
全0数组： [[0. 0.]
 [0. 0.]]
全1数组： [[1. 1.]
 [1. 1.]]
趋近0数组： [[9.90263869e+067 8.01304531e+262]
 [2.60799828e-310 0.00000000e+000]]
对角矩阵： [[1. 0.]
 [0. 1.]]
全17数组： [[17 17]
 [17 17]]

原文地址：https://www.cnblogs.com/hezhefly/p/8278842.html