“Numpy”的版本间差异

来自Shiyin's note
跳到导航 跳到搜索
 
(未显示同一用户的38个中间版本)
第2行: 第2行:


==ndarray==
==ndarray==


*shape() #数组的形状,虽然len()可以运行
*shape() #数组的形状,虽然len()可以运行
*size() #数组的总元素
*size() #数组的总元素
*a=np.empty_like(b) #初始化一个和b数组一样shape的空数组
*a=np.empty_like(b) #初始化一个和b数组一样shape的空数组
*产生序列数组 a=np.arange(20)
*合并两个数组 np.append(array1,array2)
*合并两个数组 np.append(array1,array2)
*选择数组在某个范围之内 sel=np.where((wave < 6800) & (wave > 3800))

*利用内循环赋值
*利用内循环赋值
a = [0 for x in range(0, 1000)]
a = [0 for x in range(0, 1000)]


===数组运算===
===数组运算===
* where
a=np.arange(10)
a=np.where(a<5,a,np.nan) #将大于5的数替换为np.nan
*argmin,argmax
:数组中极值的位置
*clip(a,a_min,a_max)
*clip(a,a_min,a_max)
:array(a).clip(a_min.a_max)
:array(a).clip(a_min.a_max)
第20行: 第20行:
:reduceat 有点复杂 参见[http://blog.chinaunix.net/uid-7596337-id-125815.html]
:reduceat 有点复杂 参见[http://blog.chinaunix.net/uid-7596337-id-125815.html]
*unique,sort,sum
*unique,sort,sum
:a=np.zeros([3,5])+1
a=np.zeros([3,5])+1
:np.sum(a,1) #只对多维数组的某一个方向上求和
np.sum(a,1) #只对多维数组的某一个方向上求和
c,s=np.unique(b,return_index=True) # return_index=True 表示返回新列表元素在旧列表中的位置,并以列表形式储存在s中。
*roll #平移
*roll #平移
*array[::-1] 数组倒序
*array[::-1] 数组倒序
*np.hpstack: stack数组
*np.hpstack: stack数组
*np.hsplit: split数组
*np.hsplit: split数组
import numpy as np
print "Stacking and splitting array"
p = np.array([1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5])
p = np.array([1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5])
q = np.array([2.35, 5.75, 7.75, 3.15])
q = np.array([2.35, 5.75, 7.75, 3.15])
newa = np.hstack((p, q))
newa = np.hstack((p, q))
print "newa: ", newa
r = np.hsplit(newa,3) # three equally shaped arrays 11 print "Array r:"
r = np.hsplit(newa,3) # three equally shaped arrays 11 print "Array r:"
*percentile
*percentile
:wout=np.percentile(flatchain,[16,50,84],0) #flatchain 是二维数组,这是在一个维度上求其分布的范围
:wout=np.percentile(flatchain,[16,50,84],0) #flatchain 是二维数组,这是在一个维度上求其分布的范围
*按照数值大小分成等份的几个数组
>>> a = np.array([3, 4, 2, 1])
>>> >>> x[np.argpartition(x, 3)]
array([2, 1, 3, 4])
>>> np.partition(a, 3) #可以把3替换为一个数组,比如 (1,3)
array([2, 1, 3, 4]) # that the value of the element in k-th position is in the position it would be in a sorted array


*布尔型数组取否运算 (~)
*布尔型数组取否运算 (~)

*提取一组数组元素,np.take() 提取多个不连续的元素,对于一维数组来说,较为简单,不用指定维度。方法类似提取单个元素,如果a是一个numpy array,a.take(m,1)表示取每一行的第m个值;a.take(m,0)表示取第m行
print(a.take([1,3,4]))


===数据类型===
===数据类型===
第67行: 第62行:
*参见 [https://blog.csdn.net/Zhili_wang/article/details/81140282]
*参见 [https://blog.csdn.net/Zhili_wang/article/details/81140282]


===特殊数值 nan,inf===
====特殊数值 nan,inf====
* isnan, isinf ,isnull
* isnan, isinf ,isnull
:nan只能用isnan来判断
:nan只能用isnan来判断
第74行: 第69行:
* nan_to_num(x)
* nan_to_num(x)
直接将nan数值替换为0
直接将nan数值替换为0
* 一个讨巧的办法是 np.isfinite()可以判断去除各种特殊数值
* np.nanmedian()这些算法可以不考虑nan数值


===字符串数组===
====字符串数组====
*dtype='str'
*dtype='str'
*同时对每个元素操作见这里 https://docs.scipy.org/doc/numpy/reference/routines.char.html
*np.char: 同时对每个元素操作见这里 https://docs.scipy.org/doc/numpy/reference/routines.char.html, also 参见[https://blog.csdn.net/m0_37816922/article/details/127957746]

*字符串数组里面直接定位一个元素,用index会报错,用find返回的是一个布尔数组
*字符串数组里面直接定位一个元素,用index会报错,用find返回的是一个布尔数组
:解决办法:用tolist()再用index定位
:解决办法:用tolist()再用index定位
*charar = np.chararray(10, itemsize=10,unicode=True) #字符串长度为10的字符串数组

===多维数组===
*极值
:Ha是是个二维map
Hamax=Ha.max()
xmax,ymax=np.unravel_index(np.argmax(Ha, axis=None), Ha.shape) #极值位置
*降维 Ha.flatten()
*Ha.reshape(-1) # 也可以达到降维的效果


===格式输出===
===格式输出===
第99行: 第88行:


*另外一个方法
*另外一个方法
def ndprint(a, format_string ='{0:.2f}'):
def ndprint(a, format_string ='{:.2f}'):
print [format_string.format(v,i) for i,v in enumerate(a)]
print [format_string.format(v) for i,v in enumerate(a)]


叠加标准输出:%r 不换行 %n 换行
叠加标准输出:%r 不换行 %n 换行
第109行: 第98行:
sys.stdout.write("\n[{0}{1}]".format('#' * n, ' ' * (30 - n)))
sys.stdout.write("\n[{0}{1}]".format('#' * n, ' ' * (30 - n)))


===简单文件存取===
====txt文件====
*np.loadtxt(frame,dtype = np.float,delimiter = None,unpack = False)
*numpy.savetxt(fname, X, fmt=’%.18e’, delimiter=’ ‘, newline=’\n’, header=”, footer=”, comments=’# ‘)
可以把一个数组一次性写入某个文件,但是第一个参数貌似必须是文件名,而且不能续写,写完后文件就被关闭。只能最多是2维数组

====npy文件====
*.npy是numpy专用的二进制格式(压缩扩展名为.npz)
import numpy as np
arr = np.array([[1, 2, 3],
[4, 5, 6]])
np.save('weight.npy', arr)
loadData = np.load('weight.npy')
print("----type----")
print(type(loadData))
print("----shape----")
print(loadData.shape)
print("----data----")
print(loadData)
*ndarray.tofile(self, fid, sep=”“, format=”%s”)
*ndarray.tofile(self, fid, sep=”“, format=”%s”)
数组的简单存取,比较方便可以用于多维数组(二进制格式)
数组的简单存取,比较方便可以用于多维数组(二进制格式)
*numpy.fromfile(file, dtype=float, count=-1, sep='')


====npz文件====
*np.load(fname):
如果你想将多个数组保存到一个文件中的话,可以使用numpy.savez函数。savez函数的第一个参数是文件名,其后的参数都是需要保存的数组,也可以使用关键字参数为数组起一个名字,非关键字参数传递的数组会自动起名为arr_0, arr_1, …。
savez函数输出的是一个压缩文件(扩展名为npz),其中每个文件都是一个save函数保存的npy文件,文件名对应于数组名。
load函数自动识别npz文件,并且返回一个类似于字典的对象,可以通过数组名作为关键字获取数组的内容。
np.savez(‘test.npz',zero=np.zeros(10),np.ones(10))
data = np.load('test.npz') #类似于字典{‘arr_0’:a,’arr_1’:b,’arr_2’:c}
data.files #查看里面包含的数组
print('arr_0 : ', data['zero'])
print('arr_1 : ', data['arr_1'])


==多维数组==
fname:文件,以.npy为扩展名,压缩扩展名为.npz
*极值
*np.save(fname,array)
:Ha是是个二维map
Hamax=Ha.max()
xmax,ymax=np.unravel_index(np.argmax(Ha, axis=None), Ha.shape) #极值位置
*降维 Ha.flatten()
*Ha.reshape(-1) # 也可以达到降维的效果
*squeeze 把多维数组里面 为1的压缩,比如(1,2,2)变成(2,2)
*ravel(),把矩阵向量化


===行向量,列向量===
*numpy.fromfile(file, dtype=float, count=-1, sep='')
*与数组不同的是行矢量是二维,提取某个参数时需要指定元素在两个维度下的位置如 a[0,0]代表两个维度中位置都为0的元素。
a=np.arange(10).reshape(1,-1)
print(a[0,-1])


===索引===
*np.loadtxt(frame,dtype = np.float,delimiter = None,unpack = False)
xpos,ypos=np.indices((5,4))
x = np.arange(20).reshape(5, 4)
print(x)
print(x[xpos,ypos])


===broadcast===
*numpy.savetxt(fname, X, fmt=’%.18e’, delimiter=’ ‘, newline=’\n’, header=”, footer=”, comments=’# ‘)
* 当两个数组的形状并不相同的时候,我们可以通过扩展数组的方法来实现相加、相减、相乘等操作,这种机制叫做广播(broadcasting)。 广播的原则:如果两个数组的后缘维度(trailing dimension,即从末尾开始算起的维度)的轴长度相符,或其中的一方的长度为1,则认为它们是广播兼容的。广播会在缺失和(或)长度为1的维度上进行。 这句话乃是理解广播的核心。广播主要发生在两种情况,一种是两个数组的维数不相等,但是它们的后缘维度的轴长相符,另外一种是有一方的长度为1。
可以把一个数组一次性写入某个文件,但是第一个参数貌似必须是文件名,而且不能续写,写完后文件就被关闭。只能最多是2维数组
:所以,一个(4,5)的矩阵可以直接和(5,)的向量相加,这时候,每行都加上这个数
:一个(4,5)矩阵不能直接和(4,)的向量相加,这时候可以采用None标签来扩维,即扩展为(4,1)矩阵
a=np.arange(20).reshape((4,5))
b=np.ones(5)
c=np.ones(4)*2
print(a+b)
print(a+c[:,None]) #a+c会出错

===keepdims===
* 在多维数组的某一维度上求和或者计算平均值的时候,可以使用keepdims=True,这样可以保证后续运算中使用broadcast原则
a=np.ones((2,3,4,5))
b=np.sum(a,axis=(1,2),keepdims=True)
c=a+b


==vectorize==
==vectorize==
第133行: 第175行:
return integrate.quad(CSFH,t1,t2)[0]
return integrate.quad(CSFH,t1,t2)[0]


==随机数==
==Linear algebra==
*norm (对矢量的归一化,用矢量的模)
*random.rand(20,20)

2024年7月7日 (日) 14:12的最新版本

http://bigsec.net/b52/scipydoc/numpy_intro.html

ndarray

  • shape() #数组的形状,虽然len()可以运行
  • size() #数组的总元素
  • a=np.empty_like(b) #初始化一个和b数组一样shape的空数组
  • 合并两个数组 np.append(array1,array2)
  • 利用内循环赋值
 a = [0 for x in range(0, 1000)]  

数组运算

  • where
a=np.arange(10)
a=np.where(a<5,a,np.nan) #将大于5的数替换为np.nan
  • argmin,argmax
数组中极值的位置
  • clip(a,a_min,a_max)
array(a).clip(a_min.a_max)
  • reduce,reduceat
reduceat 有点复杂 参见[1]
  • unique,sort,sum
a=np.zeros([3,5])+1
np.sum(a,1) #只对多维数组的某一个方向上求和
c,s=np.unique(b,return_index=True) # return_index=True 表示返回新列表元素在旧列表中的位置,并以列表形式储存在s中。
  • roll #平移
  • array[::-1] 数组倒序
  • np.hpstack: stack数组
  • np.hsplit: split数组
 p = np.array([1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5]) 
 q = np.array([2.35, 5.75, 7.75, 3.15]) 
 newa = np.hstack((p, q)) 
 r = np.hsplit(newa,3) # three equally shaped arrays 11 print "Array r:"
  • percentile
wout=np.percentile(flatchain,[16,50,84],0) #flatchain 是二维数组,这是在一个维度上求其分布的范围
  • 布尔型数组取否运算 (~)
  • 提取一组数组元素,np.take() 提取多个不连续的元素,对于一维数组来说,较为简单,不用指定维度。方法类似提取单个元素,如果a是一个numpy array,a.take(m,1)表示取每一行的第m个值;a.take(m,0)表示取第m行
print(a.take([1,3,4]))

数据类型

  • dtype
dtype=object 比较好用,这样每个元素可以是另外一个数组,可以不等长。合并的时候可以采用 hstack的命令
a1=np.arange(10)
a2=np.arange(20)
a=np.array([a1,a2],dtype=object)
a3=np.hstack(a)
dtype=str 字符串 (只能是一位字符)
dype='S256'
  • astype 装换格式(数组的dtype不能直接修改)
 >>> b = np.array([1.23,12.201,123.1])
 >>> b.dtype
 dtype('float64')
  >>> c = b.astype(int)


  • 可以自定义
>>> t = dtype([('name', str, 40), ('numitems', numpy.int32), ('price',numpy.float32)])
>>> itemz = array([('Meaning of life DVD', 42, 3.14), ('Butter', 13,2.72)], dtype=t)

特殊数值 nan,inf

  • isnan, isinf ,isnull
nan只能用isnan来判断
a=1/np.arange
sel=np.where(np.isinf(a))
  • nan_to_num(x)
直接将nan数值替换为0
  • 一个讨巧的办法是 np.isfinite()可以判断去除各种特殊数值
  • np.nanmedian()这些算法可以不考虑nan数值

字符串数组

解决办法:用tolist()再用index定位
  • charar = np.chararray(10, itemsize=10,unicode=True) #字符串长度为10的字符串数组

格式输出

x = np.random.random(10)
np.set_printoptions(precision=3, suppress=True):
print(x)
print(np.array_str(x, precision=2))
np.array2string(x, formatter={'float_kind':'{0:.3f}'.format})
print(np.vectorize("%.2f".__mod__)(x))
  • 另外一个方法
def ndprint(a, format_string ='{:.2f}'):
   print [format_string.format(v) for i,v in enumerate(a)]

叠加标准输出:%r 不换行 %n 换行

for n in range(30):
   sys.stdout.write("\r[{0}{1}]".format('#' * n, ' ' * (30 - n))) 
for n in range(30):
   sys.stdout.write("\n[{0}{1}]".format('#' * n, ' ' * (30 - n)))

txt文件

  • np.loadtxt(frame,dtype = np.float,delimiter = None,unpack = False)
  • numpy.savetxt(fname, X, fmt=’%.18e’, delimiter=’ ‘, newline=’\n’, header=”, footer=”, comments=’# ‘)
可以把一个数组一次性写入某个文件,但是第一个参数貌似必须是文件名,而且不能续写,写完后文件就被关闭。只能最多是2维数组

npy文件

  • .npy是numpy专用的二进制格式(压缩扩展名为.npz)
import numpy as np
arr = np.array([[1, 2, 3],
              [4, 5, 6]])
np.save('weight.npy', arr)
loadData = np.load('weight.npy')
print("----type----")
print(type(loadData))
print("----shape----")
print(loadData.shape)
print("----data----")
print(loadData)
  • ndarray.tofile(self, fid, sep=”“, format=”%s”)
数组的简单存取,比较方便可以用于多维数组(二进制格式)
  • numpy.fromfile(file, dtype=float, count=-1, sep=)

npz文件

如果你想将多个数组保存到一个文件中的话,可以使用numpy.savez函数。savez函数的第一个参数是文件名,其后的参数都是需要保存的数组,也可以使用关键字参数为数组起一个名字,非关键字参数传递的数组会自动起名为arr_0, arr_1, …。 savez函数输出的是一个压缩文件(扩展名为npz),其中每个文件都是一个save函数保存的npy文件,文件名对应于数组名。 load函数自动识别npz文件,并且返回一个类似于字典的对象,可以通过数组名作为关键字获取数组的内容。

np.savez(‘test.npz',zero=np.zeros(10),np.ones(10))
 data = np.load('test.npz')      #类似于字典{‘arr_0’:a,’arr_1’:b,’arr_2’:c}
 data.files #查看里面包含的数组
 print('arr_0 : ', data['zero'])
 print('arr_1 : ', data['arr_1'])

多维数组

  • 极值
Ha是是个二维map
Hamax=Ha.max()
xmax,ymax=np.unravel_index(np.argmax(Ha, axis=None), Ha.shape) #极值位置
  • 降维 Ha.flatten()
  • Ha.reshape(-1) # 也可以达到降维的效果
  • squeeze 把多维数组里面 为1的压缩,比如(1,2,2)变成(2,2)
  • ravel(),把矩阵向量化

行向量,列向量

  • 与数组不同的是行矢量是二维,提取某个参数时需要指定元素在两个维度下的位置如 a[0,0]代表两个维度中位置都为0的元素。
a=np.arange(10).reshape(1,-1)
print(a[0,-1])

索引

xpos,ypos=np.indices((5,4))
x = np.arange(20).reshape(5, 4)
print(x)
print(x[xpos,ypos])

broadcast

  • 当两个数组的形状并不相同的时候,我们可以通过扩展数组的方法来实现相加、相减、相乘等操作,这种机制叫做广播(broadcasting)。 广播的原则:如果两个数组的后缘维度(trailing dimension,即从末尾开始算起的维度)的轴长度相符,或其中的一方的长度为1,则认为它们是广播兼容的。广播会在缺失和(或)长度为1的维度上进行。 这句话乃是理解广播的核心。广播主要发生在两种情况,一种是两个数组的维数不相等,但是它们的后缘维度的轴长相符,另外一种是有一方的长度为1。
所以,一个(4,5)的矩阵可以直接和(5,)的向量相加,这时候,每行都加上这个数
一个(4,5)矩阵不能直接和(4,)的向量相加,这时候可以采用None标签来扩维,即扩展为(4,1)矩阵
a=np.arange(20).reshape((4,5))
b=np.ones(5)
c=np.ones(4)*2
print(a+b)
print(a+c[:,None]) #a+c会出错

keepdims

  • 在多维数组的某一维度上求和或者计算平均值的时候,可以使用keepdims=True,这样可以保证后续运算中使用broadcast原则
a=np.ones((2,3,4,5))
b=np.sum(a,axis=(1,2),keepdims=True)
c=a+b

vectorize

  • 可以将只能对数值计算的函数,变成可以对数组计算,比如积分
import scipy.integrate as integrate
  
    vec_expint=np.vectorize(expint) 
def expint(t1,t2):
    return integrate.quad(CSFH,t1,t2)[0]

Linear algebra

  • norm (对矢量的归一化,用矢量的模)