Numpy库使用总结

Numpy库使用总结

一、总结

一句话总结：

NumPy：大数据量的纯粹数组处理，以及复杂函数和线性代数等

1、numpy中创建矩阵的方法？

numpy中的数据结构主要是同构的多维数组，所以创建数组的方法主要有array和arange方法，当然还有其它的一些比如linspace等等
arr = np.array([[1,2,3],[4,5,6]])
arr = np.arange(6).reshape((2,3))

2、numpy库中创建数组方法array和asarray的区别？

array和asarray都可以将结构数据转化为ndarray，但是主要区别就是当数据源是ndarray时，【array仍然会copy出一个副本，占用新的内存，但asarray不会】

3、numpy中的特殊矩阵？

numpy中的特殊矩阵 主要有ones（全1）、zeros（全0）、eye（单位矩阵）、empty（未初始化）
np.ones((3,4))
np.zeros((3,4))
np.eye(2)
np.empty((6,4))

4、numpy中的常用属性？

numpy的多维数组常用属性主要有dtype（数据类型）、ndim（维度）、shape（性状）、size（元素个数）
arr = np.arange(12).reshape((3,4))
print(arr)
# 数据类型
print(arr.dtype)
# 维数
print(arr.ndim)
# 行数和列数
print(arr.shape)
# 大小，也就是元素个数
print(arr.size)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
int32
2
(3, 4)
12


 

5、numpy中的基本计算？

numpy中的ndarray对象重载了许多运算符，使用这些运算符可以完成矩阵间对应元素的运算。如 +，-，*（内积），/，%，**（次方），@（矩阵阶层）
# 矩阵内积：对应位置相乘
print(arr1*arr2)
# 矩阵乘法：
print(arr1@arr2)
print(np.dot(arr1,arr2))
print(arr1.dot(arr2))

6、numpy中的常用函数？

numpy常用多维函数有sin、sqrt、sort、transpose、max、
mean（average）、sum、median（中位数）、var（方差）、std（标准差）、cumsum（累加）、
np.clip(arr,5,9)（小于5的数全部让它变成5，大于9的数全部是9）

7、numpy中axis为0为1表示的意思是什么？

axis为0表示对列进行操作，axis为1表示为行进行操作
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

# 平均数
print(arr.mean())
print(np.average(arr))
print(np.average(arr,axis=0)) # 0是列
print(np.average(arr,axis=1)) # 1是行

5.75
5.75
[4. 5. 7. 7.]
[1.5  6.25 9.5 ]

8、numpy中索引？

numpy中，可以像普通数组一样用下标来访问元素，比如a[1][1]、a[1,1]

9、numpy中访问行列元素？

a[1,:]（打印下标为1的行所有数）
a[:,1]（打印下标为1的列的所有数）
a[1,1:3]（第1行 列从1-2）

10、numpy中迭代行循环打印即可，如何迭代列？

将矩阵转置即可
# 迭代列 (转置一下即可实现)
for i in a.T:
    print(i)

11、numpy中如何迭代多维数组的每一个数？

for i in a.flat: print(i)

12、numpy中数组合并？

numpy数组水平合并可以np.hstack((a,b))，类似于np.concatenate((a,b,a),axis=1)
numpy数组垂直合并可以np.vstack((a,b))，类似于np.concatenate((a,b,a),axis=0)

13、numpy中数组分割？

等量分割：水平分成两块np.split(a,2,axis=1)，vsplit和hsplit也可以等量分割
不等量分割：np.array_split(a,3,axis=1)

14、numpy中数组拷贝？

numpy 中的 copy方法是 deep copy：b = np.copy(a)

二、Numpy库使用总结

博客对应课程的视频位置：

一、numpy库概述

numpy库是做什么的

大数据量的纯粹数组处理，以及复杂函数和线性代数等

NumPy的主要对象是同构多维数组。它是一个元素表（通常是数字），所有类型都相同，由非负整数元组索引。

numpy库核心

numpy的结构是纯粹的ndarray

numpy库和pandas库的关系

NumPy：大数据量的纯粹数组处理，以及复杂函数和线性代数等 Pandas：处理非纯粹的、混杂数组

