一、文件读取

　　numpy.genfromtxt() 可以用来读取各种文件。常用语法大致如下：

　　numpy.genfromtxt(fname, dtype=<type 'float'>, delimiter=None, skip_header=0, skip_footer=0)

　　fname 要导入的文件路径

　　dtype 指定要导入文件的类型，dtype=str / int等等

　　delimiter 文件中不同元素间的间隔方式，空格还是逗号什么的，如：delimiter=','；

　　skip_header 是否跳过开头行，一般第一行为类别，为0不跳过，为1或者2则跳过前面1或者2行

import numpy

students = numpy.genfromtxt("student_list.txt", delimiter=",",dtype=str, skip_header=0)

二、构造ndarray

　　1、NumPy的数组类被称作ndarray，通常被称作数组。

　　np.array只是一个便捷的函数，用来创建一个ndarray，它本身不是一个类。

　　ndarray：N维数组对象（矩阵），所有元素必须是相同类型。
　　ndarray属性：

　　　　ndim属性，表示维度个数；

　　　　shape属性，表示各维度大小；

　　　　dtype属性，表示数据类型。

　创建ndarray数组函数：

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

　　numpy.array()构造 ndarray

　　numpy.array()中传入数组参数，可以是一维的也可以是二维三维的。numpy 会将其转变成 ndarray 的结构。

vector = numpy.array([1,2,3,4])

matrix = numpy.array([[1,2,3],[4,5,6]])

　　传入的参数必须是同一结构,不是同一结构将发生转换。

vector = numpy.array([1,2,3,4])       # 均为int型

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

vector = numpy.array([1,2,3,4.0])  # 转为float类型

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

vector = numpy.array([1,2,'',4])   # 转为str类型

array(['1', '2', '3', '4'],dtype='<U21')

　　利用 .shape 查看结构

　　能够了解 array 的结构，debug 时通过查看结构能够更好地了解程序运行的过程。

print(vector.shape)

print(matrix.shape)

(4,)

(2, 3)

　　利用 dtype 查看类型

vector = numpy.array([1,2,3,4])

vector.dtype

dtype('int64')

　　ndim 查看维度

vector = numpy.array([1,2,3,4])

vector.ndim

matrix = numpy.array([[1,2,3],

                      [4,5,6],

                     [7,8,9]])

matrix.ndim

　　size 查看元素数量

matrix.size

　　2、数组和矩阵matrix的区别（matrix 和 array的区别）

Numpy matrix必须是2维的,但是 numpy arrays (ndarrays) 可以是多维的（1D，2D，3D····ND）. Matrix是Array的一个小的分支，包含于Array。所以matrix 拥有array的所有特性。但这时候，官方建议大家如果两个可以通用，那就选择array，因为array更灵活，速度更快，很多人把二维的array也翻译成矩阵。
但是matrix的优势就是相对简单的运算符号，比如两个矩阵相乘，就是用符号*，但是array相乘不能这么用，得用方法.dot()
matrix 和 array 都可以通过objects后面加.T 得到其转置。但是 matrix objects 还可以在后面加 .H 得到共轭矩阵, 加 .I 得到逆矩阵。
在numpy里面arrays遵从逐个元素的运算，所以array：c 和d的c*d为对应元素相乘，而矩阵相乘，则需要numpy里面的dot命令。

a=np.mat('4 3; 2 1')

b=np.mat('1 2; 3 4')

print(a)

# [[4 3]

#  [2 1]]

print(b)

# [[1 2]

#  [3 4]]

print(a*b)

# [[13 20]

#  [ 5  8]]

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

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

print(c*d)

# [[4 6]

#  [6 4]]

print(np.dot(c,d))

# [[13 20] # [ 5 8]]

>>> a=np.mat([[4+2j 3], [2 1]])

>>> a

matrix([[ 4.+2.j,  3.+0.j],

        [ 2.+0.j,  1.+0.j]])

>>> a.H

matrix([[ 4.-2.j,  2.-0.j],

        [ 3.-0.j,  1.-0.j]])

>>> a.I

matrix([[-0.25-0.25j,  0.75+0.75j],

        [ 0.50+0.5j , -0.50-1.5j ]])>>> b=np.array([[4, 3], [2, 1]])

>>> b.T

array([[4, 2],

       [3, 1]])

>>> b.H

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

AttributeError: 'numpy.ndarray' object has no attribute 'H'

** 运算符的作用也不一样

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

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

print(a**2)

# [[22 15]

#  [10  7]]

print(c**2)

# [[16  9]

#  [ 4  1]]

　　因为a是个matrix，所以a**2返回的是a*a，相当于矩阵相乘。而c是array，c**2相当于，c中的元素逐个求平方。

　　问题就出来了，如果一个程序里面既有matrix 又有array，会让人脑袋大。但是如果只用array，你不仅可以实现matrix所有的功能，还减少了编程和阅读的麻烦。

三、获取与计算

　　numpy 能使用切片获取数据

matrix = numpy.array([[1,2,3],

                      [4,5,6],

                     [7,8,9]])

>>> matrix[1,1]

5

>>> matrix[0,2]

3

>>> matrix[1,]

array([4, 5, 6])

>>> matrix[1]

array([4, 5, 6])

>>> matrix[1][0]

4

>>> matrix[:,1]

array([2, 5, 8])

　>>> matrix[1,...]
array([4, 5, 6])
>>> matrix[...,1]
array([2, 5, 8])

　　根据条件获取

　　numpy 能够依次比较 vector 和元素之间是否相同

vector = numpy.array([5, 10, 15, 20])

vector == 10

array([False,  True, False, False], dtype=bool)

vector = numpy.array([5, 10, 15, 20])

equal_to_ten = (vector == 10)

print(equal_to_ten)

print(vector[equal_to_ten])

[False  True False False]

[]

vector = numpy.array([5, 10, 15, 20])

equal_to_ten_and_five = (vector == 10) & (vector == 5)

vector = numpy.array([5, 10, 15, 20])

equal_to_ten_or_five = (vector == 10) | (vector == 5)

　　类型转换

　　将整体类型进行转换

vector = numpy.array([5, 10, 15, 20])

print(vector.dtype)

vector = vector.astype(str)

print(vector.dtype)

int64

<U21

　　求和

　　sum() 能够对 ndarray 进行各种求和操作，比如分别按行按列进行求和，sum(1) 是 sum(axis=1)) 的缩写，1表示按照 x轴方向求和，0表示按照y轴方向求和

matrix = numpy.array([[1,2,3],

                      [4,5,6],

                     [7,8,9]])

print(matrix.sum())

print(matrix.sum(1))

print(matrix.sum(0))

45

[ 6 15 24]

[12 15 18]

四、常用函数

　　reshape

　　生成从 0-14 的 15 个数字，使用 reshape(3,5) 将其构造成一个三行五列的 array。

　　resize和reshape都可以改变ndarray的结构，但resize会对原值进行修改，返回None，而reshape不会对原值进行修改，返回是修改后结果。

import numpy as np

arr = np.arange(15).reshape(3, 5)

arr

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

       [ 5,  6,  7,  8,  9],

       [10, 11, 12, 13, 14]])

　zeros

　　生成指定结构的默认为 0. 的 array

np.zeros ((3,4))

array([[ 0.,  0.,  0.,  0.],

       [ 0.,  0.,  0.,  0.],

       [ 0.,  0.,  0.,  0.]])

　ones

　　生成一个三维的 array,通过 dtype 指定类型

np.ones( (2,3,4), dtype=np.int32 )

array([[[1, 1, 1, 1],

        [1, 1, 1, 1],

        [1, 1, 1, 1]],

       [[1, 1, 1, 1],

        [1, 1, 1, 1],

        [1, 1, 1, 1]]])

　arange

　　指定范围和数值间的间隔生成 array，注意范围包左不包右

np.arange(0,10,2)

array([0, 2, 4, 6, 8])

　linespace 随机数

　　生成等差数列

>>> np.linspace(0,10)        # 默认生成50个值

