python中的科学计算库-Numpy_points = np.genfromtxt('%d1.txt' % i, delimiter="

1. numpy.genfromtxt

作用：从txt文件中读取数据，得到一个列表
最常用的为genfromtxt(filename, delimiter=",", dtype=“str”)。
filename：被读取文件的名字
delimiter：txt文件中不同属性数据之间的分隔符
dtype：读取出的数据的类型，默认为float类型
例如，有一个test.txt文件，内容如下：
name,age,gender,num
wcy,18,m,1
wwk,17,m,2
tl,25,f,3

test= numpy.genfromtxt("test.txt", delimiter=",", dtype="str")
print(test)
1
2

输出结果为：

[['name' 'age' 'gender' 'num']
 ['wcy' '18' 'm' '1']
 ['wwk' '17' 'm' '2']
 ['tl' '25' 'f' '3']]
1
2
3
4

2. numpy.array

作用：生成一个numpy类型的矩阵

matrix = numpy.array([[5, 10, 15], [20, 25, 30], [35, 40, 45]])
print(matrix)
#查看矩阵类型
print(type(matrix))
#查看矩阵形状，debug的时候很有用
print(matrix.shape)
#查看矩阵中数据的类型
print(matrix.dtype)
1
2
3
4
5
6
7
8

输出结果为：

[[ 5 10 15]
 [20 25 30]
 [35 40 45]]
<class 'numpy.ndarray'>
(3, 3)
int32
1
2
3
4
5
6

需要注意的是，numpy.array生成的矩阵中数据的类型全都一样，例如：

vector = numpy.array([1, 2, 3, 4.0])
print(numbers)
print(vector.dtype)
1
2
3

得到：

[1. 2. 3. 4.]
dtype('float64')
1
2

因为4.0为float类型的，所以所有数据都会转换为float64类型的数据。

3. numpy.array.astype

作用：转化numpy矩阵中的数据类型

vector = numpy.array(["1", "2", "3"])
print(vector.dtype)
print(vector)
vector = vector.astype(float)
print(vector.dtype)
print(vector)
1
2
3
4
5
6

输出结果为：

|S1
['1' '2' '3']
float64
[ 1.  2.  3.]
1
2
3
4

4. numpy.arange

作用：返回一个有终点和起点的固定步长的排列

最普通的用法：

a = np.arange(15)
print(a)
1
2

得到结果：

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

也可以指定步长：

#10到30之间，每隔5取一个数
np.arange( 10, 30, 5 )
#结果
array([10, 15, 20, 25])
1
2
3
4

5. numpy.linspace

作用：在指定区间内取n个数

#在0-50间取20个数
print(np.linspace( 0, 50, 20))
1
2

结果：

[ 0.          2.63157895  5.26315789  7.89473684 10.52631579 13.15789474
 15.78947368 18.42105263 21.05263158 23.68421053 26.31578947 28.94736842
 31.57894737 34.21052632 36.84210526 39.47368421 42.10526316 44.73684211
 47.36842105 50.        ]
1
2
3
4

6. numpy.random.random

作用：随机生成一个指定大小的矩阵

#注意是两个括号，一个括号会报错
np.random.random((2,3))
1
2

结果为：

array([[ 0.40130659,  0.45452825,  0.79776512],
       [ 0.63220592,  0.74591134,  0.64130737]])
1
2

7. numpy.zeros和numpy.ones

作用：zeros,生成指定大小的元素全为0的矩阵;ones，生成指定大小的元素全为1的矩阵。

zeros:

np.zeros ((3,4)) 
1

由结果可以看到，默认的数据类型为float型

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

ones:
可以使用dtype参数指定生成元素的数据类型

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

结果为：

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]]])
1
2
3
4
5
6
7

8. numpy.array.ravel

作用：将矩阵拉成一个向量

a=np.random.random((2,3))
print(a.shape)
print(a.ravel().shape)
1
2
3

结果为：

(2, 3)
(6,)
1
2
'
运行
运行

9. numpy.array.reshape

a=np.random.random((3,4))
print(a)
print("----------")
a.reshape(2,6)
print(a)
print("----------")
#当给出reshape一些参数之后，可以确定另外一个参数，呢么可以用-1表示
a.reshape(6,-1)
print(a)
print("----------")
1
2
3
4
5
6
7
8
9
10

输出为：

[[0.48805901 0.13437123 0.06571408 0.69987945]
 [0.35907378 0.18497138 0.73855317 0.50127783]
 [0.89146941 0.28401389 0.51699227 0.79399227]]
----------
[[0.48805901 0.13437123 0.06571408 0.69987945 0.35907378 0.18497138]
 [0.73855317 0.50127783 0.89146941 0.28401389 0.51699227 0.79399227]]
----------
[[0.48805901 0.13437123]
 [0.06571408 0.69987945]
 [0.35907378 0.18497138]
 [0.73855317 0.50127783]
 [0.89146941 0.28401389]
 [0.51699227 0.79399227]]
