Python_Numpy学习

Numpy学习

N维数组对象ndarray

ndarray 数组与  列表均可以表示多维数据，区别在于 使用ndarray进行数据运算时可以不使用循环（使用list进行矩阵操作时要使用循环）

数组的生成：

 

# 创建数组可以指定数据类型，如果不指定就默认
a = np.arange(10)
print(a)
b = np.ones((3, 6))
print(b)
c = np.zeros((3, 6), dtype=np.int32)
print(c)

 

np.ones_like(a) 根据数组a的形状生成一个全一数组

np.zeros_like(a) 根据数组a 生成一个全0数组

np.full_like(a, val) 根据数组a 生成一个数组，每一个元素值都是val

 

np.linsapce() 根据起止数据等间距的填充数据，形成数组

np.concatenate() 将两个或多个数组合并成一个新的数组

# a = np.linspace(1, 10, 4)  # 第一个为起始，第二个为终止，第三个数是划分的元素个数
# print(a)
# b = np.linspace(1, 10, 4, endpoint=False)
# print(b)
# c = np.concatenate((a, b))  # 合并数组
# print(c)

 

 

 

import numpy as np

# # 生成指定维度的随机多维数组
# data = np.random.rand(2, 3)
# print(data)
# print(type(data))

# # list 转化为ndarray
# l = range(10)
# data = np.array(l)
# print(data)
# print(data.shape)
# print(data.ndim)
# print(type(data))

# # 嵌套序列转化为ndarray
# l2 = [range(10), range(10)]
# data = np.array(l2)
# print(data)
# print(data.shape)

# np.zeros, np.ones, 和 np.empty

# np.zeros
zeros_arr = np.zeros((3, 4))

# np.ones
ones_arr = np.ones((2, 3))

#np.empty
empty_arr = np.empty((3, 3))

# np.empty 指定数据类型
empty_int_arr = np.empty((3, 3), int)

print(zeros_arr)
print("---------------")
print(ones_arr)
print("---------------")
print(empty_arr)
print("---------------")
print(empty_int_arr)

 

ndarray数组的变换

可以进行维度变换和元素类型变换

.reshape(shape) 不改变数组元素，返回一个shape形状的数组，原数组不变

.resize(shape) 与.reshape()功能一致，但要修改原数组

.swapaxes(ax1, ax2) 将数组n个维度中两个维度进行调换

.flatten() 对数组进行降维，返回折叠后的一维数组，原数组不变

# # 维度变换
# # .reshape
# a = np.ones((2, 3, 4), dtype=np.int32)
# print(a.reshape((3, 8)))
# print("-----------------")
# print(a)  # a还是（2, 3, 4）维度

# # .resize
# a = np.ones((2, 3, 4), dtype=np.int32)
# a.resize((3, 8))
# print(a)  # 已经修改了a 的维度

# # .flatten()   将数组变为一维,不改变原数组维度
# a = np.ones((2, 3, 4), dtype=np.int32)
# print(a.flatten())
# print("-------------------")
# print(a)

 

数组类型变换：

将整数变为浮点数 astype（）方法一定会创建一个新数组（拷贝）

# # 数组类型转换
# a = np.ones((2, 3, 4), dtype=np.int)
# b = a.astype(np.float)
# print(a)
# print("---------------")
# print(b)

 

ndarray数组想列表的转换

ls = a.tolist()

# # 数组向列表转化
# a = np.full((2, 3, 4), 25, dtype=np.int32)
# print(a)
# print("--------------------------")
# print(a.tolist())

 

 

 

 

矩阵运算与处理：

"""
"""
# # 矢量与矢量运算
# arr = np.array([[1, 2, 3],
#                [4, 5, 6]])
# print("元素相乘：")
# print(arr * arr)
#
# print("矩阵相加：")
# print(arr + arr)
# # 矢量与标量运算        点乘与点除
# print(1. / arr)
# print(2. * arr)

"""索引与切片    一维数组的索引与Python列表索引功能相似
                多维数组索引
                arr[r1:r2, c1:c2]  --->代表从矩阵切片范围（与MATLAB处理相似）
                [:]  --->代表某个维度的数据
                [r1:, :c1]--->
注意：所有的索引值都是从 0 开始（与MATLAB相区别）
"""
# 索引与切片
# 一维数组
arr1 = np.arange(10)
print(arr1)
print(arr1[2:5:2])  # 数字依次为起始编号：终止编号：步长
# 多维数组
arr2 = np.arange(12).reshape(3, 4)
print(arr2)
print(arr2[1])
print(arr2[0:2, 2:])
print(arr2[:, 1:3])

 

条件索引：

注意：多个条件组合使用时使用&  |  表示 和  或

 

# 条件索引
# 找出data_arr 中2015年后的数据
data_arr = np.random.rand(3, 3)
print(data_arr)
print("")

year_arr = np.array([[2000, 2001, 2000],
                     [2005, 2002, 2009],
                     [2001, 2003, 2010]])
# 两个矩阵维数相同，数据也依次对应，现在筛选出年份大于2005的数据
filter_arr = data_arr[year_arr >=2005]
print(filter_arr)
print("")

# 多个条件
filter_arr = data_arr[(year_arr <= 2005) & (year_arr % 2 == 0)]
print(filter_arr)

 

转置（transpose）

高维数组转置要指定编号（0， 1，2 ，3）

# 转置
arr = np.random.rand(2, 3)
print(arr)
print(arr.transpose())
print("")
# 三维数组
arr3d = np.random.rand(2, 3, 4)
print(arr3d)
print("-------")
print(arr3d.transpose((1, 0, 2)))

 

 

通用函数 ：

ceil   向上最接近的整数

floor  向下最接近的整数

rint   四舍五入

isnan  判断元素是否为NaN

multiply   元素相乘

divide   元素相除

# 通用函数
arr = np.random.randn(2, 3)
print(arr)
print(np.ceil(arr))
print(np.floor(arr))
print(np.rint(arr))
print(np.isnan(arr))

 

np.where

矢量版本的三元表达式  x if condition else y

使用np.where np.where(condition, x, y)

# np.where
arr = np.random.randn(3, 4)
print(arr)
print(np.where(arr > 0, 1, -1))  # 如果arr大于0 输出1，否则输出-1

 

常用的统计方法

np.mean , np.sum

np.max , np.min

np.std , np.var

np.argmax , np.argmin

np.cumsum , np.cumprod

# 数组与标量之间的运算
a = np.arange(14).reshape(2, 7)
print(a.mean())

 

注意：多维的话要指定维度，否则默认是在全部维度上做统计

# 求和
arr = np.arange(10).reshape(5, 2)
print(arr)
print(np.sum(arr))
print(np.sum(arr, axis=0))  # axis=0是指竖直方向的一列
print(np.sum(arr, axis=1))  # axis=1是指横向的一行

 

ndarray中元素级运算：

np.abs(x)  np.fabs()    计算各元素绝对值

np.sqrt(x)   计算数组各元素平方根

np.square(x) 计算数组各元素的平方

 

 np.log(x)  np.log10(x)   np.log2(x)   计算各数组的自然对数、10为底对数、2底对数

 

np.ceil(x)  np.floor(x)     计算数组各元素ceiling值（不超过元素的整数值）或floor值（小于元素的最大整数值）

np.rint(x)  计算各元素的四舍五入值

np.modf(x)  将数组各元素的小数和整数部分以两个独立数组形式返回

np.cos(x)  np.cosh(x)  计算数组各元素的普通型和双曲型三角函数

np.sin(x)  np.sinh(x)  

np.tan(x)  np.tanh(x)

np.exp(x)   计算数组各元素的指数值

np.sign(x)   计算数组各元素的符号值，1（+），0（0），-1（-）正数输出1.。。。。

 

 

 

 

 

 

np.all和np.any

all  全部满足条件

any  至少有一个元素满足条件

