Question

我有一个numpy数组，我需要得到（不更改原始）相同的数组，但第一个项目放在最后。由于我使用这个很多，我正在寻找干净的方式得到这个。所以例如，如果我的原始数组是[1,2,3,4]，我想得到一个数组[4,1,2,3]而不修改原始数组。

我找到了一个解决方案：

const path = require('path');
const webpack = require('webpack');
const HtmlWebpackPlugin = require('html-webpack-plugin');
const CleanWebpackPlugin = require('clean-webpack-plugin');
const CopyWebpackPlugin = require('copy-webpack-plugin');
require('babel-loader');

module.exports = {
    entry: {
        App1: './App1/main.js',
        App2: './App2/main.js'
},
    module: {
        rules: [{
                test: /\.ts$/,
                loader: 'ts-loader',
                exclude: /node_modules|vue\/src/,
                options: {
                    appendTsSuffixTo: [/\.vue$/]
                }
            },
            {
                test: /\.vue$/,
                loader: 'vue-loader',
                options: {
                    esModule: true,
                    loaders: {
                        'js': 'babel-loader'
                    }
                }
            },
            {
                test: /\.css$/,
                use: [
                    'style-loader',
                    'css-loader'
                ]
            },
            {
                test: /\.(png|svg|jpg|gif)$/,
                use: [
                    'file-loader'
                ]
            }
        ]
    },
    resolve: {
        extensions: [".ts", ".js"],
        alias: {
            'vue$': 'vue/dist/vue.esm.js'
        }
    },
    plugins: [
        new CleanWebpackPlugin(['dist'])
        , new CopyWebpackPlugin([
            { from: './App1/*.css' },
            { from: './App1/*.html' },
            { from: './App2/*.css' },
            { from: './App2/*.html' },
        ])
    ],
    output: {
        filename: './Apps/[name]/[name].bundle.js',
        path: path.resolve(__dirname, 'dist')
    },
    node: {
        fs: 'empty'
    }
}

然而，我正在寻找一种更加pythonic的方式。基本上是这样的：

x = [1,2,3,4]
a = np.append(x[1:],x[0])]

然而，这当然不起作用。有没有比使用append（）函数更好的方法来做我想做的事情？

Answer 1

np.roll易于使用，但不是最快的方法。它是通用的，具有多个维度和变化。

其行动可以简化为：

def simple_roll(x):
    res = np.empty_like(x)
    res[0] = x[-1]
    res[1:] = x[:-1]
    return res

In [90]: np.roll(np.arange(1,5),1)
Out[90]: array([4, 1, 2, 3])
In [91]: simple_roll(np.arange(1,5))
Out[91]: array([4, 1, 2, 3])

时间测试：

In [92]: timeit np.roll(np.arange(1001),1)
36.8 µs ± 1.28 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
In [93]: timeit simple_roll(np.arange(1001))
5.54 µs ± 24.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

我们也可以使用r_构造一个索引数组来进行复制。但它较慢（由于高级索引而不是切片）：

def simple_roll1(x):
    idx = np.r_[-1,0:x.shape[0]-1]
    return x[idx]
In [101]: timeit simple_roll1(np.arange(1001))
34.2 µs ± 133 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Answer 2

您可以使用np.roll，例如文档：

沿给定轴滚动数组元素。

超出最后位置的元素将重新引入   第一

np.roll([1,2,3,4], 1)
# array([4, 1, 2, 3])

要向另一个方向滚动，请使用负移位：

np.roll([1,2,3,4], -1)
# array([2, 3, 4, 1])

获取数组的一部分以及numpy中的第一个元素（以pythonic方式）

2 个答案: