天道酬勤,学无止境

What is the best way to take np.percentile along an axis ignoring nans?

Is there a reasonably fast way to do np.percentile(ndarr, axis=0) on data containing NaN values?

For np.median, there is the corresponding bottleneck.nanmedian (https://pypi.python.org/pypi/Bottleneck) that is pretty good.

The best I've come up with for percentile, which is incomplete and presently incorrect, is:

   from bottleneck import nanrankdata, nanmax, nanargmin
   def nanpercentile(x, q, axis):
       ranks = nanrankdata(x, axis=axis)
       peak = nanmax(ranks, axis=axis)
       pct = ranks/peak / 100. # to make a percentile
       wh = nanargmin(abs(pct-q),axis=axis)
       return x[wh]

This doesn't work; really what is needed is some way to take the n'th element along the axis, but I haven't found the numpy slicing trick to do that.

"Reasonably fast" means better than looping over indices, e.g.:

q = 40
x = np.array([[[1,2,3],[6,np.nan,4]],[[0.5,2,1],[9,3,np.nan]]])
out = np.empty(x.shape[:-1])
for i in range(x.shape[0]):
   for j in range(x.shape[1]):
      d = x[i,j,:]
      out[i,j] = np.percentile(d[np.isfinite(d)], q)

print out

#array([[ 1.8,  4.8],
#       [ 0.9,  5.4]])

which works but can be exceedingly slow.

np.ma appears not to work as expected; it treats the nan value as if it were inf:

xm = np.ma.masked_where(np.isnan(x),x)
print np.percentile(xm,40,axis=2)

# array([[ 1.8,  5.6],
#        [ 0.9,  7.8]])
标签

评论

np.nanpercentile is included in numpy 1.9.0

http://docs.scipy.org/doc/numpy/reference/generated/numpy.nanpercentile.html

You can manipulate the strides of the array to iterate over it faster, using as_strided() which is found in numpy.lib.stride_tricks.

Your computations can be viewed as operating on (1,1,3) windows of your array. I like to use a generalized function (sliding_window() that creates n by n windows using as_strided(). I found it here - Efficient Overlapping Windows with Numpy; credit for the function apparently goes to johnvinyard. That blog page is a pretty good description of what is happening.

Make some 1x1x3 windows

import numpy as np
x = np.array([[[1,2,3],[6,np.nan,4]],[[0.5,2,1],[9,3,np.nan]]])
for thing in sliding_window(x, (1,1,3)):
    print thing

# [ 1.  2.  3.]
# [  6.  nan   4.]
# [ 0.5  2.   1. ]
# [  9.   3.  nan]

Apply ```np.percentile()'' - disregarding the NaN's

for thing in sliding_window(x, (1,1,3)):
    print np.percentile(thing[np.isfinite(thing)], 40)

# 1.8
# 4.8
# 0.9
# 5.4

Make an array of the result:

per_s = [np.percentile(thing[np.isfinite(thing)], 40)
         for thing in sliding_window(x, (1,1,3))]

print per_s
# [1.8, 4.8000000000000007, 0.90000000000000002, 5.4000000000000004]

per_s = np.array(per_s)
print per_s
# array([ 1.8,  4.8,  0.9,  5.4])

Get it back to the shape you expect

print per_s.reshape((2,2))
# array([[ 1.8,  4.8],
#        [ 0.9,  5.4]])

print per_s.reshape(x.shape[:-1])
# array([[ 1.8,  4.8],
#        [ 0.9,  5.4]])

This should be faster. I'm curious if it will be - i don't have any real world problems to test it on.

A google search of numpy as_strided turns up some good results: I have this one bookmarked, http://scipy-lectures.github.io/advanced/advanced_numpy/

sliding_window() from Efficient Overlapping Windows with Numpy

from numpy.lib.stride_tricks import as_strided as ast
from itertools import product

def norm_shape(shape):
    '''
    Normalize numpy array shapes so they're always expressed as a tuple, 
    even for one-dimensional shapes.

    Parameters
        shape - an int, or a tuple of ints

    Returns
        a shape tuple
    '''
    try:
        i = int(shape)
        return (i,)
    except TypeError:
        # shape was not a number
        pass

    try:
        t = tuple(shape)
        return t
    except TypeError:
        # shape was not iterable
        pass

    raise TypeError('shape must be an int, or a tuple of ints')


def sliding_window(a,ws,ss = None,flatten = True):
    '''
    Return a sliding window over a in any number of dimensions

    Parameters:
        a  - an n-dimensional numpy array
        ws - an int (a is 1D) or tuple (a is 2D or greater) representing the size 
             of each dimension of the window
        ss - an int (a is 1D) or tuple (a is 2D or greater) representing the 
             amount to slide the window in each dimension. If not specified, it
             defaults to ws.
        flatten - if True, all slices are flattened, otherwise, there is an 
                  extra dimension for each dimension of the input.

    Returns
        an array containing each n-dimensional window from a
    '''

    if None is ss:
        # ss was not provided. the windows will not overlap in any direction.
        ss = ws
    ws = norm_shape(ws)
    ss = norm_shape(ss)

    # convert ws, ss, and a.shape to numpy arrays so that we can do math in every 
    # dimension at once.
    ws = np.array(ws)
    ss = np.array(ss)
    shape = np.array(a.shape)


    # ensure that ws, ss, and a.shape all have the same number of dimensions
    ls = [len(shape),len(ws),len(ss)]
    if 1 != len(set(ls)):
        raise ValueError(\
        'a.shape, ws and ss must all have the same length. They were %s' % str(ls))

    # ensure that ws is smaller than a in every dimension
    if np.any(ws > shape):
        raise ValueError('ws cannot be larger than a in any dimension. a.shape was %s and ws was %s' % (str(a.shape),str(ws)))

    # how many slices will there be in each dimension?
    newshape = norm_shape(((shape - ws) // ss) + 1)
    # the shape of the strided array will be the number of slices in each dimension
    # plus the shape of the window (tuple addition)
    newshape += norm_shape(ws)
    # the strides tuple will be the array's strides multiplied by step size, plus
    # the array's strides (tuple addition)
    newstrides = norm_shape(np.array(a.strides) * ss) + a.strides
    strided = ast(a,shape = newshape,strides = newstrides)
    if not flatten:
        return strided

    # Collapse strided so that it has one more dimension than the window.  I.e.,
    # the new array is a flat list of slices.
    meat = len(ws) if ws.shape else 0
    firstdim = (np.product(newshape[:-meat]),) if ws.shape else ()
    dim = firstdim + (newshape[-meat:])
    # remove any dimensions with size 1
    #dim = filter(lambda i : i != 1,dim)
    dim = tuple(thing for thing in dim if thing != 1)
    return strided.reshape(dim)

If you don't need super fast solution, you could first transfer your array to pandas DataFrame and do quantile and then get back to numpy array.

df = pd.DataFrame(array.T).quantile()
arr = np.array(df)

you can use partition() in numpy 1.8 to take the n'th element along the axis, here is the code to get the second elements along the last axis:

x = np.array([[[1,2,3],[6,np.nan,4]],[[0.5,2,1],[9,3,np.nan]]])
np.partition(x, 1)[..., 1]

the output:

array([[ 2.,  6.],
       [ 1.,  9.]])

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • Numpy快速入门
    1. 写在前面 这篇博客是针对想入门机器学习和深度学习,或者数据分析的小白而写,我们都知道机器学习和深度学习,数据分析的编程基础就是Python编程,而最常用的一些库,像numpy,pandas,matplotlib,sklearn等这些库都必须熟记于心,如果学习深度学习的话,还必须有着深度学习基础,掌握一些主流的TensorFlow,pytorch等框架才能在这条路上走下去。 而在信息发展很快的时代,原来在校的那种,学完理论,再去实战的学习方式,其实已经不太适用,现在应该get到的一种新的学习技能其实应该是,边用边学,理论不需要总的学一遍再出发,而是掌握一些基本的理论,然后出发,遇到问题再返回来补充理论的这样的一种逻辑。 所以如果想入门人工智能或者数据分析,千万不要想着我Python学一遍,各种库先学一遍这样,不仅慢,有时候还会浪费很多时间,所以我根据之前整理的一些numpy,总结了一个numpy的快速入门(后续还有pandas,matplotlib的)有了这些知识,然后去通过项目实战,然后再补充,应该会快速上手。如果想更深入的学习numpy,我后面也会给出一些链接,是我曾经学习时整理的笔记,希望有所帮助。 下面开始: 2. Numpy是什么? 简单的说,Numpy是Python中一个非常重要的第三库,它不仅是 Python 中使用最多的第三方库,而且还是 SciPy
  • 减少使用 numpy 的一行代码的内存使用量(Reduce memory usage of a line of code that uses numpy)
    问题 我正在使用python库: https://github.com/ficusss/PyGMNormalize 用于规范化我的数据集 ( scRNAseq ) 和库文件utils.py的最后一行: https://github.com/ficusss/PyGMNormalize/blob/master/pygmnormalize/utils.py 使用太多内存: np.percentile(matrix[np.any(matrix > 0, axis=1)], p, axis=0) 有没有什么好办法重写这行代码来提高内存使用率? 我的意思是我在集群上有200Gb RAM可以访问,并且像20Gb这样的matrix无法工作,但我相信应该有办法让它工作。 回答1 如果matrix所有元素都 >=0,那么您可以执行以下操作: np.percentile(matrix[np.any(matrix, axis = 1)], p, axis = 0) 这使用了这样一个事实,即当被视为布尔值时,除0以外的任何浮点数或整数都被解释为True ( np.any在内部这样做)。 使您无需单独构建那个大的布尔矩阵。 由于您在matrix[...]布尔索引,因此您正在创建一个临时副本,您并不真正关心它是否在percentile过程中被覆盖。 因此,您可以使用overwrite_input =
  • 使用百分位数删除 Pandas DataFrame 中的异常值(Remove Outliers in Pandas DataFrame using Percentiles)
    问题 我有一个包含 40 列和许多记录的 DataFrame df。 df: User_id | Col1 | Col2 | Col3 | Col4 | Col5 | Col6 | Col7 |...| Col39 对于除 user_id 列之外的每一列,如果出现异常值,我想检查异常值并删除整个记录。 对于每一行的异常值检测,我决定简单地使用第 5 个和第 95 个百分位数(我知道这不是最好的统计方法): 编码我到目前为止所拥有的: P = np.percentile(df.Col1, [5, 95]) new_df = df[(df.Col1 > P[0]) & (df.Col1 < P[1])] 问题:如何在不手动执行此操作的情况下将此方法应用于所有列( User_id除外)? 我的目标是获得一个没有异常值记录的数据框。 谢谢! 回答1 初始数据集。 print(df.head()) Col0 Col1 Col2 Col3 Col4 User_id 0 49 31 93 53 39 44 1 69 13 84 58 24 47 2 41 71 2 43 58 64 3 35 56 69 55 36 67 4 64 24 12 18 99 67 首先删除User_id列 filt_df = df.loc[:, df.columns != 'User_id'] 然后,计算百分位数。
  • 将参数传递给确定性变量,pymc(Passing parameters to deterministic variables, pymc)
    问题 我正在尝试使用 PyMC 实现一个非常简单的大数定律示例。 目标是生成不同大小样本的许多样本平均值。 例如,在下面的代码中,我反复采用 5 个样本为一组 (samples_to_average = 5),计算它们的平均值,然后找到结果轨迹的 95% CI。 下面的代码运行,但我想要做的是将 samples_to_average 修改为一个列表,以便我可以在一次通过中计算一系列不同样本大小的置信区间。 import scipy.misc import numpy as np import pymc as mc samples_to_average = 5 list_of_samples = mc.DiscreteUniform("response", lower=1, upper=10, size=1000) @mc.deterministic def sample_average(x=list_of_samples, n=samples_to_average): samples = int(n) selected = x[0:samples] total = np.sum(selected) sample_average = float(total) / samples return sample_average def getConfidenceInterval()
  • 将数千张图像读入一个大的 numpy 数组的最快方法(Fastest approach to read thousands of images into one big numpy array)
    问题 我试图找到从目录中读取一堆图像到 numpy 数组的最快方法。 我的最终目标是计算所有这些图像中像素的最大值、最小值和第 n 个百分位数等统计数据。 当来自所有图像的像素都在一个大的 numpy 数组中时,这既简单又快速,因为我可以使用内置的数组方法,例如.max和.min ,以及np.percentile函数。 下面是一些带有 25 个 tiff 图像(512x512 像素)的时序示例。 这些基准测试来自在 jupyter-notebook 中使用%%timit 。 差异太小,仅对 25 张图像没有任何实际意义,但我打算在未来阅读数千张图像。 # Imports import os import skimage.io as io import numpy as np 附加到列表%%timeit imgs = [] img_path = '/path/to/imgs/' for img in os.listdir(img_path): imgs.append(io.imread(os.path.join(img_path, img))) ## 32.2 ms ± 355 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) 使用字典%%timeit imgs = {} img_path = '/path/to/imgs
  • 当我取数组列的中位数时,如何忽略零?(How can I ignore zeros when I take the median on columns of an array?)
    问题 我有一个简单的 numpy 数组。 array([[10, 0, 10, 0], [ 1, 1, 0, 0] [ 9, 9, 9, 0] [ 0, 10, 1, 0]]) 我想分别取这个数组的每一列的中位数。 但是,在计算中位数时,我想在各个地方忽略一些0值。 更复杂的是,我想保留只有0个条目的列的中位数为0 。 通过这种方式,这些列将充当一个占位符,保持矩阵的维度相同。 numpy 文档没有任何参数可以满足我的需求(也许我被 R 获得的许多开关所宠坏了!) numpy.median(a, axis=None, out=None, overwrite_input=False)[source] 有人可以阐明一种有效的方法来做到这一点,这符合 numpy 的精神吗? 我可以破解它,但在那种情况下,我觉得我一开始就失去了使用 numpy 的目的。 提前致谢。 回答1 掩码Masked array总是很方便,但 slooooooow: In [14]: %timeit np.ma.median(y, axis=0).filled(0) 1000 loops, best of 3: 1.73 ms per loop In [15]: %%timeit ans=np.apply_along_axis(lambda v: np.median(v[v!=0]), 0, x) ans[np
  • 在一维观测数据中检测异常值的Python方法(Pythonic way of detecting outliers in one dimensional observation data)
    问题 对于给定的数据,我想将异常值(由95%的置信度或95%的分位数函数或所需的任何值定义)设置为nan值。 以下是我现在正在使用的数据和代码。 如果有人可以进一步解释我,我将非常高兴。 import numpy as np, matplotlib.pyplot as plt data = np.random.rand(1000)+5.0 plt.plot(data) plt.xlabel('observation number') plt.ylabel('recorded value') plt.show() 回答1 使用percentile的问题在于,被识别为离群值的点是样本大小的函数。 有很多方法可以测试离群值,因此您应该考虑如何对它们进行分类。 理想情况下,您应该使用先验信息(例如“此值之上/之下的任何内容都是不现实的,因为...”) 但是,通常的,不太合理的离群值测试是根据“绝对中位数偏差”删除点。 这是N维案例的一种实现(来自本文的一些代码:https://github.com/joferkington/oost_paper_code/blob/master/utilities.py): def is_outlier(points, thresh=3.5): """ Returns a boolean array with True if points are
  • ValueError:操作数无法与形状一起广播 (2501,201) (2501,)(ValueError: operands could not be broadcast together with shapes (2501,201) (2501,))
    问题 我是python的新手,所以请保持友善。 我正在尝试将两个 Numpy 数组与np.logical_or函数进行比较。 当我运行下面的代码时,错误出现在 Percentile = np.logical_or(data2 > Per1, data2 < Per2)行说明 ValueError:操作数无法与形状一起广播 (2501,201) (2501,) data = 1st Array data2 = 2nd Array Per1 = np.percentile(data, 10, axis=1) Per2 = np.percentile(data, 90, axis=1) Percentile = np.logical_or(data2 > Per1, data2 < Per2) print(Percentile) 我检查了两个数组的形状,它们的形状似乎相同(2501,201) (2501,201) 。 因此,我很难理解为什么会发生此错误,任何帮助将不胜感激。 回答1 您需要添加一个维度(通过使用[:, None]到Per1和Per2以使它们可广播到数据。 Percentile = np.logical_or(data2 > Per1[:, None], data2 < Per2[:, None]) 回答2 如果您检查 Per1 或 Per2 的形状,您将看到它的值为
  • Numpy的使用
    什么是 NumPy? NumPy是一个功能强大的Python库,主要用于对多维数组执行计算。NumPy这个词来源于两个单词-- Numerical和Python.NumPy提供了大量的库函数和操作,可以帮助程序员轻松地进行数值计算。这类数值计算广泛用于以下任务: 机器学习模型:在编写机器学习算法时,需要对矩阵进行各种数值计算。例如矩阵乘法、换位、加法等。NumPy提供了一个非常好的库,用于简单(在编写代码方面)和快速(在速度方面)计算。NumPy数组用于存储训练数据和机器学习模型的参数。 图像处理和计算机图形学:计算机中的图像表示为多维数字数组。NumPy成为同样情况下最自然的选择。实际上,NumPy提供了一些优秀的库函数来快速处理图像。例如,镜像图像、按特定角度旋转图像等。 数学任务:NumPy对于执行各种数学任务非常有用,如数值积分、微分、内插、外推等。因此,当涉及到数学任务时,它形成了一种基于Python的MATLAB的快速替代。 我们为什么要掌握NumPy 人们有时会说,与C 这种低级语言相比,Python以运行速度为代价改善了开发时间和效率。幸运的是,有一些方法可以在不牺牲易用性的情况下加速Python中的操作运行时。适用于快速数值运算的一个选项是NumPy,它当之无愧地将自己称为使用Python进行科学计算的基本软件包。 通常
  • NumPy基础之大作业(Iris数据分析)
    @[云好晕啊]学习笔记 大作业 【声明:本章所有内容都是通过一个程序完成的,所以每个小问题中的代码存在数据复用以及后面的代码没有导入相应的库情况】  本次练习使用的是 鸢尾植物数据集。Iris也称为鸢尾花卉数据集,包含了三类不同鸢尾属植物:Iris Setosa、Iris Versicolour、Iris Virginica。每类包含50个样本。整个数据集150个样本,每个样本包含4个特征分别为: sepal_lenth(花萼长度)sepal_width(花萼宽度)pepal_length(花瓣长度)pepal_width(花瓣宽度) 以上特征单位均为cm。 1、导入鸢尾植物数据集,保持文本不变 【知识点:输入输出】 如何实现导入存在数字与文本的数据集? 【答案】  因为本次使用的鸢尾植物数据集是sklearn.dataset中自带的数据,所以本次数据的导入是直接通过相应函数: sklearn.datasets.load_iris() 但是因为这个数据集中包含很多部分内容,包括属性数据值,所属种类等等,所以还需要进行预处理以获得相应格式的分析数据。 具体思路是首先获取属性类数据iris.data,再考虑添加相应的分类数据,因为是按照顺序排列的,所以可以通过for循环实现分类数据构造,再进行连接两个数据集。将结果存入并加上行名称。接着就是对文本文件的读出。 代码: import
  • 机器学习 / 数据分析(一) (数据预处理 ——异常值和缺失值处理)
    Pandas. fillna(value) —— 补充缺失值 fillna(method='',inplace=Boolean) => pad(利用前面的值填充)、bfill(后面的值填充) inplace(是否替换原来的数据) PS: pad = ffill | backfill = bfill 均值填充 train['Age']=train['Age'].fillna(np.mean(train['Age'])) test['Age']=test['Age'].fillna(np.mean(train['Age'])) (测试集使用训练集均值处理) -99填充 train.replace(to_replace = np.nan, value = -99) (树模型比较常用) 线性差值填充 train.interpolate(method='linear') 删除 dropna([how='all']) 删除 NaN 数据 (删除全部都是 NaN 的数据) dropna(axis=0,how='any') 删除行(至少有一个NaN) dropna(axis=1,how='ant') 删除列(至少有一个NaN) 使用 sklearn.preprocessing(预处理) 中 Imputer (缺失值处理器) 新版 sklearn 中 Imputer 在 sklearn
  • 如何为 binned_statistic 制作用户定义的函数(How to make user defined functions for binned_statistic)
    问题 我正在使用 scipy stats 包沿轴获取统计信息,但我无法使用binned_statistic获取百分位数统计信息。 我已经概括了下面的代码,我试图在一系列 x 箱中取具有 x、y 值的数据集的第 10 个百分位数,但它失败了。 我当然可以使用np.std执行函数选项,例如中值,甚至是 numpy 标准差。 但是,我无法弄清楚如何使用np.percentile因为它需要 2 个参数(例如np.percentile(y, 10) ),但是它给了我一个ValueError: statistic not understood np.percentile(y, 10)错误。 import numpy as np import scipy.stats as scist y_median = scist.binned_statistic(x,y,statistic='median',bins=20,range=[(0,5)])[0] y_std = scist.binned_statistic(x,y,statistic=np.std,bins=20,range=[(0,5)])[0] y_10 = scist.binned_statistic(x,y,statistic=np.percentile(10),bins=20,range=[(0,5)])[0] print y
  • How to make user defined functions for binned_statistic
    I am using scipy stats package to take statistics along the an axis, but I am having trouble taking the percentile statistic using binned_statistic. I have generalized the code below, where I am trying taking the 10th percentile of a dataset with x, y values within a series of x bins, and it fails. I can of course do function options, like median, and even the numpy standard deviation using np.std. However, I cannot figure out how to use np.percentile because it requires 2 arguments (e.g. np.percentile(y, 10)), but then it gives me a ValueError: statistic not understood error. import numpy as
  • NumPy 函数手册
    NumPy手册 文章目录 NumPy手册获取属性秩形状大小元素数据类型元素占用空间大小内存地址 创建数组创建空数组创建零数组创建1数组创建对角矩阵创建序列数组创建概率分布的数组已有列表、元组创建 切片、索引切片高维切片索引布尔索引花式索引 数值计算算术运算广播(Broadcast)统计运算逻辑运算线性代数运算 迭代nditer迭代广播迭代flat 迭代 数组操作修改数组形状数组展开/降维矩阵转置坐标轴调整维度扩展,复制扩展维度压缩数组连接数组分割 参考网站 获取属性 秩 ndarray.ndim # 即轴的数量或维度的数量 形状 ndarray.shape # 数组的维度,对于矩阵,n 行 m 列 大小 ndarray.size # 数组元素的总个数,相当于 .shape 中 n*m 的值 元素数据类型 ndarray.dtype # ndarray 对象的元素类型 元素占用空间大小 ndarray.itemsize # ndarray 对象中每个元素的大小,以字节为单位 ####对象内存布局 ndarray.flags # ndarray 对象的内存信息 ####实部 ndarray.real # ndarray元素的实部 ####虚部 ndarray.imag # ndarray 元素的虚部 内存地址 ndarray.data #包含实际数组元素的缓冲区
  • Kaggle比赛系列: (3) Titanic-2
    前言:这是Titanic的第二篇文章, 在多模型ensemble之后并没有提高LB的得分和排名,但是依然是精挑细选的一片开源notebook.亮点在数据分析和特征工程. 1. 查看数据 1.1 数据加载 import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns %matplotlib inline from collections import Counter import warnings warnings.filterwarnings('ignore') from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, ExtraTreesClassifier, VotingClassifier from sklearn.discriminant_analysis import LinearDiscriminantAnalysis from sklearn.linear_model import LogisticRegression from sklearn.neighbors import
  • 在忽略 NaN 的同时取 np.average ?(Taking np.average while ignoring NaN's?)
    问题 我有一个形状 (64,17) 对应于时间和纬度的矩阵。 我想采用加权平均纬度,我知道 np.average 可以做到这一点,因为与 np.nanmean 不同,我曾经用来平均经度,可以在参数中使用权重。 但是, np.average 不会像 np.nanmean 那样忽略 NaN,所以我每行的前 5 个条目都包含在纬度平均中,并使整个时间序列充满 NaN。 有没有一种方法可以在计算中不包含 NaN 的情况下取加权平均值? file = Dataset("sst_aso_1951-2014latlon_seasavgs.nc") sst = file.variables['sst'] lat = file.variables['lat'] sst_filt = np.asarray(sst) missing_values_indices = sst_filt < -8000000 #missing values have value -infinity sst_filt[missing_values_indices] = np.nan #all missing values set to NaN weights = np.cos(np.deg2rad(lat)) sst_zonalavg = np.nanmean(sst_filt, axis=2) print sst
  • 用NumPy快速处理数据(学习笔记)
    Python科学计算:用NumPy快速处理数据(学习笔记) 目录 Python科学计算:用NumPy快速处理数据(学习笔记)前言使用 NumPy 让你的 Python 科学计算更高效ndarray 对象创建数组结构数组 ufunc 运算连续数组的创建算数运算统计函数计数组 / 矩阵中的最大值函数 amax(),最小值函数 amin()统计最大值与最小值之差 ptp()统计数组的百分位数 percentile()统计数组中的中位数 median()、平均数 mean()统计数组中的加权平均值 average()统计数组中的标准差 std()、方差 var() NumPy 排序 总结练习题:统计全班的成绩 前言 此笔记是清华大学计算机博士陈旸《数据分析45讲》的一课内容。由于Numpy的内容比较基础,做了一些记录。 链接:https://time.geekbang.org/column/intro/147 from IPython.core.interactiveshell import InteractiveShell InteractiveShell.ast_node_interactivity = 'all' Python 中一个非常重要的第三方库 NumPy。它不仅是 Python 中使用最多的第三方库,而且还是 SciPy、Pandas 等数据科学的基础库
  • NumPy:同时显示max()和min()的函数(NumPy: function for simultaneous max() and min())
    问题 numpy.amax()将在数组中找到最大值,而numpy.amin()对最小值进行相同操作。 如果要同时找到max和min,则必须调用两个函数,这需要两次(非常大)数组传递,这似乎很慢。 numpy API中是否存在仅通过一次数据即可找到max和min的函数? 回答1 numpy API中是否存在仅通过一次数据即可找到max和min的函数? 否。在撰写本文时,尚无此功能。 (是的,如果有这样的功能,其性能会显著优于调用numpy.amin()和numpy.amax()的大型阵列上先后)。 回答2 我认为两次通过数组都不是问题。 考虑以下伪代码: minval = array[0] maxval = array[0] for i in array: if i < minval: minval = i if i > maxval: maxval = i 虽然这里只有1个循环,但仍然有2个检查。 (而不是2个循环,每个循环1个检查)。 真正节省的唯一事情是1个循环的开销。 如果数组确实如您所说很大,那么与实际循环的工作量相比,开销很小。 (请注意,这都是用C实现的,因此循环无论如何都差不多是自由的)。 编辑对不起,你们中有4个人对我充满信心。 您绝对可以优化它。 这是一些可以通过f2py编译成python模块的fortran代码
  • 如何使用python / numpy计算百分位数?(How do I calculate percentiles with python/numpy?)
    问题 是否有一种方便的方法来计算序列或一维numpy数组的百分位数? 我正在寻找类似于Excel的百分位数功能的东西。 我查看了NumPy的统计资料参考,但找不到。 我只能找到中位数(第50个百分位数),但没有更具体的内容。 回答1 您可能对SciPy Stats软件包感兴趣。 它具有您需要的百分位数功能以及许多其他统计功能。 percentile()也可以在numpy 。 import numpy as np a = np.array([1,2,3,4,5]) p = np.percentile(a, 50) # return 50th percentile, e.g median. print p 3.0 这张票证使我相信,他们不会很快将percentile()集成到numpy中。 回答2 顺便说一句,有一个纯Python实现的百分位数功能,以防万一不想依赖scipy。 该函数复制如下: ## {{{ http://code.activestate.com/recipes/511478/ (r1) import math import functools def percentile(N, percent, key=lambda x:x): """ Find the percentile of a list of values. @parameter N - is a list
  • numpy学习笔记
    一、list 和 ndarray 对比 list 分散存储,使用指针;ndarray 存在连续均匀的内存中;使用 y = x * 2,而是使用x *= 2 (避免隐式拷贝) 二、numpy 中两个重要对象 ndarray(N-dimensional array object),多维数组ufunc(universal function object),对多维数组的操作 三、ndarray ndarray 实际上是多维数组的含义。在 NumPy 数组中,维数称为秩(rank),一维数组的秩为 1,二维数组的秩为 2,以此类推。在 NumPy 中,每一个线性的数组称为一个轴(axis),其实秩就是描述轴的数量。 (一) 创建数组 import numpy as np a = np.array([1, 2, 3]) a array([1, 2, 3]) a.shape (3,) a.dtype dtype('int32') b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) b array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) b.shape (3, 3) b.dtype dtype('int32') (二) 结构数组 import numpy as np person_type = np.dtype({