array([ 0.        ,  0.20408163,  0.40816327,  0.6122449 ,  0.81632653,

        1.02040816,  1.2244898 ,  1.42857143,  1.63265306,  1.83673469,

        2.04081633,  2.24489796,  2.44897959,  2.65306122,  2.85714286,

        3.06122449,  3.26530612,  3.46938776,  3.67346939,  3.87755102,

        4.08163265,  4.28571429,  4.48979592,  4.69387755,  4.89795918,

        5.10204082,  5.30612245,  5.51020408,  5.71428571,  5.91836735,

        6.12244898,  6.32653061,  6.53061224,  6.73469388,  6.93877551,

        7.14285714,  7.34693878,  7.55102041,  7.75510204,  7.95918367,

        8.16326531,  8.36734694,  8.57142857,  8.7755102 ,  8.97959184,

        9.18367347,  9.3877551 ,  9.59183673,  9.79591837, 10.        ])

>>> np.linspace(1,20,10,dtype=int) 可指定区间范围，个数，和类型

array([ 1,  3,  5,  7,  9, 11, 13, 15, 17, 20])

　random 随机数

　　生成指定结构的随机数，可以用于生成随机权重，用法和Python的random模块基本一致

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

array([[ 0.86166627,  0.37756207,  0.94265883],

       [ 0.9768257 ,  0.96915312,  0.33495431]])

>>> li = list(range(0,10))
>>> li

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

>>> np.random.shuffle(li)

>>> li

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

>>> np.random.choice(li)

2

>>> np.random.sample(3)

array([0.41578646, 0.4275044 , 0.46925681])

>>> np.random.choice(5,2)

array([4, 4])

>>> np.random.choice(li,5)

array([3, 3, 4, 5, 0])

>>> np.random.rand()  # 0-1随机数

0.5526940210685204

>>> np.random.randn() # 标准正态分布

-1.3879406767054916

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

array([[0.76781829, 0.98909192],

       [0.56726061, 0.48113612],

       [0.52529073, 0.00218226],

       [0.5546019 , 0.29870287]])

>>> np.random.randn(4,2)

array([[-0.68062491,  0.46315132],

       [-0.13610026, -0.72371849],

       [-1.15933349, -0.92001229],

       [ 0.79173944, -1.29063009]])

>>> np.random.randint(4)  # 随机整数

1

>>> np.random.randint(0,10,4)   # 0-10的随机整数

array([6, 9, 1, 1])

>>> np.random.seed(3)

>>> np.random.random()

0.5507979025745755

>>> np.random.random()

0.7081478226181048

>>> np.random.seed(3)

>>> np.random.random()

0.5507979025745755

五、ndarray 运算

　　元素之间依次相减相减

a = np.array([10,20,30,40])

b = np.array(4)

a - b

array([ 6, 16, 26, 36])

　　乘方

a**2

array([ 100,  400,  900, 1600])

　　开根号

np.sqrt(B)

array([[ 1.41421356,  0.        ],

       [ 1.73205081,  2.        ]])

　　e 求方

np.exp(B)

array([[  7.3890561 ,   1.        ],

       [ 20.08553692,  54.59815003]])

　　向下取整

a = np.floor(10*np.random.random((2,2)))

a

array([[ 0.,  0.],

       [ 3.,  6.]])

　　行列变换

a.T

array([[ 0.,  3.],

       [ 0.,  6.]])

　　变换结构

a.resize(1,4)

a

array([[ 0.,  0.,  3.,  6.]])

六、矩阵运算

　　矩阵之间的运算

A = np.array( [[1,1],

               [0,1]] )

B = np.array( [[2,0],

               [3,4]] )

　　*运算

　　对于ndarray, * 作用的是进行element-wise乘积，必要时需要broadcast，作用同np.multipy

>>> a = np.array(range(6)).reshape((2,3))

>>> b = np.array([1,0,1])

>>> a

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

>>> b

array([1, 0, 1])

>>> c= a*b

>>> c

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

>>> d = a*b.T

>>> d

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

　　而对于matrix，* 则表示矩阵相乘，运算必须保证矩阵相乘的法则:

>>> A=np.matrix(a)

>>> B=np.matrix(b)

>>> A

matrix([[0, 1, 2],

        [3, 4, 5]])

>>> B

matrix([[1, 0, 1]])

>>> C=A*B

ValueError: shapes (2,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)

#维数不匹配

>>> C=A*B.T

>>> C

matrix([[2],

        [8]])

　　dot运算

如果 a 和 b都是 1-D arrays,它的作用是计算内积。(不进行复共轭)

>>> np.dot(3, 4)

12

>>> np.dot([2j, 3+3j], [2j, 3j])

(-13+9j)

如果 a 和 b 是 2-D arrays, 作用是矩阵的乘积， a 和 b的维数要满足矩阵乘积维数要求，此时推荐使用 matmul 或 a @ b 。

>>> a = [[1, 0], [0, 1]]

>>> b = [[4, 1], [2, 2]]

>>> np.dot(a, b)

array([[4, 1],

       [2, 2]])

如果 a 或 b 是 0-D (标量), 等价于 multiply ，推荐使用 numpy.multiply(a, b)或 a * b。

如果 a 是 N-D array 且 b 是 1-D array，作用是在a 和 b的最后一个轴上进行sum product运算。

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

          [ 5.,  6.,  7.,  8.],

          [ 9., 10., 11., 12.]],

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

          [ 5.,  6.,  7.,  8.],

          [ 9., 10., 11., 12.]]])

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

>>>np.dot(a, b)

array([[ 30.,  70., 110.],

       [ 30.,  70., 110.]])

如果a 是 N-D array 且 b 是 M-D array (M>=2), 作用是在a的最后一个轴上和b的倒数第二个轴上进行sum product，即 :

dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])

>>> a = np.arange(3*4*5*6).reshape((3,4,5,6))

>>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))

>>> np.dot(a, b)[2,3,2,1,2,2]

499128

>>> sum(a[2,3,2,:] * b[1,2,:,2])

499128

　　multiply运算

　　函数原型是

numpy.multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'multiply'>

　　Returns:
　　　　y : ndarray
　　　　x1 和 x2的element-wise乘积，保证x1和x2有相同的维数，或者进行broadcast之后两者有相同的维数

>>> np.multiply(2.0, 4.0)

8.0

>>> x1 = np.arange(9.0).reshape((3, 3))

>>> x2 = np.arange(3.0)

>>> np.multiply(x1, x2)

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

       [  0.,   4.,  10.],

       [  0.,   7.,  16.]])

#要进行broadcast

　　横向堆叠

a = np.floor(10*np.random.random((2,2)))

b = np.floor(10*np.random.random((2,2)))

print(a)

print(b)

print(np.hstack((a,b)))

[[ 2.  3.]

 [ 9.  3.]]

[[ 8.  1.]

 [ 0.  0.]]

[[ 2.  3.  8.  1.]

 [ 9.  3.  0.  0.]]

　　纵向堆叠

print(np.vstack((a,b)))

[[ 2.  3.]

 [ 9.  3.]

 [ 8.  1.]

 [ 0.  0.]]

　　矩阵分割

#横向分割

print( np.hsplit(a,3))

#纵向风格

print(np.vsplit(a,3))

七、复制的区别

　　地址复制

　　通过 b = a 复制 a 的值，b 与 a 指向同一地址，改变 b 同时也改变 a。

a = np.arange(12)

b = a

print(a is b)

print(a.shape)

print(b.shape)

b.shape = (3,4)

print(a.shape)

print(b.shape)

True

(12,)

(12,)

(3, 4)

(3, 4)

　　复制值

　　通过 a.view() 仅复制值，当对 c 值进行改变会改变 a 的对应的值，而改变 c 的 shape 不改变 a 的 shape

a = np.arange(12)

c = a.view()

print(c is a)

c.shape = 2,6

c[0,0] = 9999

print(a)

print(c)

False

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

[[9999    1    2    3    4    5]

 [   6    7    8    9   10   11]]

　完整拷贝

　　a.copy() 进行的完整的拷贝，产生一份完全相同的独立的复制

