在numpy数组中移动元素

Question 1

几年前从这个问题开始，在numpy中是否有规范的“移位”功能？我从文档中看不到任何东西。

这是我正在寻找的简单版本：

def shift(xs, n):
    if n >= 0:
        return np.r_[np.full(n, np.nan), xs[:-n]]
    else:
        return np.r_[xs[-n:], np.full(-n, np.nan)]

使用它就像：

In [76]: xs
Out[76]: array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.])

In [77]: shift(xs, 3)
Out[77]: array([ nan,  nan,  nan,   0.,   1.,   2.,   3.,   4.,   5.,   6.])

In [78]: shift(xs, -3)
Out[78]: array([  3.,   4.,   5.,   6.,   7.,   8.,   9.,  nan,  nan,  nan])

_{这个问题来自于我昨天尝试编写快速滚动产品的尝试。我需要一种“转移”累积乘积的方法，我所能想到的就是在中复制逻辑np.roll()。}

因此np.concatenate()比快得多np.r_[]。此版本的功能执行得更好：

def shift(xs, n):
    if n >= 0:
        return np.concatenate((np.full(n, np.nan), xs[:-n]))
    else:
        return np.concatenate((xs[-n:], np.full(-n, np.nan)))

更快的版本只是简单地预分配了数组：

def shift(xs, n):
    e = np.empty_like(xs)
    if n >= 0:
        e[:n] = np.nan
        e[n:] = xs[:-n]
    else:
        e[n:] = np.nan
        e[:n] = xs[-n:]
    return e

Question 2

不是numpy，而是scipy提供了您想要的转换功能，

import numpy as np
from scipy.ndimage.interpolation import shift

xs = np.array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.])

shift(xs, 3, cval=np.NaN)

默认情况是从数组外部引入一个带有值的常量值cval，此处设置为nan。这样可以提供所需的输出，

array([ nan, nan, nan, 0., 1., 2., 3., 4., 5., 6.])

负移的作用相似

shift(xs, -3, cval=np.NaN)

提供输出

array([  3.,   4.,   5.,   6.,   7.,   8.,   9.,  nan,  nan,  nan])

Question 3

对于那些只想复制和粘贴shift最快实现的人，有一个基准和结论（请参阅最后）。另外，我介绍了fill_value参数并修复了一些错误。

基准测试

import numpy as np
import timeit

# enhanced from IronManMark20 version
def shift1(arr, num, fill_value=np.nan):
    arr = np.roll(arr,num)
    if num < 0:
        arr[num:] = fill_value
    elif num > 0:
        arr[:num] = fill_value
    return arr

# use np.roll and np.put by IronManMark20
def shift2(arr,num):
    arr=np.roll(arr,num)
    if num<0:
         np.put(arr,range(len(arr)+num,len(arr)),np.nan)
    elif num > 0:
         np.put(arr,range(num),np.nan)
    return arr

# use np.pad and slice by me.
def shift3(arr, num, fill_value=np.nan):
    l = len(arr)
    if num < 0:
        arr = np.pad(arr, (0, abs(num)), mode='constant', constant_values=(fill_value,))[:-num]
    elif num > 0:
        arr = np.pad(arr, (num, 0), mode='constant', constant_values=(fill_value,))[:-num]

    return arr

# use np.concatenate and np.full by chrisaycock
def shift4(arr, num, fill_value=np.nan):
    if num >= 0:
        return np.concatenate((np.full(num, fill_value), arr[:-num]))
    else:
        return np.concatenate((arr[-num:], np.full(-num, fill_value)))

# preallocate empty array and assign slice by chrisaycock
def shift5(arr, num, fill_value=np.nan):
    result = np.empty_like(arr)
    if num > 0:
        result[:num] = fill_value
        result[num:] = arr[:-num]
    elif num < 0:
        result[num:] = fill_value
        result[:num] = arr[-num:]
    else:
        result[:] = arr
    return result