虽然NumPy有着以上的种种出色的特性，其本身则难以独支数据分析这座大厦，这是一方面是由于NumPy几乎仅专注于数组处理， 另一方面则是数据分析牵涉到的数据特性众多，需要处理各种表格和混杂数据，远非纯粹的数组（NumPy）方便解决的，而这就是pandas发力的地方。

NumPy在大数组的数据处理方面进行的优化？

  • 【连续的内存块】：NumPy是在一个连续的内存块中存储数据，独立于其他Python内置对象，如此便可以加速数据索引的速度。
  • 【调用大量c语言算法库】：NumPy调用了大量的用C语言编写的算法库，使得其可以直接操作内存，不必进行Python动态语言特性所含有的前期类型检查工作，从而大大提高了运算速度。
  • 【整数组直接计算】：NumPy所有独有的可以在整个数组上执行复杂的计算也能够大幅提高运算效率（基于NumPy的算法要比纯Python快10到100倍，甚至会快更多）。

上百G的数据如何处理

Python处理几个G的数据绰绰有余，至于几十G也勉强可以，而上百G的数据这就算是Hadoop与Spark系列的任务，不是Python的NumPy与pandas可以应付的，也不是R语言某个第三方包可以处理的。

NumPy数组 和 原生Python Array（数组）之间有几个重要的区别

  • NumPy 数组在创建时具有固定的大小，与Python的原生数组对象（可以动态增长）不同。更改ndarray的大小将创建一个新数组并删除原来的数组。
  • NumPy 数组中的元素都需要具有相同的数据类型，因此在内存中的大小相同。 例外情况：Python的原生数组里包含了NumPy的对象的时候，这种情况下就允许不同大小元素的数组。
  • NumPy 数组有助于对大量数据进行高级数学和其他类型的操作。通常，这些操作的执行效率更高，比使用Python原生数组的代码更少。
  • 越来越多的基于Python的科学和数学软件包使用NumPy数组; 虽然这些工具通常都支持Python的原生数组作为参数，但它们在处理之前会还是会将输入的数组转换为NumPy的数组，而且也通常输出为NumPy数组。

对应博客资料

如何通过一顿饭来说明NumPy与pandas的功用 - 范仁义 - 博客园 https://www.cnblogs.com/Renyi-Fan/p/13232318.html

二、创建矩阵

numpy库中创建数组方法array和asarray的区别

array和asarray都可以将结构数据转化为ndarray，但是主要区别就是当数据源是ndarray时，

【array仍然会copy出一个副本，占用新的内存，但asarray不会】

意思是对数据源进行重新赋值的话，array转化后的数据不变，asarray转化后的数据也会跟着数据源重新被赋值。

创建矩阵的方法

numpy中的数据结构主要是同构的多维数组，所以创建数组的方法主要有array和arange方法，当然还有其它的一些比如linspace等等

arr = np.array([[1,2,3],[4,5,6]])
arr = np.arange(6).reshape((2,3))
In [42]:
# 安装库
# pip install numpy
# 查看安装的库
# pip list

# 引入库
import numpy as np

1、array方法

In [4]:
# numpy的核心是n维数组，所以创建数组是array方法
arr = np.array([[1,2,3],
                [4,5,6]])
print(arr)

[[1 2 3]
 [4 5 6]]
In [7]:
# 指定类型
arr = np.array([1,2,3],dtype=np.int64)
print(arr)
print(arr.dtype)

[1 2 3]
int64
In [17]:
# 同构还是异构
# 原生python中
list1 = [1,True,"a",[1,23]]
print(list1)
# numpy中
arr = np.array([1,True,'a'])
print(arr)
print(arr.dtype)
# 可以看到结果里面全部转化成了字符串，也就是全部转化为了同一类型

[1, True, 'a', [1, 23]]
['1' 'True' 'a']
<U11

2、arange方法

为了创建数字组成的数组，NumPy提供了一个类似于range的函数arange，该函数返回数组而不是列表。

In [13]:
arr = np.arange(10)
print(arr)
# 指定起点和终点
arr = np.arange(10,20)
print(arr)
# 指定步长
arr = np.arange(10,20,3)
print(arr)

