Hexo
0%

numpy

发表于 更新于 分类于

简介

参考链接
NumPy Ndarray对象
这只是简单的入门，以后接触得越多，对于其中的理解也才会更加全面，并做补充。


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 1.简单的array对象
a = np.array([1,  2,  3], dtype = complex)

# 2.结构数组形式的array对象
student = np.dtype([('name','S20'),  ('age',  'i1'),  ('marks',  'f4')]) 
a = np.array([('abc',  21,  50),('xyz',  18,  75)], dtype = student)  
print(a)
[('abc', 21, 50.0), ('xyz', 18, 75.0)]
a[0]['name']

# 3.其他形式
a.shape
a.reshape(2,4,3)  
x.itemsize 每个元素的字节单位长度
numpy.frombuffer() 怎么理解？？
np.fromiter(iter(list))
numpy.arange(start, stop, step, dtype)
numpy.linspace(start, stop, num, endpoint, retstep, dtype)
numpy.logscale(start, stop, num, endpoint, base, dtype)

numpy的保存和读取，这里还是有点东西的，待续

1
2
3
4
5
6
7
8
9
10
# numpy在save和load的时候没有显式保存变量名
np.save("A.npy",A)
B=np.load("A.npy")
B

np.savez("files.npz",A,B,C_array=C)
np.savez_compressed("files.npz",A,B,C_array=C)
D=np.load("files.npz")
D['arr_1']
D['C_array']

numpy savetxt() loadtxt

1
2
np.savetxt('a.txt',a,fmt='%d', delimiter=',')
b= np.loadtxt('a.txt',delimiter=',')
1
2
np.savetxt('a.csv',a,fmt='%d', delimiter=',')
b= np.loadtxt('a.csv',delimiter=',')

索引

ndarray对象中的元素遵循基于零的索引。 有三种可用的索引方法类型： 字段访问，基本切片和高级索引，可以使用省略号当全部
切片只是返回一个视图，高级索引返回数据的副本，并且切片是全取，而高级索引是取对应的位置的元素
y = x[1:3,1:2]:两行元素,y = x[[1,2],[1,3]]:两个元素
布尔索引是数据的复制
广播法则
数组上的迭代 for i in np.nditer(a,order=’C’ or order=’F’), np.nditer(a).next()
广播迭代

reshape：不改变数据的条件下修改形状
flat：数组上的一维迭代器， for i in a.flat , a.flat[2:4], 暂时看不出来flat和nditer的区别
flatten: 返回折叠为一维的数组副本
ravel： 返回连续的展开数组 flattten和ravel的区别暂时不知道在哪
numpy.rollaxis：这里的转轴有问题，比较好的理解是[[[000,001],[010,011]],[[100,101],[110,111]]]，[参考：]https://blog.csdn.net/liaoyuecai/article/details/80193996，还有一种理解是从页，行，列的方式，每次都在原数组上以固定页，固定行的方式进行读取，保证所有的数字以一列的方式，即总是表示成000,001,010,011,100,101,110,111，再想一个更简单的方法。跨括号法，不扯
numpy.swapaxes(arr, axis1, axis2)

修改维度

序号 维度和描述

  1. broadcast 产生模仿广播的对象 b = np.broadcast(x,y) c = np.empty(b.shape) c.flat = [u + v for (u,v) in b],并且np.nditer()也可以达到相同的效果
  2. broadcast_to 将数组广播到新形状 numpy.broadcast_to(array, shape, subok)
  3. expand_dims 扩展数组的形状numpy.expand_dims(arr, axis)
  4. squeeze 从数组的形状中删除单维条目 y = np.squeeze(x,axis=(0,1))

数组的连接
序号 数组及描述

  1. concatenate 沿着现存的轴连接数据序列，不产生新的轴
  2. stack 沿着新轴连接数组序列，产生新的轴
  3. hstack 水平堆叠序列中的数组(列方向)
  4. vstack 竖直堆叠序列中的数组(行方向)
    数组分割
    序号 数组及操作
  5. split 将一个数组分割为多个子数组
  6. hsplit 将一个数组水平分割为多个子数组(按列)
  7. vsplit 将一个数组竖直分割为多个子数组(按行)