arr = np.arange(2000).astype(float)

def benchmark_shift1():
    shift1(arr, 3)

def benchmark_shift2():
    shift2(arr, 3)

def benchmark_shift3():
    shift3(arr, 3)

def benchmark_shift4():
    shift4(arr, 3)

def benchmark_shift5():
    shift5(arr, 3)

benchmark_set = ['benchmark_shift1', 'benchmark_shift2', 'benchmark_shift3', 'benchmark_shift4', 'benchmark_shift5']

for x in benchmark_set:
    number = 10000
    t = timeit.timeit('%s()' % x, 'from __main__ import %s' % x, number=number)
    print '%s time: %f' % (x, t)

基准测试结果：

benchmark_shift1 time: 0.265238
benchmark_shift2 time: 0.285175
benchmark_shift3 time: 0.473890
benchmark_shift4 time: 0.099049
benchmark_shift5 time: 0.052836

结论

shift5是赢家！这是OP的第三个解决方案。

Question 4

没有单一功能可以满足您的需求。您对班次的定义与大多数人所做的略有不同。移位数组的方法更常见：

>>>xs=np.array([1,2,3,4,5])
>>>shift(xs,3)
array([3,4,5,1,2])

但是，您可以使用两个功能来完成所需的操作。
考虑a=np.array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])：

def shift2(arr,num):
    arr=np.roll(arr,num)
    if num<0:
         np.put(arr,range(len(arr)+num,len(arr)),np.nan)
    elif num > 0:
         np.put(arr,range(num),np.nan)
    return arr
>>>shift2(a,3)
[ nan  nan  nan   0.   1.   2.   3.   4.   5.   6.]
>>>shift2(a,-3)
[  3.   4.   5.   6.   7.   8.   9.  nan  nan  nan]

在给定的函数和您提供的上述代码上运行cProfile之后，我发现您提供的代码进行42次函数调用，而shift2当arr为正时进行14次调用，当其为负时进行16次调用。~~我将尝试计时，以查看它们如何处理真实数据。~~

Question 5

您可以先转换ndarray为Series或DataFrame与转换pandas，然后可以shift根据需要使用method。

例：

In [1]: from pandas import Series

In [2]: data = np.arange(10)

In [3]: data
Out[3]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [4]: data = Series(data)

In [5]: data
Out[5]: 
0    0
1    1
2    2
3    3
4    4
5    5
6    6
7    7
8    8
9    9
dtype: int64

In [6]: data = data.shift(3)

In [7]: data
Out[7]: 
0    NaN
1    NaN
2    NaN
3    0.0
4    1.0
5    2.0
6    3.0
7    4.0
8    5.0
9    6.0
dtype: float64

In [8]: data = data.values

In [9]: data
Out[9]: array([ nan,  nan,  nan,   0.,   1.,   2.,   3.,   4.,   5.,   6.])

Question 6

基准和Numba简介

1.总结

可接受的答案（scipy.ndimage.interpolation.shift）是此页面中列出的最慢的解决方案。
当数组大小小于〜25.000时，Numba（@ numba.njit）会提高性能
当数组大小较大（> 250.000）时，“任何方法”同样适用。
最快的选择实际上取决于
（1）数组的长度
（2）您需要执行的移位量。
下图是此页面（2020-07-11）列出的所有不同方法的使用固定位移= 10的时间的图片。可以看到，在较小的数组大小下，某些方法所用的时间比方法所占用的时间多+ 2000％。最好的方法。

相对定时，恒定移位（10），所有方法

2.最佳选择的详细基准测试

shift4_numba如果您想要出色的全方位服务，请选择（定义如下）

3.代码

3.1 `shift4_numba`

全方位的好；最高20％wrt。任何数组大小的最佳方法
中等阵列大小的最佳方法：〜500 <N <20.000。
注意：仅当您多次调用装饰函数时，Numba jit（及时编译器）才会提高性能。第一次通话通常比后续通话时间长3-4倍。

