python 中的numpy_python中的numpy简介（详细）,之,入门

何为numpy

numpy是python里面专门用于处理高维数据计算的包，十分的方便！

具体来说，numpy可以说是数据分析领域的基础数组。底层实现中使用了

C语言和Fortran语言的机制分配内存

。可以理解它的输出是一个

非常大且连续的并由同类型的数据组成的内存区域

。

作用：可以构造一个比普通列表大的多的数组，并且可以很灵活的对其中所有的元素进行并行化操作。

我个人认为学习任何一个模块之前，我们必须先对它有一个整体的框架性的认识，在逐步的去了解每一个细小的东西。有了一开始高屋建瓴的认知，后面学起来将会轻松顺畅很多。

numpy入门

初始化操作

大概有以下三种方法。 普通法，定点定隔法，一步到位法。

# 普通法

a = [1, 3, 5, 7, 9]

a = np.array(a)

# 定点定间隔法

## 定隔的 arange：固定元素大小间隔 arange(start , stop , step)

## 其中 stop 必须要有，start 和 step 没有的话默认为 1。

np.arange(2,8,2)

## 定点的 linspace：固定元素个数 linspace (start , stop , num)

## 其中 start 和 stop 必须要有，num 没有的话默认为 50。

np.linspace(0,2,10) # 在0到2之间生成等间隔的10个元素序列

# 一步到位法（用于生成特殊的numpy数组）

b = np.zeros(100, dtype = float) # 生成100个0

d = np.ones((3, 3)) #生成 3*3数组，元素都是1

c = np.empty((2,4, 4)) # 生成三维数组，其中元素随机

e = np.full((3, 3), 3.14) # 以指定值3.14填满数组

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

np.random.randint(2,5,(6,6)) # 生成一个6*6矩阵，矩阵的每个元素2到5

np.eye(3) # 3维的单位矩阵

### 以上每一个还有与之对应的like方法

np.empty_like(a)

np.ones_like(a)

# range用法和np.arrange用法对比(知道歩长)

# list(range(0, 10, 2)) 从0到10以2为步长生成元素，不包括10

# np.arrange(0, 10, 2)

# np.linspace() （不知道歩长）

# np.linspace(0, 3, 100) 从0到3以等步长生成100个数，包括3

广播机制（与列表的区别）

numpy数组对普通列表的操作方式是不同的，numpy使用的是一种广播机制作用于每一个元素，而普通列表作用于整体。

而numpy这种方法使得它的效率得到了

几个数量级

的提升。

import numpy as np

normal_list = range(10000)

# %time可以测量一行代码执行的时间

# %timeit可以测量一行代码多次执行的时间 从中选取最快的三次

print("普通的列表：")

%timeit [i**2 for i in normal_list]

print("numpy数组：")

np_list = np.arange(10000)

%timeit np_list**2

# 普通列表作用于整体

normal_list2 = list(range(10))

print(normal_list2*2)

np_array = np.arange(10)

np_array*2

输出：

普通的列表：

4.18 ms ± 687 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

numpy数组：

9.97 µs ± 1.03 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)

[range(0, 10), range(0, 10)]

索引选取与切片

切片得到的是原数组的一个视图 (view) ，修改切片中的内容会改变原数组

索引得到的是原数组的一个复制 (copy)，修改索引中的内容不会改变原数组

# 简单索引略(与其他语言类似）

# 花式索引

## 假设你想按特定顺序来获取第 5, 4 和 7 行时

arr[ [4,3,6] ]

## 假设你想按特定顺序来获取倒数第 4, 3 和 6 行时

arr[ [-4,-3,-6] ]

stock_cnt = 200

view_days = 504

# 正态分布的数据

stock_day_change = np.random.standard_normal((stock_cnt, view_days))

print(stock_day_change.shape)

# 切片操作 记住 Python 切片包头不包尾

print(stock_day_change[:2, :5])

print(stock_day_change[-2:, -5:])

# 交换两组数据，注意copy的使用

