Numpy的基本用法整理

本篇内容主要讲解“Numpy的基本用法整理”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Numpy的基本用法整理”吧!

创新互联2013年开创至今，先为镇海等服务建站，镇海等地企业，进行企业商务咨询服务。为镇海企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

前言

Numpy是一个开源的Python科学计算库，它是python科学计算库的基础库，许多其他著名的科学计算库如Pandas，Scikit-learn等都要用到Numpy库的一些功能。

本文主要内容如下：

1. Numpy数组对象

2. 创建ndarray数组

3. Numpy的数值类型

4. ndarray数组的属性

5. ndarray数组的切片和索引

6. 处理数组形状

7. 数组的类型转换

8. numpy常用统计函数

9. 数组的广播

1 Numpy数组对象

Numpy中的多维数组称为ndarray，这是Numpy中最常见的数组对象。ndarray对象通常包含两个部分：

• ndarray数据本身

• 描述数据的元数据

Numpy数组的优势

• Numpy数组通常是由相同种类的元素组成的，即数组中的数据项的类型一致。这样有一个好处，由于知道数组元素的类型相同，所以能快速确定存储数据所需空间的大小。

• Numpy数组能够运用向量化运算来处理整个数组，速度较快；而Python的列表则通常需要借助循环语句遍历列表，运行效率相对来说要差。

• Numpy使用了优化过的C API，运算速度较快

关于向量化和标量化运算，对比下面的参考例子就可以看出差异

• 使用python的list进行循环遍历运算

1.        def pySum():

2.            a = list(range(10000))

3.            b = list(range(10000))

4.            c = []

5.            for iin range(len(a)):

6.                c.append(a[i]**2 + b[i]**2)

7.         

8.            return c

1.        %timeit pySum()

1.        10 loops, best of3:49.4 ms per loop

• 使用numpy进行向量化运算

1.        import numpyas np

2.        def npSum():

3.            a = np.arange(10000)

4.            b = np.arange(10000)

5.            c = a**2 + b**2

6.            return c

1.        %timeit npSum()

1.        The slowest run took262.56 times longer than the fastest.This could mean that an intermediate resultis being cached.

2.        1000 loops, best of3:128 ?s per loop

从上面的运行结果可以看出，numpy的向量化运算的效率要远远高于python的循环遍历运算（效率相差好几百倍）。 （1ms=1000?s）

2创建ndarray数组

首先需要导入numpy库，在导入numpy库时通常使用“np”作为简写，这也是Numpy官方倡导的写法。

当然，你也可以选择其他简写的方式或者直接写numpy，但还是建议用“np”，这样你的程序能和大都数人的程序保持一致。

1.        import numpyas np

创建ndarray数组的方式有很多种，这里介绍我使用的较多的几种：

Method 1:基于list或tuple

1.        #一维数组

2.         

3.        #基于list

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

5.        print(arr1)

6.         

7.        #基于tuple

8.        arr_tuple = np.array((1,2,3,4))

9.        print(arr_tuple)

10.      

11.     #二维数组 (2*3)

12.     arr2 = np.array([[1,2,4], [3,4,5]])

13.     arr2

1.        [1234]

2.        [1234]

3.        array([[1,2,4],

4.               [3,4,5]])

请注意：

• 一维数组用print输出的时候为 [1 2 3 4]，跟python的列表是有些差异的，没有“,”

• 在创建二维数组时，在每个子list外面还有一个"[]"，形式为“[[list1], [list2]]”

Method 2:基于np.arange

1.        #一维数组

2.        arr1 = np.arange(5)

3.        print(arr1)

4.         

5.        #二维数组

6.        arr2 = np.array([np.arange(3), np.arange(3)])

7.        arr2

1.        [01234]

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

3.               [0,1,2]])

Method 3:基于arange以及reshape创建多维数组

1.        #创建三维数组

2.        arr = np.arange(24).reshape(2,3,4)

3.        arr

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

2.                [4,  5,  6,  7],

3.                [8,  9,10,11]],

4.         

5.               [[12,13,14,15],

6.                [16,17,18,19],

7.                [20,21,22,23]]])

• 请注意：arange的长度与ndarray的维度的乘积要相等，即 24 = 2X3X4

• 用numpy.random创建数组的方法，可以参考下面的文章

为什么你用不好Numpy的random函数？

• 其他创建ndarray的方法，各位小伙伴们自己可以研究下。

3 Numpy的数值类型

Numpy的数值类型如下：

每一种数据类型都有相应的数据转换函数，参考示例如下：

1.        np.int8(12.334)

1.        12

1.        np.float64(12)

1.        12.0

1.        np.float(True)

1.        1.0

1.        bool(1)

1.        True

在创建ndarray数组时，可以指定数值类型：

1.        a = np.arange(5, dtype=float)

2.        a

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

• 请注意，复数不能转换成为整数类型或者浮点数，比如下面的代码会运行出错

1.        # float(42 + 1j)

4 ndarray数组的属性

• dtype属性，ndarray数组的数据类型，数据类型的种类，前面已描述。

1.        np.arange(4, dtype=float)

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

1.        # 'D'表示复数类型

2.        np.arange(4, dtype='D')

1.        array([0.+0.j,  1.+0.j,  2.+0.j,  3.+0.j])

1.        np.array([1.22,3.45,6.779], dtype='int8')

1.        array([1,3,6], dtype=int8)

• ndim属性，数组维度的数量

1.        a = np.array([[1,2,3], [7,8,9]])

2.        a.ndim

1.        2

• shape属性，数组对象的尺度，对于矩阵，即n行m列,shape是一个元组（tuple）

1.        a.shape

1.        (2,3)

• size属性用来保存元素的数量，相当于shape中nXm的值

1.        a.size

1.        6

• itemsize属性返回数组中各个元素所占用的字节数大小。

1.        a.itemsize

1.        4

• nbytes属性，如果想知道整个数组所需的字节数量，可以使用nbytes属性。其值等于数组的size属性值乘以itemsize属性值。

1.        a.nbytes

1.        24

1.        a.size*a.itemsize

1.        24

• T属性，数组转置

1.        b = np.arange(24).reshape(4,6)

2.        b

1.        array([[0,  1,  2,  3,  4,  5],

2.               [6,  7,  8,  9,10,11],

3.               [12,13,14,15,16,17],

4.               [18,19,20,21,22,23]])

1.        b.T

1.        array([[0,  6,12,18],

2.               [1,  7,13,19],

3.               [2,  8,14,20],

4.               [3,  9,15,21],

5.               [4,10,16,22],

6.               [5,11,17,23]])

• 复数的实部和虚部属性，real和imag属性

1.        d = np.array([1.2+2j,2+3j])

2.        d

1.        array([1.2+2.j,  2.0+3.j])

real属性返回数组的实部

1.        d.real

1.        array([1.2,  2. ])

imag属性返回数组的虚部

1.        d.imag

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

• flat属性，返回一个numpy.flatiter对象，即可迭代的对象。

1.        e = np.arange(6).reshape(2,3)

2.        e

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

2.               [3,4,5]])

1.        f = e.flat

2.        f

1.        

1.        for itemin f:

2.            print(item)

1.        0

2.        1

3.        2

4.        3

5.        4

6.        5

可通过位置进行索引，如下：

1.        f[2]

1.        2

1.        f[[1,4]]

1.        array([1,4])

也可以进行赋值

1.        e.flat=7

2.        e

1.        array([[7,7,7],

2.               [7,7,7]])