Numpy笔记--版本1.16.4

常用小操作

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

arr2 = np.array([[1, 1, 2],
				                 [1, 2, 3],
				                 [2, 3, 3]])
# 矩阵相乘：行 乘 列     注意：行列一致才能相乘
x = np.dot(arr1, arr2)  # 方法1
y = arr1.dot(arr2)      	# 方法2
print(arr1.T)			# 矩阵转置
# 生成3行2列的随机矩阵 标准正态分布随机数
np.random.random(size=(3,2))
# 生成3行2列的随机 整数范围 矩阵
np.random.randint(0,10,size=(3,2))
# 生成3行2列的随机矩阵
np.random.random((3,2))
np.sum(arr1)# 求和
np.min(arr1)# 最小值
np.max(arr1)# 最大值
# 对列求和
np.sum(arr1, axis=0)  # 全部的列
# 对行求和
np.sum(arr1, axis=1)  # 全部的行
# 求矩阵最小值的索引
np.argmin(arr1) # 最小 索引
np.argmax(arr1) # 最大 索引
# 求矩阵平均值的两种方式
np.mean(arr1)    # 方法1
arr1.mean()         # 方法2
np.abs(arr1)  # 函数返回数字的绝对值。
np.median(arr1)  # 求矩阵中位数 奇数有1个中位数 偶数有俩
np.sqrt(arr1)		# 开方
np.sort(arr1)	    # 排序
np.argsort(arr1)    # 索引排序
# 条件索引
a = np.array([2, 4, 6, 8, 10])
a1 = np.where(a > 5)  # 返回值 a1 是满足条件的索引
# 条件变数
p = [[7, 0, 0, 5, 8, 6, 1, 5, 5, 0]]
a = np.clip(p,2,7)  # 小于2 就填2、大于7 就填7、 范围内不变
# 结果：[[7 2 2 5 7 6 2 5 5 2]]
# 取接近的最小整数
a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
np.ceil(a)
结果：[-1. -1. -0.  1.  2.  2.  2.]
# 标准差
a.std()
np. exp(x)   # e的x幂次方
# np转列表
arr1.tolist()
# 压缩维度
l1 = np.asarray([[1, 2, 3]])  # 如果[[1, 2, 3], [4, 5, 6]] 结果就无法压缩了，(2, 3)，只要1是可以被压缩的
l2 = np.squeeze(l1)

print(l1.shape)
print(l2.shape)
#(1, 3)
#(3,)

# 数组 比较 改写需要的
l1 = np.array([[1, 2, -10],
               [4, 5, -6]])

l2 = np.array([[1, 9, -10],
               [4, 5, -6]])

# 它比较两个数组并返回一个新的数组，其中包含按元素的最大值
b1 = np.maximum(l1, l2)
print(b1)
# 每个元素都与0进行比较,如果当前位置大于0,就将当前位置修改为0 当然可以将0换成其他数字
b2 = np.maximum(l1, 0)
print(b2)

保存与读取np文件

import numpy as np

l1 = np.array([[1, 2, -10],
               [4, 5, -6]])

l2 = np.array([[1, 9, -10],
               [4, 5, -6]])

# 存储
# 存储为numpy文件
np.savez('./Data.npz', l1, l2)

# np的索引默认 arr_0 arr_1 arr_3 ...
# 自定义名字 name1,name2
np.savez('./Data.npz', name1=l1, name2=l2)


# 读取
arr = np.load('./Data.npz')

a1 = arr['arr_0']
a2 = arr['arr_1']
print(a1)
print(a2)

# 查看索引名字
with arr as f:
    print(f.files)  # ['arr_0', 'arr_1']

显示完整数组

import numpy as np
np.set_printoptions(threshold=np.inf)

去重排序(小-大)，并变为1维

label_list = np.array([[[1, 2, 3], [6, 5, 4]]])
# 对于一维数组或者列表，np.unique() 函数 去除其中重复的元素
# 并按元素 由小到大 返回一个新的无元素重复的元组或者列表。
print(np.unique(label_list))
# [1 2 3 4 5 6]

生成数组

np_ = np.arange(1, 8, 1)  # 生成数组（起点,终点,步长）
# np数组之间可直接加减乘除、**、%、//取整、矩阵元素都加减乘除
# 注意：列表与字符串相加是合并,相乘是成倍合并.不要混淆

np.zeros((5, 8), dtype='int32')  # 生成（行,列）0数组
# 注意：默认生成的是小数类型，可以单独指定它的数据类型

cry = np.ones((5, 8), dtype='int32')  # 生成1数组
gry0 = np.zeros_like(cry)  # 复制某np数组的格式：维度, 形状, 元素类型
gry1 = np.ones_like(cry)	# 用0补充 或者 用1补充

查看属性

# 普通格式转换np格式
array = np.array([[1, 2, 3, ],
					                  [4, 5, 6],
					                  [7, 8, 9]])
print(array.ndim)  # 维度
print(array.shape)  # 形状
print(array.size)  # 元素总数  注意：len()是数组长度, 无法查看深维度的个数
print(array.dtype)  # 元素类型

print(array[0, 0])  # np取元素		结果都为1
print(array[0][0])  # 列表取元素  	两种都可用
#　切片同理		[0:2,0.:3]

# 修改形状--- shape长宽
np_ = np.arange(1, 8, 1)  # 生成数组（起点,终点,步长）
np_.shape = (2, 4)  # 可直接进行更改维度,注意数量要与维度对的上,否则报错
np_1 = np.arange(1, 9)  # 生成1～8
 np_1.shape = (2, 2, 2)  # 变成3维  （页-行-列）			（页就是面）