# np.all 和np.any
arr = np.random.randn(2, 3)
print(arr)
print(np.all(arr > 0))
print(np.any(arr > 0))

 

np.unique  找到唯一值并返回排序结果

# np.unique
arr = np.array([[1, 2, 1], [2, 3, 4]])
print(arr)
print(np.unique(arr))

 

文件存取

csv文件

说明：CSV文件只能存取一维二维数组

CSV（逗号分隔值）一种常见文件格式，用于批量处理数据。

 

文件写入CSV格式：

np.savetxt(frame,array,fmt=’.18e’,delimiter=None)

frame  文件、字符串或产生器，可以是.gz或者.bz2的压缩文件。

array   存入文件的数组

fmt     写入文件的格式，例如：%d%.2f%.18e

delimiter   分隔字符串，默认是任何空格

 

CSV文件读入：

np.loadtxt(frame,dtype=np.float,delimiter=None,unpack=Flase)

frame  文件、字符串或产生器，可以是.gz或者.bz2的压缩文件。

dtype   数据类型，可选

delimiter   分隔字符串，默认是任何空格

unpack    如果True，读入属性将分别写入不同变量

 

# 存入CSV文件
a = np.arange(100).reshape(5, 20)
print(a)
print("-----------------------------")
np.savetxt("a.csv", a, fmt="%d", delimiter=",")  # 自动写入项目中

# 读入CSV文件
b = np.loadtxt("a.csv",dtype=np.int, delimiter=",")
print(b)

 

多维数据的存取

写入：

a. tofile(frame, sep=””, formate”%s”)

frame  文件、字符串

sep    数据分隔字符串，如果是空格，写入文件为二进制

format  写入数据格式

 

读出：

注意：使用该方法读取时需要知道存入文件时数组维度和元素类型

np.fromfile(frame, dtype=float, count=-1, sep=””)

frame  文件、字符串

dtype  读取的数据类型

count   读入元素个数，-1表示读入整个文件

sep    数据分隔字符串，如果是空格，写入文件为二进制

# 多维数据的存取
# 存入
a = np.arange(100).reshape(5, 10, 2)
a.tofile("b.dat", sep=",", format="%d")  # 如果没有sep=","则数据存为二进制文件（可以作为文件备份方式）
# 读出（文本文件）
c = np.fromfile("b.dat", dtype=np.int, count=-1, sep=",")
print(c)
c = np.fromfile("b.dat", dtype=np.int, count=-1, sep=",").reshape(5, 10, 2)
print(c)
# 读出（二进制文件）
a = np.arange(100).reshape(5, 10, 2)
a.tofile("b.dat",  format="%d")  # 文件为二进制格式，无法读出
c = np.fromfile("b.dat", dtype=np.int).reshape(5, 10, 2)  # 修改为文件格式
print(c)

 

NumPy的便捷文件存取：

存入：

np.save(fname, array) 或np.savez(fname, array)

frame:  文件名，以.npy为扩展名，压缩扩展名为.npz

array: 数组变量

读取：

np.load(fname)

frame:文件名，以.npy为扩展名，压缩扩展名为.npz

# NumPy的便捷文件存取
a = np.arange(100).reshape(5, 10, 2)
np.save("ahhh.npy", a)  # 保存格式也是二进制格式，不过在二进制文件开头有数组保存之前的原信息（包括维度，数据类型）
b = np.load("ahhh.npy")
print(b)

 

Numpy的随机数函数字库

随机数生成：

NumPyd的random字库(np.random.*)

rand(d0, d1, ...,dn) 根据d0-dn创建随机数数组，浮点数，在【0,1】之间产生并均匀分布

randn(d0,d1,d2...dn) 根据d0-dn创建随机数数组，标准正态分布

randint(low[,high,shape]) 根据shape创建随机数或整数数组，范围是【low，high）

seed(s) 随机数种子，s是给定的种子值