----------
1
2
3
4
5
6
7
8
9
10
11
12
13
14

10. 矩阵拼接

使用np.hstack()和np.vstack()
直接上代码：

a = np.floor(10*np.random.random((2,2)))
b = np.floor(10*np.random.random((2,2)))
print(a)
print( '---')
print(b)
print ('---')
#横向拼接矩阵
print(np.hstack((a,b)))
print ('---')
#纵向拼接矩阵
print(np.vstack((a,b)))
1
2
3
4
5
6
7
8
9
10
11

结果为：

[[0. 6.]
 [9. 4.]]
---
[[7. 0.]
 [5. 4.]]
---
[[0. 6. 7. 0.]
 [9. 4. 5. 4.]]
---
[[0. 6.]
 [9. 4.]
 [7. 0.]
 [5. 4.]]
1
2
3
4
5
6
7
8
9
10
11
12
13

11. 矩阵切分

a = np.floor(10*np.random.random((2,12)))
print(a)
#横向上切成三等分
print(np.hsplit(a,3))
#横向上，在第3列,第4列和第5列后面分割
print(np.hsplit(a,(3,4,5))) 
1
2
3
4
5
6

结果为：

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

当然，纵向也是可以操作的。

12. 矩阵复制

复制有三种方法:
①直接用等于号复制

a = np.arange(12)
b = a
print(b is a)
b.shape = (3,4)
print(a.shape)
print(id(a))
print(id(b))
1
2
3
4
5
6
7

结果为：

True
(3, 4)
2349040641088
2349040641088
1
2
3
4
'
运行
运行

可以看出，使用等号复制，只是个被复制的矩阵取了个别名，两个变量是指向同一个矩阵的，改变任意一个矩阵，两个变量都会改变。

②使用array.view()方法：
view()方法创建了一个新的对象，但是这两个对象共享相同的数据。

c = a.view()
print(c is a)
c.shape = 2,6
print(a.shape)
c[0,4] = 1234
print(a)
1
2
3
4
5
6

结果为：

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

c不等于a，c不能改变a的shape属性，但是可以改变a矩阵中的值。

③使用array.copy()方法：
copy()方法，完全生成一个新的矩阵，和原矩阵无任何关联，就是所谓的深拷贝。

d = a.copy() 
print(d is a)
d[0,0] = 1024
print(d) 
print(a)
1
2
3
4
5

结果为：

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

13. 矩阵排序

a = np.array([[4, 3, 5], [1, 2, 1]])
#按行排序
b = np.sort(a, axis=1)
print(b)
#按列排序
b = np.sort(a, axis=0)
print(b)
a = np.array([4, 3, 1, 2])
#得到排序后元素的索引
j = np.argsort(a)
print (j)
print (a[j])
1
2
3
4
5
6
7
8
9
10
11
12

结果为：

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

14. 其他操作

1).在numpy数组中查找指定值

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

结果为：

[False  True False False]
[2]
1
2

也可以使用与或非来查找：

vector = numpy.array([5, 10, 15, 20])
equal_to_ten_or_five = (vector == 10) | (vector == 5)
print(equal_to_ten_or_five)
1
2
3

输出：

[ True  True False False]
1

2). 在numpy数组中取极值

使用max(), min()函数

vector = numpy.array([5, 10, 15, 20])
print(vector.max())
print(vector.min())
1
2
3

结果为：

20
5
1
2
'
运行
运行

3). numpy数组求和

使用sum()函数

matrix = numpy.array([
                [5, 10, 15], 
                [20, 25, 30],
                [35, 40, 45]
             ])
matrix.sum(axis=0)
matrix.sum(axis=1)
1
2
3
4
5
6
7

结果为：

[60 75 90]
[30 75 120]
1
2

显然，当axis为0时，求的是矩阵列和，当axis为1时，求的是矩阵行和。

4). 矩阵运算

两矩阵之差：

a = np.array( [20,30,40,50] )
b = np.arange( 4 )
c = a-b
print(c)
1
2
3
4

结果为：

[20 29 38 47]
1

另外还有乘方、自减等操作也是和普通数字运算一样。
矩阵两种乘法：

A = np.array( [[1,1],
               [0,1]] )
B = np.array( [[2,0],
               [3,4]] )
#矩阵中对应元素相乘
print(A*B)
#矩阵乘法（线性代数）
print(A.dot(B))
#矩阵乘法的另一种方法
print(np.dot(A, B)) 
1
2
3
4
5
6
7
8
9
10

结果为

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

5). 矩阵扩展

将一个矩阵作为元素扩展为指定大小的矩阵

a = np.arange(0, 40, 10)
print(a)
b = np.tile(a, (3, 5)) 
print(b)
1
2
3
4

结果为：

[ 0 10 20 30]
[[ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
 [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
 [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]]
1
2
3
4