import numba

@numba.njit
def shift4_numba(arr, num, fill_value=np.nan):
    if num >= 0:
        return np.concatenate((np.full(num, fill_value), arr[:-num]))
    else:
        return np.concatenate((arr[-num:], np.full(-num, fill_value)))

3.2。 `shift5_numba`

较小（N <= 300 .. 1500）阵列大小的最佳选择。阈值取决于所需的移位量。
在任何阵列大小上均具有良好的性能；与最快的解决方案相比，最高+ 50％。
注意：仅当您多次调用装饰函数时，Numba jit（及时编译器）才会提高性能。第一次通话通常比后续通话时间长3-4倍。

import numba

@numba.njit
def shift5_numba(arr, num, fill_value=np.nan):
    result = np.empty_like(arr)
    if num > 0:
        result[:num] = fill_value
        result[num:] = arr[:-num]
    elif num < 0:
        result[num:] = fill_value
        result[:num] = arr[-num:]
    else:
        result[:] = arr
    return result

3.3。 `shift5`

数组大小〜20.000 <N <250.000的最佳方法
与相同shift5_numba，只需删除@ numba.njit装饰器。

4附录

4.1有关使用方法的详细信息

shift_scipy：scipy.ndimage.interpolation.shift（scipy 1.4.1）-可接受答案中的选项，这显然是最慢的选择。
shift1：np.roll和out[:num] xnp.nan由IronManMark20＆GZC
shift2：np.roll和np.put由IronManMark20
shift3：np.pad和slice由 GZC
shift4：np.concatenate和np.full由 chrisaycock
shift5：result[slice] = x由 chrisaycock使用两次
shift#_numba：@ numba .njit装饰了以前的版本。

当前numba（0.50.1）不支持的shift2和所shift3包含的函数。

4.2其他测试结果

4.2.1相对时间，所有方法

4.2.2原始计时，所有方法

4.2.3原始时间，最佳方法很少

Question 7

您也可以使用Pandas来做到这一点：

使用2356长的数组：

import numpy as np

xs = np.array([...])

使用scipy：

from scipy.ndimage.interpolation import shift

%timeit shift(xs, 1, cval=np.nan)
# 956 µs ± 77.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

使用熊猫：

import pandas as pd

%timeit pd.Series(xs).shift(1).values
# 377 µs ± 9.42 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

在此示例中，使用Pandas的速度是Scipy的约8倍

Question 8

如果您希望从numpy获得单线并且不太在乎性能，请尝试：

np.sum(np.diag(the_array,1),0)[:-1]

说明：np.diag(the_array,1)创建一个矩阵，矩阵的对角线是一个对角线，np.sum(...,0)将矩阵按列求和，并...[:-1]采用与原始数组的大小相对应的元素。1和和:-1as参数一起玩可以使您朝不同的方向移动。

Question 9

一种不将代码洒入案例的方法

与数组：

def shift(arr, dx, default_value):
    result = np.empty_like(arr)
    get_neg_or_none = lambda s: s if s < 0 else None
    get_pos_or_none = lambda s: s if s > 0 else None
    result[get_neg_or_none(dx): get_pos_or_none(dx)] = default_value
    result[get_pos_or_none(dx): get_neg_or_none(dx)] = arr[get_pos_or_none(-dx): get_neg_or_none(-dx)]     
    return result

使用矩阵可以做到这一点：

def shift(image, dx, dy, default_value):
    res = np.full_like(image, default_value)

    get_neg_or_none = lambda s: s if s < 0 else None
    get_pos_or_none = lambda s : s if s > 0 else None

    res[get_pos_or_none(-dy): get_neg_or_none(-dy), get_pos_or_none(-dx): get_neg_or_none(-dx)] = \
        image[get_pos_or_none(dy): get_neg_or_none(dy), get_pos_or_none(dx): get_neg_or_none(dx)]
    return res