[0 1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18 19]
[10 13 16 19]
In [15]:
# reshape方法改变维数
arr = np.arange(6).reshape((2,3))
print(arr)

[[0 1 2]
 [3 4 5]]
In [18]:
# 等差数列
arr = np.linspace(1,3,5)
print(arr)
print(arr.dtype)

[1.  1.5 2.  2.5 3. ]
float64
In [21]:
# 等比数列
arr = np.logspace(1,3,5)
print(arr)
print(arr.dtype)

[  10.           31.6227766   100.          316.22776602 1000.        ]
float64

三、特殊矩阵

numpy中的特殊矩阵

numpy中的特殊矩阵 主要有ones（全1）、zeros（全0）、eye（单位矩阵）、empty（未初始化）

np.ones((3,4))
np.zeros((3,4))
np.eye(2)
np.empty((6,4))
In [23]:
# 参数是一个元组，来指定行列
arr = np.ones((3,4))
print(arr)

[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
In [25]:
arr = np.zeros((3,4))
print(arr)

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
In [35]:
help(np.eye)

Help on function eye in module numpy:

eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
    Return a 2-D array with ones on the diagonal and zeros elsewhere.
    
    Parameters
    ----------
    N : int
      Number of rows in the output.
    M : int, optional
      Number of columns in the output. If None, defaults to `N`.
    k : int, optional
      Index of the diagonal: 0 (the default) refers to the main diagonal,
      a positive value refers to an upper diagonal, and a negative value
      to a lower diagonal.
    dtype : data-type, optional
      Data-type of the returned array.
    order : {'C', 'F'}, optional
        Whether the output should be stored in row-major (C-style) or
        column-major (Fortran-style) order in memory.
    
        .. versionadded:: 1.14.0
    
    Returns
    -------
    I : ndarray of shape (N,M)
      An array where all elements are equal to zero, except for the `k`-th
      diagonal, whose values are equal to one.
    
    See Also
    --------
    identity : (almost) equivalent function
    diag : diagonal 2-D array from a 1-D array specified by the user.
    
    Examples
    --------
    >>> np.eye(2, dtype=int)
    array([[1, 0],
           [0, 1]])
    >>> np.eye(3, k=1)
    array([[0.,  1.,  0.],
           [0.,  0.,  1.],
           [0.,  0.,  0.]])
In [49]:
# 对角矩阵的行列肯定是一样的
arr = np.eye(2)
print(arr)

[[1. 0.]
 [0. 1.]]
In [50]:
# empty为空，表示没有初始化的意思
arr1 = np.empty((6,4))
print(arr1)

[[4.624e-321 4.624e-321 4.190e-321 4.190e-321]
 [2.628e-321 2.628e-321 3.992e-321 3.992e-321]
 [4.585e-321 4.585e-321 4.427e-321 4.427e-321]
 [5.613e-321 5.613e-321 5.652e-321 5.652e-321]
 [5.454e-321 5.454e-321 2.174e-321 2.174e-321]
 [5.830e-321 5.830e-321 4.466e-321 4.466e-321]]

四、常用属性

numpy的多维数组常用属性主要有dtype（数据类型）、ndim（维度）、shape（性状）、size（元素个数）

arr = np.arange(12).reshape((3,4))
print(arr)
# 数据类型
print(arr.dtype)
# 维数
print(arr.ndim)
# 行数和列数
print(arr.shape)
# 大小，也就是元素个数
print(arr.size)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
int32
2
(3, 4)
12
In [52]:
arr = np.arange(12).reshape((3,4))
print(arr)
# 数据类型
print(arr.dtype)
# 维数
print(arr.ndim)
# 行数和列数
print(arr.shape)
# 大小，也就是元素个数
print(arr.size)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
int32
2
(3, 4)
12

五、基本计算

numpy中的ndarray对象重载了许多运算符，使用这些运算符可以完成矩阵间对应元素的运算。

如 +，-，*（内积），/，%，**（次方），@（矩阵阶层）

# 矩阵内积：对应位置相乘
print(arr1*arr2)
# 矩阵乘法：
print(arr1@arr2)
print(np.dot(arr1,arr2))
print(arr1.dot(arr2))
In [61]:
arr1 = np.array([[0,1],[1,2]])
arr2 = np.arange(4).reshape((2,2))
ans = arr1 + arr2
print(arr1)
print(arr2)
print("===========================")
print(ans)
print(arr2-arr1)

[[0 1]
 [1 2]]
[[0 1]
 [2 3]]
===========================
[[0 2]
 [3 5]]
[[0 0]
 [1 1]]
In [64]:
# 矩阵内积：对应位置相乘
print(arr1*arr2)
# 矩阵乘法：
print(arr1@arr2)
print(np.dot(arr1,arr2))
print(arr1.dot(arr2))

[[0 1]
 [2 6]]
[[2 3]
 [4 7]]
[[2 3]
 [4 7]]
[[2 3]
 [4 7]]
In [65]:
print(arr1*3)

[[0 3]
 [3 6]]
In [66]:
print(arr1/2)

[[0.  0.5]
 [0.5 1. ]]
In [67]:
print(arr1**2)

[[0 1]
 [1 4]]
In [69]:
print(arr2%3)

[[0 1]
 [2 0]]

六、常用函数

numpy常用多维函数有sin、sqrt、sort、transpose、max、

mean（average）、sum、median（中位数）、var（方差）、std（标准差）、cumsum（累加）、

np.clip(arr,5,9)（小于5的数全部让它变成5，大于9的数全部是9）

axis为0为1表示的意思是什么

axis为0表示对列进行操作，axis为1表示为行进行操作

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

# 平均数
print(arr.mean())
print(np.average(arr))
print(np.average(arr,axis=0)) # 0是列
print(np.average(arr,axis=1)) # 1是行

5.75
5.75
[4. 5. 7. 7.]
[1.5  6.25 9.5 ]
In [71]:
arr = np.arange(12).reshape((3,4))
print(arr)
print(np.sin(arr))
print(np.sqrt(arr))

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0.          0.84147098  0.90929743  0.14112001]
 [-0.7568025  -0.95892427 -0.2794155   0.6569866 ]
 [ 0.98935825  0.41211849 -0.54402111 -0.99999021]]