# 修改元素类型—dtype
a = array.astype('float64')  # 修改类型 需要定义一个变量接收
.astype(np.uint8)

# 测试日期类型数组  格式必须：'2013-01-01 01:01:01'
f = np.array(['2013-01-01 01:01:01'])
# Y年 M月 D日 h时 m分 s秒     D天  从计算机元年1970-01-01开始算起 
f = f.astype('datetime64')
f = f.astype('datetime64[Y]')

版本过高，去除警告的方法

import warnings
warnings.filterwarnings('ignore')

Numpy的内部基本数据类型

类型名	类型表示符
布尔型	bool_
有符号整数型	int8(-128~127) / int16 / int32 / int64
无符号整数型	uint8(0~255) / uint16 / uint32 / uint64
浮点型	float16 / float32 / float64
复数型	complex64 / complex128
字串型	str_，每个字符用32位Unicode编码表示
日期类型	datetime64
字符串型：1字节=8位
类型字符码

类型	字符码
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]

自定义复合类型

# 自定义复合类型--必须为列表套元组

data = [
    ('zs', [12, 23, 34], 54),
    ('ls', [11, 24, 53], 77),
    ('ww', [12, 23, 63], 15)
]

# 方式一
# [('起名字', '数据类型', '占几位')]
data = np.array(data, dtype=[('name', 'str', 2),
							                             ('score', 'int32', 3),
							                             ('age', 'int32', 1),
							                             ])
print(data[1]['score'])

# 方式二
# 固定键值对  两键固定：名字与数据类型
data = np.array(data, dtype={'names': ['name', 'score', 'age'],
                             'formats': ['U2', '3int32', 'int32']})
print(data[1]['score'])

视图变维

a = np.arange(1, 9)	# [1 2 3 4 5 6 7 8]	 		改维度-生成新数组
b = a.reshape(2, 4)	#视图变维  : b变为2行4列的二维数组   特殊参数 -1 代表自适应
c = b.reshape(2, 2, 2) #视图变维    c变为2页2行2列的三维数组
d = c.ravel()	#视图变维	d变为1维数组

a.shape = (2, 4)			# 直接改变原数组对象的维度，不返回新数组
a.resize(2, 2, 2)

数组掩码

#  布尔掩码
a = np.arange(1, 9)
a1 = a > 3		# 判断      复杂判断   a[a %3 ==0]  需要3的倍数
print(a1)
# 结果：
# [False False False  True  True  True  True  True]
# 复杂条件判断　　在 100内   同时3和7整除的数
res = np.arange(1, 101)
print(res[(res % 3 == 0) & (res % 7 == 0)])

# 索引掩码
res = np.array(['物品1', '物品2', '物品3'])
print(res[[2, 1, 0]])  # 可使用索引

mask = [0, 0, 0, 1, 2, 2, 1, 1, 0, 1, 0]  # 可以使用多个
np.array(mask)    # 注意转格式
print(res[mask])

合并数组

arr1 = np.array([1,2,3])
arr2 = np.array([4,5,6])
arr3 = np.vstack((arr1,arr2))  # 垂直合并
arr4 = np.hstack((arr1,arr2))  # 水平合并
arr5 = np.vstack((arr1,arr2,arr3))  # 垂直或者水平合并多个
arr = np.concatenate((arr1,arr2,arr1))
arr = np.concatenate((arr3,arr5),axis=0)  # 0 竖向合并  注意维度、形状 相同
# 一维度数据，无法转置
arr1_3 = np.atleast_2d(arr1)  # 将里面的数据转化2维 np.atleast_3d 是3维

分割数组

arr1 =  np.arange(12).reshape(3,4)
 # 切分
arr2,arr3 = np.split(arr1,2,axis=1)  # 水平方向分割，分成2份
arr4,arr5,arr6 = np.split(arr1,3,axis=0)  # 垂直方向分割，分成2份
arr7,arr8,arr9 = np.array_split(arr1,3,axis=1)  # 水平分割 3份不等分
arrv1,arrv2,arrv3 = np.vsplit(arr1,3)  # 垂直分割
arrv4,arrv5 = np.hsplit(arr1,2)  # 水平分割

np迭代元素

arr2 = np.arange(2, 14).reshape(3, 4)  # 生成2~13一维数组  .reshape改变形状
for i in arr2:  # 迭代行
    print(i)
for i in arr2.T:  # 迭代列
    print(i)
for i in arr2.flat:  # 每个元素迭代
    print(i)

基础概率分布

连续数据：在一定范围内 ，任意数据----无限可能
离散数据：在一定选项中，任意某个选项----有限选项

# 1..正太分布
# 共有3种大概率  34.2%、13.5%、2.2%   共同99.8%    0.2%异常数据
# 正态分布 	+-1倍、+-2倍、+-3倍  的标准差
# 正态分布--随机  （期望值，上下波动标准差, 生成数量）
np.random.normal(172, 7, 2000)
# 2.二项分布
# n次独立事件的伯努利实验：抛硬币  只有两种可能
# 二项分布的数据（事件重复次数，事件成功概率，生成--这样条件下的测试结果--的个数）   
x = np.random.binomial(10, 0.3, 100)
# 求某种结果的概率  某结果在整个结果数据中的占比
x1 = x[x == 1].size / x.size
# 超几何分布
# (需要的，需要以外的--其他的，目前取数，生成--这样条件下的测试结果--的个数  也就是执行次数)
x = np.random.hypergeometric(6, 4, 3, 1000)