Numpy API整理大全
文章目录
ndarray数组
用np.ndarray类的对象表示n维数组
import numpy as np
ary = np.array([1, 2, 3, 4, 5, 6])
print(type(ary))
ndarray数组对象的创建
np.array(任何可被解释为Numpy数组的逻辑结构)
import numpy as np
a = np.array([1, 2, 3, 4, 5, 6])
print(a)
np.arange(起始值(0),终止值,步长(1))
import numpy as np
a = np.arange(0, 5, 1)
print(a)
b = np.arange(0, 10, 2)
print(b)
np.zeros(数组元素个数, dtype=‘类型’（整数的还是浮点数，还可以是布尔型）)
import numpy as np
a = np.zeros(10)
print(a)
out：[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
np.ones(数组元素个数, dtype=‘类型’)
import numpy as np
a = np.ones((2,3))
print(a)
out： [[1. 1. 1.]
[1. 1. 1.]]
np.zeros_like(数组)
用零填充这个数组
import numpy as np
a = [[1. 1. 1.]
[1. 1. 1.]]
b = np.zeros_like(a)
print(a)
np.ones_like(数组)
用一填充这个数组
import numpy as np
a = [[1. 1. 1.]
[1. 1. 1.]]
b = np.ones_like(a)
1. ndarray对象属性的基本操作
数组的维度：
np.ndarray.shape
import numpy as np
ary = np.array([1, 2, 3, 4, 5, 6])
print(type(ary), ary, ary.shape)
ary.shape = (2,3) # 将数组的维度改为两行三列
#二维数组
ary = np.array([
[1,2,3,4],
[5,6,7,8]
])
print(type(ary), ary, ary.shape)
out：
<class 'numpy.ndarray'> [1 2 3 4 5 6] (6,)
<class 'numpy.ndarray'> [[1 2 3 4]
[5 6 7 8]] (2, 4)
元素的类型
np.ndarray.dtype
错误的修改数据类型的方法
a.dtype = 'float32'
这样强制转化会导致数字错误
正确的修改数据类型的方法：
import numpy as np
ary = np.array([1, 2, 3, 4, 5, 6])
print(type(ary), ary, ary.dtype)
#转换ary元素的类型
b = ary.astype(float)
print(type(b), b, b.dtype)
#转换ary元素的类型
c = ary.astype(str)
print(type(c), c, c.dtype)
注： a.astype(float) 这样a并没有变化，想要得到转换后的数组应该用另一个变量去保存他
数组元素的个数：
np.ndarray.size
import numpy as np
ary = np.array([
[1,2,3,4],
[5,6,7,8]
])
#观察维度，size，len的区别
print(ary.shape, ary.size, len(ary))
数组元素索引(下标)
数组对象[..., 页号, 行号, 列号]
下标从0开始，到数组len-1结束。
import numpy as np
a = np.array([[[1, 2],
[3, 4]],
[[5, 6],
[7, 8]]])
print(a, a.shape)
print(a[0])
print(a[0][0])
print(a[0][0][0])
print(a[0, 1, 0]) # 第0行第1列第0个元素
for i in range(a.shape[0]):
for j in range(a.shape[1]):
for k in range(a.shape[2]):
print(a[i, j, k])
2. ndarray对象属性操作详解
Numpy的内部基本数据类型
| 类型名 | 类型表示符 |
|---|---|
| 布尔型 | bool_ |
| 有符号整数型 | int8(-128~127)/int16/int32/int64 |
| 无符号整数型 | uint8(0~255)/uint16/uint32/uint64 |
| 浮点型 | float16/float32/float64 |
| 复数型 | complex64/complex128 |
| 字串型 | str_，每个字符用32位Unicode编码表示 |
自定义复合类型
为什么要自定义复合类型？
因为numpy是同质数组，所以如果有复杂数据类型的时候就不能将其全部放在数组当中。
当有些数据类型比较复杂的时候就把这些数据包装成一个整体，然后就数据存储到这个整体当中，就类似于面向对象的思想，把一个整体当中的数据类型封装一下放到一个元组中当成一个对象来看待
# 自定义复合类型
import numpy as np
data=[
('zs', [90, 80, 85], 15),
('ls', [92, 81, 83], 16),
('ww', [95, 85, 95], 15)
]
#第一种设置dtype的方式
a = np.array(data, dtype='U3, 3int32, int32')
print(a)
print(a[0]['f0'], ":", a[1]['f1'])
print("=====================================")
#第二种设置dtype的方式，给没种数据其个名字。
#可以通过名字来访问
b = np.array(data, dtype=[('name', 'str_', 2),
('scores', 'int32', 3),
('ages', 'int32', 1)])
print(b[0]['name'], ":", b[0]['scores'])
print("=====================================")
#第三种设置dtype的方式
c = np.array(data, dtype={'names': ['name', 'scores', 'ages'],
'formats': ['U3', '3int32', 'int32']})
print(c[0]['name'], ":", c[0]['scores'], ":", c.itemsize)
print("=====================================")
#第四种设置dtype的方式
d = np.array(data, dtype={'names': ('U3', 0),
'scores': ('3i4', 16),
'ages': ('i4', 28)})
print(d[0]['names'], d[0]['scores'], d.itemsize)
# 字符类型后面的数字是输出字段时的字节偏移量
print("=====================================")
#第五种设置dtype的方式
e = np.array([0x1234, 0x5667],
dtype=('u2', {'lowc': ('u1', 0),
'hignc': ('u1', 1)}))
print('%x' % e[0])
print('%x %x' % (e['lowc'][0], e['hignc'][0]))
print("=====================================")
#测试日期类型数组
f = np.array(['2011', '2012-01-01', '2013-01-01 01:01:01','2011-02-01'])
# 转换数据类型 D天 s秒 （精确到）
f = f.astype('M8[D]')
print(f)
f = f.astype('int32')
print(f)
print(f[3]-f[0])
out:
['2011-01-01' '2012-01-01' '2013-01-01' '2011-02-01']
[14975 15340 15706 15006]
31
print("=====================================")
a = np.array([[1 + 1j, 2 + 4j, 3 + 7j],
[4 + 2j, 5 + 5j, 6 + 8j],
[7 + 3j, 8 + 6j, 9 + 9j]])
print(a.T)
for x in a.flat:
print(x.imag)
类型字符码
| 类型 | 字符码 |
|---|---|
| np.bool_ | ? |
| np.int8/16/32/64 | i1/i2/i4/i8 |
| np.uint8/16/32/64 | u1/u2/u4/u8 |
| np.float/16/32/64 | f2/f4/f8 |
| np.complex64/128 | c8/c16 |
| np.str_ | U<字符数> |
| np.datetime64 | M8[Y] M8[M] M8[D] M8[h] M8[m] M8[s] |
字节序前缀，用于多字节整数和字符串：
</>/[=]分别表示小端/大端/硬件字节序。
类型字符码格式
<字节序前缀><维度><类型><字节数或字符数>
| 3i4 | 释义 |
|---|---|
| 3i4 | 大端字节序，3个元素的一维数组，每个元素都是整型，每个整型元素占4个字节。 |
| <(2,3)u8 | 小端字节序，6个元素2行3列的二维数组，每个元素都是无符号整型，每个无符号整型元素占8个字节。 |
| U7 | 包含7个字符的Unicode字符串，每个字符占4个字节，采用默认字节序。 |
3. ndarray数组对象的维度操作
视图变维（数据共享）： reshape() 与 ravel()
掉这个方法得到的数组和原数组用的数据是同一份
reshape()可以得到原数组的任意维度（前提是可以进行维度变换），rave1（）就相当于把数组撑平
import numpy as np
a = np.arange(1, 9)
print(a) # [1 2 3 4 5 6 7 8]
b = a.reshape(2, 4) #视图变维 : 变为2行4列的二维数组
print(b)
c = b.reshape(2, 2, 2) #视图变维 变为2页2行2列的三维数组
print(c)
d = c.ravel() #视图变维 变为1维数组
print(d)
复制变维（数据独立）：flatten()
e = c.flatten()
print(e)
a += 10
print(a, e, sep='\n') # a变了 e还是e
就地变维：直接改变原数组对象的维度，不返回新数组
不需要新赋值，就是改变原有数组的维度
a.shape = (2, 4)
print(a)
a.resize(2, 2, 2)
print(a)
4. ndarray数组切片操作
#数组对象切片的参数设置与列表切面参数类似
# 步长+：默认切从首到尾
# 步长-：默认切从尾到首
数组对象[起始位置:终止位置:步长, ...]
#默认位置步长：1
一维数组的切片操作
import numpy as np
a = np.arange(1, 10)
print(a) # 1 2 3 4 5 6 7 8 9
print(a[:3]) # 1 2 3
print(a[3:6]) # 4 5 6
print(a[6:]) # 7 8 9
print(a[::-1]) # 9 8 7 6 5 4 3 2 1
print(a[:-4:-1]) # 9 8 7
print(a[-4:-7:-1]) # 6 5 4
print(a[-7::-1]) # 3 2 1
print(a[::]) # 1 2 3 4 5 6 7 8 9
print(a[:]) # 1 2 3 4 5 6 7 8 9
print(a[::3]) # 1 4 7
print(a[1::3]) # 2 5 8
print(a[2::3]) # 3 6 9
多维数组的切片操作
import numpy as np
a = np.arange(1, 28)
a.resize(3,3,3)
print(a)
#切出1页
print(a[1, :, :])
#切出所有页的1行
print(a[:, 1, :])
#切出0页的1行1列
print(a[0, :, 1])
5. ndarray数组的掩码操作
import numpy as np
a = np.arange(1, 10)
mask = [True, False,True, False,True, False,True, False,True]
print(a[mask]) # [1 3 5 7 9]
运用： 求100以内3的倍数
import numpy as np
a = np.arange(1, 100)
# 输出100以内3的倍数
print(a[a % 3 == 0])
运用： 得到即是3 又是7的倍数的数
注：不能用and 要用&
import numpy as np
a = np.arange(1, 100)
# 输出100以内即是3又是7的倍数
mask = (a % 3 == 0) & (a% 7 == 0)
print(a[mask])
6. 多维数组的组合与拆分
垂直方向操作：
import numpy as np
a = np.arange(1, 7).reshape(2, 3)
b = np.arange(7, 13).reshape(2, 3)
# 垂直方向完成组合操作，生成新数组
c = np.vstack((a, b))
# 垂直方向完成拆分操作，生成两个数组
d, e = np.vsplit(c, 2)
水平方向操作：
import numpy as np
a = np.arange(1, 7).reshape(2, 3)
b = np.arange(7, 13).reshape(2, 3)
# 水平方向完成组合操作，生成新数组
c = np.hstack((a, b))
# 水平方向完成拆分操作，生成两个数组
d, e = np.hsplit(c, 2)
深度方向操作：（3维）
import numpy as np
a = np.arange(1, 7).reshape(2, 3)
b = np.arange(7, 13).reshape(2, 3)
# 深度方向（3维）完成组合操作，生成新数组
i = np.dstack((a, b))
# 深度方向（3维）完成拆分操作，生成两个数组
k, l = np.dsplit(i, 2)
多维数组组合与拆分的相关函数：
# 通过axis作为关键字参数指定组合的方向，取值如下：
# 若待组合的数组都是二维数组：
# 0: 垂直方向组合
# 1: 水平方向组合
# 若待组合的数组都是三维数组：
# 0: 垂直方向组合
# 1: 水平方向组合
# 2: 深度方向组合
np.concatenate((a, b), axis=0)
# 通过给出的数组与要拆分的份数，按照某个方向进行拆分，axis的取值同上
np.split(c, 2, axis=0)
长度不等的数组组合：
import numpy as np
a = np.array([1,2,3,4,5])
b = np.array([1,2,3,4])
# 填充b数组使其长度与a相同, 头部补0个元素，尾部补1个元素
b = np.pad(b, pad_width=(0, 1), mode='constant', constant_values=-1)
print(b)
# 垂直方向完成组合操作，生成新数组
c = np.vstack((a, b))
print(c)
简单的一维数组组合方案
a = np.arange(1,9) #[1, 2, 3, 4, 5, 6, 7, 8]
b = np.arange(9,17) #[9,10,11,12,13,14,15,16]
#把两个数组摞在一起成两行
c = np.row_stack((a, b))
print(c)
#把两个数组组合在一起成两列
d = np.column_stack((a, b))
print(d)
7. ndarray类的其他属性
- shape - 维度
- dtype - 元素类型
- size - 元素数量
- ndim - 维数，len(shape)
- itemsize - 元素字节数
- nbytes - 总字节数 = size x itemsize
- real - 复数数组的实部数组
- imag - 复数数组的虚部数组
- T - 数组对象的转置视图
- flat - 扁平迭代器
import numpy as np
a = np.array([[1 + 1j, 2 + 4j, 3 + 7j],
[4 + 2j, 5 + 5j, 6 + 8j],
[7 + 3j, 8 + 6j, 9 + 9j]])
print(a.shape)
print(a.dtype)
print(a.ndim)
print(a.size)
print(a.itemsize)
print(a.nbytes)
print(a.real, a.imag, sep='\n')
print(a.T)
print([elem for elem in a.flat])
b = a.tolist()
print(b)
8. 矢量化
矢量化指的是用数组代替标量来操作数组里的每个元素。
numpy提供了vectorize函数，可以把处理标量的函数矢量化，返回的函数可以直接处理ndarray数组。
import math as m
import numpy as np
def foo(x, y):
return m.sqrt(x**2 + y**2)
x, y = 1, 4
print(foo(x, y))
X, Y = np.array([1, 2, 3]), np.array([4, 5, 6])
vectorized_foo = np.vectorize(foo)
print(vectorized_foo(X, Y))
print(np.vectorize(foo)(X, Y))
numpy还提供了frompyfunc函数，也可以完成与vectorize相同的功能：
# 把foo转换成矢量函数，该矢量函数接收2个参数，返回一个结果
fun = np.frompyfunc(foo, 2, 1)
fun(X, Y)
案例：定义一种买进卖出策略，通过历史数据判断这种策略是否值得实施。
dates, opening_prices, highest_prices, \
lowest_prices, closing_prices = np.loadtxt(
'../../data/bhp.csv', delimiter=',',
usecols=(1, 3, 4, 5, 6), unpack=True,
dtype='M8[D], f8, f8, f8, f8',
converters={1: dmy2ymd})
# 定义一种投资策略
def profit(opening_price, highest_price,
lowest_price, closing_price):
buying_price = opening_price * 0.99
if lowest_price <= buying_price <= highest_price:
return (closing_price - buying_price) * \
100 / buying_price
return np.nan # 无效值
# 矢量化投资函数
profits = np.vectorize(profit)(opening_prices,
highest_prices, lowest_prices, closing_prices)
nan = np.isnan(profits)
dates, profits = dates[~nan], profits[~nan]
gain_dates, gain_profits = dates[profits > 0], profits[profits > 0]
loss_dates, loss_profits = dates[profits < 0], profits[profits < 0]
mp.figure('Trading Simulation', facecolor='lightgray')
mp.title('Trading Simulation', fontsize=20)
mp.xlabel('Date', fontsize=14)
mp.ylabel('Profit', fontsize=14)
ax = mp.gca()
ax.xaxis.set_major_locator(md.WeekdayLocator(byweekday=md.MO))
ax.xaxis.set_minor_locator(md.DayLocator())
ax.xaxis.set_major_formatter(md.DateFormatter('%d %b %Y'))
mp.tick_params(labelsize=10)
mp.grid(linestyle=':')
if dates.size > 0:
dates = dates.astype(md.datetime.datetime)
mp.plot(dates, profits, c='gray',
label='Profit')
mp.axhline(y=profits.mean(), linestyle='--',
color='gray')
if gain_dates.size > 0:
gain_dates = gain_dates.astype(md.datetime.datetime)
mp.plot(gain_dates, gain_profits, 'o',
c='orangered', label='Gain Profit')
mp.axhline(y=gain_profits.mean(), linestyle='--',
color='orangered')
if loss_dates.size > 0:
loss_dates = loss_dates.astype(md.datetime.datetime)
mp.plot(loss_dates, loss_profits, 'o',
c='limegreen', label='Loss Profit')
mp.axhline(y=loss_profits.mean(), linestyle='--',
color='limegreen')
mp.legend()
mp.gcf().autofmt_xdate()
mp.show()
9. 加载文件
numpy提供了函数用于加载逻辑上可被解释为二维数组的文本文件，格式如下：
数据项1 <分隔符> 数据项2 <分隔符> ... <分隔符> 数据项n
例如：
AA,AA,AA,AA,AA
BB,BB,BB,BB,BB
...
或：
AA:AA:AA:AA:AA
BB:BB:BB:BB:BB
...
调用numpy.loadtxt()函数可以直接读取该文件并且获取ndarray数组对象：
import numpy as np
# 直接读取该文件并且获取ndarray数组对象
# 返回值：
# unpack=False：返回一个二维数组
# unpack=True： 多个一维数组
np.loadtxt(
'../aapl.csv', # 文件路径
delimiter=',', # 分隔符
usecols=(1, 3), # 读取1、3两列 （下标从0开始）
unpack=False, # 是否按列拆包
dtype='U10, f8', # 制定返回每一列数组中元素的类型
converters={1:func} # 转换器函数字典
)
3781
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