[[0.         1.         1.41421356 1.73205081]
 [2.         2.23606798 2.44948974 2.64575131]
 [2.82842712 3.         3.16227766 3.31662479]]
In [77]:
# 随机数 排序  转置  求平均数  
arr = np.random.random(12).reshape((3,4))
print(arr)
# 默认每行排序
print(np.sort(arr))

[[0.14680654 0.45555777 0.20272618 0.80548907]
 [0.0580613  0.59622315 0.14429785 0.50518877]
 [0.7277057  0.26036975 0.71367339 0.64882704]]
[[0.14680654 0.20272618 0.45555777 0.80548907]
 [0.0580613  0.14429785 0.50518877 0.59622315]
 [0.26036975 0.64882704 0.71367339 0.7277057 ]]
In [79]:
arr = np.random.random(12).reshape((3,4))
print(arr)
# 指定列排序
print(np.sort(arr,axis=0))

[[0.28404892 0.16859485 0.40676585 0.82394419]
 [0.13459384 0.35249053 0.43333728 0.09445943]
 [0.80790859 0.13132432 0.17725597 0.90638246]]
[[0.13459384 0.13132432 0.17725597 0.09445943]
 [0.28404892 0.16859485 0.40676585 0.82394419]
 [0.80790859 0.35249053 0.43333728 0.90638246]]
In [83]:
# 转置
arr = np.arange(12).reshape((3,4))
print(arr)
print(arr.T)
print(arr.transpose())

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]
In [101]:
# max,min
# 0是列（一列来操作），1是行（一行来操作）
arr = np.arange(12).reshape((3,4))
arr[1][2]=9
print(arr)
print(np.max(arr))
print(np.max(arr,axis=0))
print(np.max(arr,axis=1))

[[ 0  1  2  3]
 [ 4  5  9  7]
 [ 8  9 10 11]]
11
[ 8  9 10 11]
[ 3  9 11]
In [102]:
# 平均数
print(arr.mean())
print(np.average(arr))
print(np.average(arr,axis=0)) # 0是列
print(np.average(arr,axis=1)) # 1是行