添加/删除元素
序号 元素及描述

  1. resize 返回指定形状的新数组
  2. append 将值添加到数组末尾
  3. insert 沿指定轴将值插入到指定下标之前
  4. delete 返回删掉某个轴的子数组的新数组
  5. unique 寻找数组内的唯一元素

切片的新表达式： np.s_[::2]
位运算：跳过

字符串函数：对dtype为numpy.string或numpy.unicode的数组执行向量化字符串操作

  1. add() 返回两个str或Unicode数组的逐个字符串连接
  2. multiply() 返回按元素多重连接后的字符串
  3. center() 返回给定字符串的副本，其中元素位于特定字符串的中央
  4. capitalize() 返回给定字符串的副本，其中只有第一个字符串大写
  5. title() 返回字符串或 Unicode 的按元素标题转换版本
  6. lower() 返回一个数组，其元素转换为小写
  7. upper() 返回一个数组，其元素转换为大写
  8. split() 返回字符串中的单词列表，并使用分隔符来分割
  9. splitlines() 返回元素中的行列表，以换行符分割
  10. strip() 返回数组副本，其中元素移除了开头或者结尾处的特定字符
  11. join() 返回一个字符串，它是序列中字符串的连接
  12. replace() 返回字符串的副本，其中所有子字符串的出现位置都被新字符串取代
  13. decode() 按元素调用str.decode
  14. encode() 按元素调用str.encode

dtype???
add()，subtract()，multiply()和divide()
排序quicksort, mergesort, heaqsort
dt = np.dtype([(‘name’, ‘S10’),(‘age’, int)])
a = np.array([(“raju”,21),(“anil”,25),(“ravi”, 17), (“amar”,27)], dtype = dt)
print(np.sort(a, order = ‘name’))
numpy.argsort()
numpy.lexsort()
np.argmax() np.argmin()
np.nonzero()
np.where()
np.extract()

改变形状： b.shape = 3,2
无复制： b = a 值和形状都是共享，id相同
浅复制: b = a.view()　值共享，形状不共享，id不同　切片也是浅复制
深复制：ｂ＝ a.copy()

numpy.matlib　
矩阵库，返回的是矩阵matrix对象，而不是ndarray对象 .empty(), .zeros(), .ones(), eye(), identity(), rand() 只能是二维的
np.matrix(‘1,2;3,4’) np.matirx([[1,2],[3,4]])

array和asarray都可以将结构数据转化为ndarray，但是主要区别就是当数据源是ndarray时，array仍然会copy出一个副本，占用新的内存，但asarray不会。
matrix和array互换： np.matrix(np.array) np.array(np.matrix),此时两者值和形状没有关系，使用asmatrix和asarray时，值共享，形状不共享
暂时没有想到matrix的意义

线性代数
numpy.linalg
貌似可以直接作用于列表

  1. dot 两个数组的点积，也就是矩阵式乘法 np.dot(a,b)，对于多维数组的乘法，可以同样以XXX0.和XXX.0的方法
    对于两个1维数组，是点积，对于两个矩阵，是矩阵乘法，对于1维数组和矩阵，则对1维数组适当地转置，然后进行矩阵乘法，需要满足倒数第一维和倒数第二维相等。
  2. vdot 两个向量的点积，也就是矩阵式对应元素的乘积和
  3. inner 两个数组的内积
  4. matmul 两个数组的矩阵积
  5. determinant 数组的行列式 numpy.linalg.det()
  6. solve 求解线性矩阵方程
  7. inv 寻找矩阵的乘法逆矩阵

Matplotlib
from matplotlib import pyplot as plt

numpy转化数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
In [11]: arr = np.array([1,2,3,4,5])

In [12]: arr
Out[12]: array([1, 2, 3, 4, 5])

# 该命令查看数据类型
In [13]: arr.dtype
Out[13]: dtype('int64')

In [14]: float_arr = arr.astype(np.float64)
# 等价于，即str和data-type是一样的
float_arr = arr.asdtype('float64')
#该命令查看数据类型
In [15]: float_arr.dtype
Out[15]: dtype('float64')

字符串数组转化为数值型

1
2
3
4
5
6
7
8
9
In [4]: numeric_strings = np.array(['1.2','2.3','3.2141'], dtype=np.string_)