import numpy as np
# rand  [0, 1]随机数
a = np.random.rand(3, 4, 5)
print(a)
# randn  生成正态分布随机数
sn = np.random.randn(3, 4, 5)
print(sn)
# rindint根据shape创建随机数或整数数组
b = np.random.randint(100, 200, (3, 4))
print(b)
# seed(s)  随机数种子，s是给定的种子值
np.random.seed(10)  # 调用同一个随机数种子。产生的随机数相同
print(np.random.randint(100, 200, (3, 4)))
print("-------------------------------------")
np.random.seed(10)
print(np.random.randint(100, 200, (3, 4)))

 

 

从已有数组中随机抽取元素构成数组：

shuffle（a） 根据数组a 的第一轴进行随机排列，改变数组x

permutation(a) 根据数组a 的第一轴产生一个新的乱序数组，不改变数组x

choice(a, [, size,replace, p]) replace表示是否可以重用元素，默认为False

# 从已有数组中随机抽取元素构成数组
# shuffle
a = np.random.randint(100, 200, (3, 4))
print(a)
np.random.shuffle(a)  # 改变数组
print(a)
# permutation
a = np.random.randint(100, 200, (3, 4))
print(a)
print(np.random.permutation(a))  # 改变数组
print("----------------------------")
print(a)

# 随机抽取元素构成新数组
b = np.random.randint(100, 200, (8,))
print(b)
print(np.random.choice(b, (3, 2)))
print("**************************")
print(np.random.choice(b, (3, 2), replace=False))  # 选取元素不在重复
print("++++++++++++++++++++++")
print(np.random.choice(b, (3, 2), p=b/np.sum(b)))  # p代表元素抽取概率（元素越大，概率越大）

 

产生具有一定分布的随机数：

uniform(low, high, size) 产生均匀分布的数组，low为起始值，high为结束值

normal(loc, scale, size) 正态分布数组，loc均值，scale标准差，size形状

poisson(lam, size) 产生泊松分布数组，lam随机事件发生概率

# 产生具有一定分布的随机数
u = np.random.uniform(0, 10, (3, 4))
print(u)
print("###############################")
n = np.random.normal(10, 5, (3, 4))
print(n)

 

NumPy的统计函数

sum(a, axis=None) 根据给定轴axis计算数组a相关元素之和，axis整数或元组

mean(a, axis=None) 根据给定轴axis计算数组a相关元素期望

average(a, axis=None, weight=None) 根据给定轴axis计算数组a相关元素加权平均值

std(a,axis=None) 根据给定轴axis计算数组a相关元素标准差

var(a, axis=None) 根据给定轴axis计算数组a相关元素方差

# 统计函数（1）
a = np.arange(15).reshape(3, 5)
print(a)
print(np.sum(a))
print("")
print(np.mean(a, axis=1))
print(np.mean(a, axis=0))
print("")
print(np.average(a, axis=0, weights=[10, 5, 1]))  # weight 代表权重，每行权重为10、5、1
print(np.std(a))
print(np.var(a))

 

min(a)  max(a) 计算数组a 中元素最小最大值

argmin(a)  argmax(a) 计算数组a中元素最小最大值的降一维后下标

unravel_index(index, shape) 根据shape将一维下标index转换为多为、维下标

ptp(a) 计算数组a 中元素极差

median(a) 计算数组a元素中位数（中值）

# 统计函数（2）
b = np.arange(15, 0, -1).reshape(3, 5)
print(b)
print(np.max(b))
print(np.argmax(b))  # 一维
print("")
print(np.unravel_index(np.argmax(b), b.shape))  # 重塑为多维下标
print(np.ptp(b))  # 数组极差
print("")
print(np.median(b))  # 中位数

 

NumPy的梯度函数

说明：用于图像声音处理

梯度：连续值之间的变化率，即斜率

np.gradient(f) 计算数组f中元素梯度，当f 为多维时，返回每个维度梯度

 

图像数组表示

RGB模式：r 表示红色，取值范围0-255、g.....、b......

PIL库：图像处理库

 

待更......