a = np.arange(12)

c = a.copy()

print(c is a)

c.shape = 2,6

c[0,0] = 9999

print(a)

print(c)

False

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

[[9999    1    2    3    4    5]

 [   6    7    8    9   10   11]]

八、数组的排序

　　经常需要对数组或者list进行排序，python提供了好几种排序的函数，下面说明下特点：

In [98]: a = np.array([[2,4,1],[4,3,9]])

In [99]: a

Out[99]:

array([[2, 4, 1],

       [4, 3, 9]])

　　1、ndarray.sort(axis=-1,kind='quicksort',order=None)

使用方法：a.sort
参数说明：
axis：排序沿着数组的方向，0表示按行，1表示按列
kind：排序的算法，提供了快排、混排、堆排
order：不是指的顺序，以后用的时候再去分析这个
作用效果：对数组a排序，排序后直接改变了a

In [101]: a.sort(axis=1)

In [102]: a

Out[102]:

array([[1, 2, 4],

       [3, 4, 9]])

　　2、numpy.sort(a,axis=-1,kind='quicksort',order=None)

使用方法：numpy.sort(a)
参数说明：
a：要排序的数组，其他同1
作用效果：对数组a排序，返回一个排序后的数组（与a相同维度），a不变

In [106]: np.sort(a,axis=1)

Out[106]:

array([[1, 2, 4],

       [3, 4, 9]])

In [107]: a

Out[107]:

array([[2, 4, 1],

       [4, 3, 9]])

　　3、numpy.argsort(a,axis=-1,kind='quicksort',order=None)，numpy.argsort() 和 numpy.lexsort()都可以返回升序排序后的索引，不同的是numpy.lexsort() 可以接受多列，即可以进行子排序。

使用方法：numpy.argsort(a)
参数说明：同2
作用效果：对数组a排序，返回一个排序后索引，a不变

In [108]: np.argsort(a,axis=1)

Out[108]:

array([[2, 0, 1],

       [1, 0, 2]])

In [109]: a

Out[109]:

array([[2, 4, 1],

       [4, 3, 9]])

　　4、python 内置函数 sorted(iterable,cmp=None,key=None,reverse=False)

说明：内置的排序函数，对list，字典等等可以使用
iterable：是可迭代类型;
cmp：用于比较的函数，比较什么由key决定,有默认值，迭代集合中的一项;
key：用列表元素的某个属性和函数进行作为关键字，有默认值，迭代集合中的一项;
reverse：排序规则.reverse=True或者reverse=False，默认False（从小到大）。
返回值：是一个经过排序的可迭代类型，与iterable一样;

In [112]: sorted(a[0])

Out[112]: [1, 2, 4]

Numpy基础总结的更多相关文章