5.75
5.75
[4. 5. 7. 7.]
[1.5  6.25 9.5 ]
In [103]:
# 中位数
print(np.median(arr))
print(np.median(arr,axis=0)) # 0是列
print(np.median(arr,axis=1)) # 1是行

6.0
[4. 5. 9. 7.]
[1.5 6.  9.5]
In [93]:
# 方差和标准差
# 方差的函数为var(),方差函数var()相当于函数mean(abs(x - x.mean())**2),其中x为矩阵。
print(np.var(arr))
# 标准差的函数为std()， std()相当于sqrt(mean(abs(x - x.mean())**2))，或相当于sqrt(x.var())。
print(np.std(arr))

11.916666666666666
3.452052529534663
In [95]:
# 求和
print(np.sum(arr))

66
In [97]:
# 累加
print(arr)
print(np.cumsum(arr))

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[ 0  1  3  6 10 15 21 28 36 45 55 66]
In [105]:
# 小于5的数全部让它变成5
# 大于9的数全部是9
print(np.clip(arr,5,9))

[[5 5 5 5]
 [5 5 9 7]
 [8 9 9 9]]
In [106]:
help(np.clip)

Help on function clip in module numpy:

clip(a, a_min, a_max, out=None, **kwargs)
    Clip (limit) the values in an array.
    
    Given an interval, values outside the interval are clipped to
    the interval edges.  For example, if an interval of ``[0, 1]``
    is specified, values smaller than 0 become 0, and values larger
    than 1 become 1.
    
    Equivalent to but faster than ``np.maximum(a_min, np.minimum(a, a_max))``.
    No check is performed to ensure ``a_min < a_max``.
    
    Parameters
    ----------
    a : array_like
        Array containing elements to clip.
    a_min : scalar or array_like or None
        Minimum value. If None, clipping is not performed on lower
        interval edge. Not more than one of `a_min` and `a_max` may be
        None.
    a_max : scalar or array_like or None
        Maximum value. If None, clipping is not performed on upper
        interval edge. Not more than one of `a_min` and `a_max` may be
        None. If `a_min` or `a_max` are array_like, then the three
        arrays will be broadcasted to match their shapes.
    out : ndarray, optional
        The results will be placed in this array. It may be the input
        array for in-place clipping.  `out` must be of the right shape
        to hold the output.  Its type is preserved.
    **kwargs
        For other keyword-only arguments, see the
        :ref:`ufunc docs <ufuncs.kwargs>`.
    
        .. versionadded:: 1.17.0
    
    Returns
    -------
    clipped_array : ndarray
        An array with the elements of `a`, but where values
        < `a_min` are replaced with `a_min`, and those > `a_max`
        with `a_max`.
    
    See Also
    --------
    ufuncs-output-type
    
    Examples
    --------
    >>> a = np.arange(10)
    >>> np.clip(a, 1, 8)
    array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
    >>> a
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> np.clip(a, 3, 6, out=a)
    array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
    >>> a = np.arange(10)
    >>> a
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)
    array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])

七、索引和迭代

numpy中，可以像普通数组一样用下标来访问元素，比如a[1][1]、a[1,1]

numpy中访问行列元素

a[1,:]（打印下标为1的行所有数）

a[:,1]（打印下标为1的列的所有数）

a[1,1:3]（第1行 列从1-2）

numpy中迭代行循环打印即可，如何迭代列

将矩阵转置即可

# 迭代列 (转置一下即可实现)
for i in a.T:
    print(i)

numpy中如何迭代多维数组的每一个数

for i in a.flat: print(i)

In [125]:
a = np.arange(3,15)
print(a)
# 索引像数组一样
print(a[3])

[ 3  4  5  6  7  8  9 10 11 12 13 14]
6
In [108]:
# 二维数组
a = np.arange(3,15).reshape((3,4))
print(a)
# 索引像数组一样
print(a[1])
print(a[1][1])
print(a[1,1])

[[ 3  4  5  6]
 [ 7  8  9 10]
 [11 12 13 14]]
[ 7  8  9 10]
8
8
In [109]:
# 打印下标为1的行所有数
print(a[1,:])
# 打印下标为1的列的所有数
print(a[:,1])
# 第1行 列从1-2
print(a[1,1:3])