tmp = stock_day_change[:2, :5].copy()

# 这里如果不使用copy，就不会达到复制的效果，仅仅是引用。并没有生成新的对象，

#tmp和stock_day_change指向同一个对象，所以一旦stock_day_change改变，tmp也会跟着改变

# numpy里面的机制全部都是引用

stock_day_change[:2,:5] = stock_day_change[-2:, -5:]

stock_day_change[-2:, -5:] = tmp

# 此操作不行 stock_day_change[:2,:5], stock_day_change[-2:, -5:] = stock_day_change[-2:, -5:], stock_day_change[:2,:5]

# 举个简单的例子

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

b = np.array([2,3,4,5,6])

a, b = b, a # TRUE 操作可行

a[2:4], b[3:5] = b[3:5], a[2:4] #FALSE 操作不可行

数据转换与规整

可以使用astype(int)改变数据的类型和np.around()函数保留指定小数位。

np_ar = np.linspace(0,10,20).reshape(4,5)

np_a = np_ar[:,:2].astype(int)

# 原数组， 切片加astype， 保留两位小数

np_ar, np_a, np.around(np_ar,2)

(array([[ 0. , 0.52631579, 1.05263158, 1.57894737, 2.10526316],

[ 2.63157895, 3.15789474, 3.68421053, 4.21052632, 4.73684211],

[ 5.26315789, 5.78947368, 6.31578947, 6.84210526, 7.36842105],

[ 7.89473684, 8.42105263, 8.94736842, 9.47368421, 10. ]]),

array([[0, 0],

[2, 3],

[5, 5],

[7, 8]]),

array([[ 0. , 0.53, 1.05, 1.58, 2.11],

[ 2.63, 3.16, 3.68, 4.21, 4.74],

[ 5.26, 5.79, 6.32, 6.84, 7.37],

[ 7.89, 8.42, 8.95, 9.47, 10. ]]))

逻辑条件下的筛选

下面的筛选方法挺重要

np_arr = np.linspace(0,1,20).reshape(4,5)

mask = np_arr>0.5 # 会返回一个ture，false数组

np_arr1 = np_arr[mask] # 利用上面的数组找出true所在的值

print(mask)

print(np_arr1)

np_arr2 = np_arr[np_arr>0.5] # 一步完成上述两个步骤

print(np_arr2)

# 加入| & 的多重选择

np_arr3 = np_arr[(np_arr>0.5) & (np_arr<0.7)]

np_arr3

[[False False False False False]

[False False False False False]

[ True True True True True]

[ True True True True True]]

[0.52631579 0.57894737 0.63157895 0.68421053 0.73684211 0.78947368

0.84210526 0.89473684 0.94736842 1. ]

[0.52631579 0.57894737 0.63157895 0.68421053 0.73684211 0.78947368

0.84210526 0.89473684 0.94736842 1. ]

array([0.52631579, 0.57894737, 0.63157895, 0.68421053])

通用序列函数

# np.all() 判断序列中是否所有的元素均为true 即对bool序列进行操作。

# np.any() 判断序列中是否有元素为true

a = np.arange(6)*2

b = np.arange(6)+3

# 最大最小

print("两个序列中小的那个是：", np.minimum(a, b))

print("两个序列中大的那个是：", np.maximum(a, b))

# np.unique() 序列中数值唯一且不重复的值组成新的序列

# np.diff() axis = 0, axis = 1 通过轴向来操作， 将前后两个数值做减法运算

两个序列中小的那个是： [0 2 4 6 7 8]

两个序列中大的那个是： [ 3 4 5 6 8 10]

数据本地序列化操作

可以通过np.save()等方法将numpy数组保存在本地。具体方法如下：

np.save('filename', np_array)#保存为npz文件

np.savez( 'filename', np_array1, np_array2) #保存为npz文件

np.savetxt() #保存为txt文件

# 还可以保存为其他例如csv等格式

test_load = np.load('filename.npy')

np.loadtxt('filename.txt')

最后，有问题欢迎评论或者私信！