In [5]: numeric_strings
Out[5]: array(['1.2', '2.3', '3.2141'], dtype='|S6')

# 此处写的是float 而不是np.float64, Numpy很聪明，会将python类型映射到等价的dtype上
# # 这里的float是Python的数据类型，NumPy会自动的将其映射到等价的dtype上，即np.float64
In [6]: numeric_strings.astype(float)
Out[6]: array([ 1.2, 2.3, 3.2141])

所以astype一共可以接受三种参数

  • 第一种是dtype，即np.int32这种，
  • 第二种是字符串，即’int32’这样，与第一种相呼应，
  • 第三种是Python的数据类型，会自动转化。

numpy中的数据类型转换，不能直接改原数据的dtype! 只能用函数astype()。
[参考链接]https://www.cnblogs.com/hhh5460/p/5129032.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 如果直接修改dtype，会导致长度发生改变
>>> a.dtype = 'float16'
>>> a
array([ -9.58442688e-05,   7.19000000e+02,   2.38159180e-01,
         1.92968750e+00,              nan,  -1.66034698e-03,
        -2.63427734e-01,   1.96875000e+00,  -1.07519531e+00,
        -1.19625000e+02,              nan,   1.97167969e+00,
        -1.60156250e-01,  -7.76290894e-03,   4.07226562e-01,
         1.94824219e+00], dtype=float16)
>>> a.shape
(16,)
>>> a.dtype = 'float16'
>>> a
array([ -9.58442688e-05,   7.19000000e+02,   2.38159180e-01,
         1.92968750e+00,              nan,  -1.66034698e-03,
        -2.63427734e-01,   1.96875000e+00,  -1.07519531e+00,
        -1.19625000e+02,              nan,   1.97167969e+00,
        -1.60156250e-01,  -7.76290894e-03,   4.07226562e-01,
         1.94824219e+00], dtype=float16)
>>> a.shape
(16,)

对于字符串数组还没有找到合理的说明，sad

np.in1d(x,y)

1
2
3
4
5
6
7
8
9
10
11
12
>>> test = np.array([0, 1, 2, 5, 0])
>>> states = [0, 2]
>>> mask = np.in1d(test, states)
>>> mask
array([ True, False,  True, False,  True], dtype=bool)
>>> test[mask]
array([0, 2, 0])
>>> mask = np.in1d(test, states, invert=True)
>>> mask
array([False,  True, False,  True, False], dtype=bool)
>>> test[mask]
array([1, 5])

np.argsort()

1
2
3
4
5
6
7
8
9
10
11
12
13
x = np.array([3, 1, 2])
y = np.argsort(x)
array([1, 2, 0])

In [48]: xx
Out[48]: array([3, 1, 2])

In [49]: yy
Out[49]: array([1, 2, 0])

In [50]: xx[yy]
Out[50]: array([1, 2, 3])

np.setdiff1d()

这种是以集合的方式，会把列表先压平，
@return: sorted 1D array

1
2
3
4
>>> a = np.array([1, 2, 3, 2, 4, 1])
>>> b = np.array([3, 4, 5, 6])
>>> np.setdiff1d(a, b)
array([1, 2])

np.argwhere()

@return: index_array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
>>> x = np.arange(6).reshape(2,3)
>>> x
array([[0, 1, 2],
       [3, 4, 5]])
>>> np.argwhere(x>1)
array([[0, 2],
       [1, 0],
       [1, 1],
       [1, 2]])

In [32]: x[0,2]
Out[32]: 2

In [26]: x[[0,1],[2,0]]
Out[26]: array([2, 3])

In [29]: z = zip([0,1],[2,0])

In [30]: for i in z:
    ...:     print(i)
    ...:     
(0, 2)
(1, 0)

In [53]: x[(0,1),(2,0)]
Out[53]: array([2, 3])

In [73]: z = list(zip(*y))

In [74]: x[z]
Out[74]: array([2, 3, 4, 5])

np.setdiff1d(x,y),intersect1d(x,y)

集合的减法运算,交集运算

np.random.choice(5,3)

1
2
3
a = np.random.choice(5,3)
a
array([0, 3, 2])