[ 7  8  9 10]
[ 4  8 12]
[8 9]
In [110]:
# 迭代行
a = np.arange(3,15).reshape((3,4))
print(a)
for i in a:
    print(i)

[[ 3  4  5  6]
 [ 7  8  9 10]
 [11 12 13 14]]
[3 4 5 6]
[ 7  8  9 10]
[11 12 13 14]
In [111]:
# 迭代列 (转置一下即可实现)
for i in a.T:
    print(i)

[ 3  7 11]
[ 4  8 12]
[ 5  9 13]
[ 6 10 14]
In [112]:
# 迭代每一个数
print(a.flatten())
# flatten() 和 flat的区别
# flat是一个迭代器
for i in a.flat:
    print(i)

[ 3  4  5  6  7  8  9 10 11 12 13 14]
3
4
5
6
7
8
9
10
11
12
13
14

八、数组合并

numpy数组水平合并可以np.hstack((a,b))，类似于np.concatenate((a,b,a),axis=1)

numpy数组垂直合并可以np.vstack((a,b))，类似于np.concatenate((a,b,a),axis=0)

In [113]:
a = np.array([1,2,3])
b = np.array([4,5,6])
# 合并数组
# 上下合并 vertical stack
c = np.vstack((a,b))
print(c)
print(a.shape)
print(c.shape)

[[1 2 3]
 [4 5 6]]
(3,)
(2, 3)
In [114]:
# 左右合并 horizontal
c = np.hstack((a,b))
print(c)

[1 2 3 4 5 6]
In [115]:
# 如何实现把一个横向的数列变成一个竖向的数列
a = np.array([1,2,3])
# 在行上加了一个维度
print(a[np.newaxis,:])
# 在列上加了一个维度
print(a[:,np.newaxis])

[[1 2 3]]
[[1]
 [2]
 [3]]
In [116]:
a = np.array([1,2,3])[:,np.newaxis]
b = np.array([4,5,6])[:,np.newaxis]
print(a)
print(b)
print("====================")
c = np.concatenate((a,b,a),axis=0)
print(c)
print("====================")
d = np.concatenate((a,b,a),axis=1)
print(d)

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

九、数组分割

等量分割：水平分成两块np.split(a,2,axis=1)，vsplit和hsplit也可以等量分割

不等量分割：np.array_split(a,3,axis=1)

In [128]:
a = np.arange(12).reshape((3,4))
print(a)
print("====================")
# 分割
# 每行分割成两个
# axis=1表示对水平进行操作
print(np.split(a,2,axis=1))

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
====================
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]
In [118]:
# 纵向分割成3块
print(np.split(a,3,axis=0))

[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
In [119]:
# 不等量分割
# ValueError: array split does not result in an equal division
# print(np.split(a,3,axis=1)) # 行的四个元素分成3个会出错
print(np.array_split(a,3,axis=1))
# 这样分成了 2 1 1 

[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2],
       [ 6],
       [10]]), array([[ 3],
       [ 7],
       [11]])]
In [131]:
print(np.vsplit(a,3))
print(np.hsplit(a,2))

[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]

十、数组拷贝

numpy 中的 copy方法是 deep copy：b = np.copy(a)

In [121]:
a = np.arange(4)
b = a
print(a)
print(b)

[0 1 2 3]
[0 1 2 3]
In [122]:
a[0] = 199
b[1:3] = [7,8]
print(a)
print(b)
print(id(a))
print(id(b))
print(b is a)

[199   7   8   3]
[199   7   8   3]
2190570709120
2190570709120
True
In [132]:
# numpy 中的 copy方法是 deep copy
# 文档中说的非常详细
a = np.arange(4)
# b = a.copy()
b = np.copy(a)
print(a)
print(b)
print(id(a))
print(id(b))

[0 1 2 3]
[0 1 2 3]
2190587830880
2190587831440
In [133]:
a[0] = 199
b[1:3] = [7,8]
print(a)
print(b)

[199   1   2   3]
[0 7 8 3]
In [ ]:
 
 
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Renyi-Fan/p/13237296.html