利用Python进行数据分析(5) NumPy基础: ndarray索引和切片
概念理解索引即通过一个无符号整数值获取数组里的值. 切片即对数组里某个片段的描述. 一维数组一维数组的索引一维数组的索引和Python列表的功能类似: 一维数组的切片一维数组的切片语法格式为a ...
《利用python进行数据分析》读书笔记--第四章 numpy基础：数组和矢量计算
http://www.cnblogs.com/batteryhp/p/5000104.html 第四章 Numpy基础:数组和矢量计算第一部分:numpy的ndarray:一种多维数组对象实话说, ...
利用Python进行数据分析——Numpy基础：数组和矢量计算
利用Python进行数据分析--Numpy基础:数组和矢量计算 ndarry,一个具有矢量运算和复杂广播能力快速节省空间的多维数组对整组数据进行快速运算的标准数学函数,无需for-loop 用于读写 ...
numpy 基础操作
Numpy 基础操作¶ 以numpy的基本数据例子来学习numpy基本数据处理方法主要内容有: 创建数组数组维度转换数据选区和切片数组数据计算随机数数据合并数据统计计算 In [1]: ...
Numpy 基础
Numpy 基础参考https://www.jianshu.com/p/83c8ef18a1e8 import numpy as np 简单创建数组 # 创建简单列表 a = [1, 2, 3, 4 ...
[转]python与numpy基础
来源于:https://github.com/HanXiaoyang/python-and-numpy-tutorial/blob/master/python-numpy-tutorial.ipynb ...
python学习笔记（三）：numpy基础
Counter函数可以对列表中数据进行统计每一个有多少种 most_common(10)可以提取前十位 from collections import Counter a = ['q','q','w' ...
Numpy基础数据结构 python
Numpy基础数据结构 NumPy数组是一个多维数组对象,称为ndarray.其由两部分组成: 实际的数据描述这些数据的元数据 1.一维数组 import numpy as np ar = np.a ...
Python Numpy基础教程
Python Numpy基础教程本文是一个关于Python numpy的基础学习教程,其中,Python版本为Python 3.x 什么是Numpy Numpy = Numerical + Pyth ...
NumPy基础操作
NumPy基础操作(1) (注:记得在文件开头导入import numpy as np) 目录: 数组的创建强制类型转换与切片布尔型索引结语数组的创建相关函数 np.array(), np. ...

随机推荐

noip第7课作业
1. 求平均值 [问题描述] 在一次运动会方队表演中,学校安排了十名老师进行打分.对于给定的每个参赛班级的不同打分(百分制整数),按照去掉一个最高分.去掉一个最低分,再算出平均分的方法,得到改班 ...
HDU1501 Zipper（DFS） 2016-07-24 15:04 65人阅读评论(0) 收藏
Zipper Problem Description Given three strings, you are to determine whether the third string can be ...
hdu1089 Ignatius's puzzle
题目其实这道题不是很难,但是我刚开始拿到这道题的时候不知道怎么做, 因为这个式子我就不知道是干什么的: 65|f(x) 百度解释(若a/b=x...0 称a能被b整除,b能整除a,即b|a,读作& ...
H3C交换机流量镜像
今天需要对交换机进行本地流量镜像,在此记录: 交换机:H3C S5120 配置本地端口镜像时,用户首先要创建一个本地镜像组,然后为本地镜像组配置源端口和目的端口. 表1-1 配置本地端口镜像操作命 ...
python的特性
python使用c语言开发 1.面向对象的特性面向对象的程序设计抽象出对象的行为和属性,把行为和属性分离开,但是又合理的组织在一起.它消除了保护类型.抽象类.接口等面向对象的元素,使得面向对象的概念 ...
How To Change the Supplier Bank Account Masking in UI (Doc ID 877074.1)
Give Feedback... How To Change the Supplier Bank Account Masking in UI (Doc ID 877074.1) ...
浏览器中调用PHP在执行linux sudo指令时报sudo: sorry, you must have a tty to run sudo
在php程序中使用了exec函数调用sudo指令,在浏览器中访问后,报sudo: sorry, you must have a tty to run sudo错误. 按照网上搜到的方法,修改/etc/ ...
BitAdminCore框架更新日志20180523
20180523更新内容本次更新两个内容,一是增加视频处理功能,二是增加定时服务功能. 视频处理定时服务 BitAdminCore框架,用最少的代码,实现最多的功能本次新暂未发布,后续有空发布 ...
application/force-download 不生效
不管用什么方式都无法下载txt 设置application/force-download也不生效很无奈胡搞瞎搞最终解决方案:但是没搞明白什么原理问题解决 @RequestMapping(val ...

Numpy基础总结

numpy.array()构造 ndarray

利用 .shape 查看结构

利用 dtype 查看类型

ndim 查看维度

size 查看元素数量

numpy 能使用切片获取数据

根据条件获取

类型转换

求和

四、 常用函数

arange

五、ndarray 运算

六、 矩阵运算

七、 复制的区别

完整拷贝

Numpy基础总结的更多相关文章

随机推荐

热门专题

　　numpy.array()构造 ndarray

　　利用 .shape 查看结构

　　利用 dtype 查看类型

　　ndim 查看维度

　　size 查看元素数量

　　numpy 能使用切片获取数据

　　根据条件获取

　　类型转换

　　求和

四、常用函数

　arange

六、矩阵运算

七、复制的区别

　完整拷贝