Numpy: ENH： `random.shuffle`の代わりに` axis`引数を使用します。

なぜこれが代替手段である必要があるのか​​わからない-なぜ単に追加しないのか
シャッフルする軸引数？ np.sumのように、デフォルトはNoneです。

21:36時土、2014年10月11日には、ウォーレンWeckesser [email protected]
書きました：

numpy.random.shuffleに代わるものがあるといいでしょう
軸引数を受け入れ、それは独立してシャッフルします
一次元スライス。 これが私がdisarrangeと呼ぶ実装です。
それは機能しますが、より効率的なCの実装があると便利です。

def disarrange（a、axis = -1）：
"" "
指定された軸に沿ってaをインプレースでシャッフルします。

Apply numpy.random.shuffle to the given axis of `a`.
Each one-dimensional slice is shuffled independently.
"""
b = a.swapaxes(axis, -1)
# Shuffle `b` in-place along the last axis.  `b` is a view of `a`,
# so `a` is shuffled in place, too.
shp = b.shape[:-1]
for ndx in np.ndindex(shp):
    np.random.shuffle(b[ndx])
return

例：

[156]の場合：a = np.arange（20）.reshape（4,5）

[157]で：a
アウト[157]：
array（[[0、1、2、3、4]、
[5、6、7、8、9]、
[10、11、12、13、14]、
[15、16、17、18、19]]）

[158]の場合：disarrange（a、axis = -1）

[159]で：
アウト[159]：
array（[[2、0、4、3、1]、
[8、6、7、9、5]、
[11、14、13、10、12]、
[19、18、16、17、15]]）

[160]の場合：a = np.arange（20）.reshape（4,5）

[161]の場合：disarrange（a、axis = 0）

[162]で：a
アウト[162]：
array（[[5、11、7、13、14]、
[0、6、2、3、4]、
[10、1、17、18、19]、
[15、16、12、8、9]]）

このリクエストは、stackoverflowに関するこの質問によって動機付けられました：
http://stackoverflow.com/questions/26310346/quickly-calculate-randomized-3d-numpy-array-from-2d-numpy-array/

—
このメールに直接返信するか、GitHubで表示してください
https://github.com/numpy/numpy/issues/5173。

ナサニエル・J・スミス
ポスドク研究員-情報学-エディンバラ大学
http://vorpus.org

shuffleの現在の動作は、実際にはaxis=Noneます。 引数を1次元シーケンスとして扱います。

In [181]: a = np.arange(20).reshape(4,5)

In [182]: np.random.shuffle(a)

In [183]: a
Out[183]: 
array([[ 0,  1,  2,  3,  4],
       [15, 16, 17, 18, 19],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

これはaxis=0であると解釈できますが、欠落している機能は1次元スライスの独立したシャッフルです。

2次元配列の場合、あなたはシャッフルすることができますa.Tエミュレートするためにaxis=1 、これはあなたの独立したシャッフルを取得することはできません。

In [184]: a = np.arange(20).reshape(4,5)

In [185]: np.random.shuffle(a.T)

In [186]: a
Out[186]: 
array([[ 4,  1,  0,  3,  2],
       [ 9,  6,  5,  8,  7],
       [14, 11, 10, 13, 12],
       [19, 16, 15, 18, 17]])

disarrangeでは、 axis=Noneがnp.random.shuffle(a.flat)ように動作することを期待します。

shuffle適切な引数を追加して、その動作を制御する代替シャッフルを実装すれば問題ありませんが、そのAPIの提案はありません。

おそらく、2つの引数をshuffle追加できます： axisとindependent （またはそれらの線に沿ったもの）。 新しい署名は次のようになります。

def shuffle(a, independent=False, axis=0)

independentがFalseの場合、現在のshuffleます。 Trueの場合、 disarrangeように動作します。

ああ、うーん、私はそれが類似のものとより一貫していると思った
sortのような関数:-(。この種の場合はもっといいでしょう
スライスのシャッフルは、idx = arange（...）;のように記述されました。 shuffle（idx）;
multi_dim_array [idx、...]; しかし、誰も私に尋ねませんでした:-)

一致する呼び出し規約があるバージョンのシャッフルで+1しています
np.sortですが、原則としてリストで確認する必要があります。 彼らは持っているかもしれません
最高の名前のような重要な問題に関する提案も:-)

（たぶん「スクランブル」？）

2014年10月11日土曜日午後10時31分、Warren Weckesser < [email protected]

書きました：

シャッフルの現在の動作は、実際にはaxis = Noneのようではありません。 それは扱います
一次元シーケンスとしてのその議論。

[181]の場合：a = np.arange（20）.reshape（4,5）

[182]の場合：np.random.shuffle（a）

[183]​​で：
アウト[183]​​：
array（[[0、1、2、3、4]、
[15、16、17、18、19]、
[5、6、7、8、9]、
[10、11、12、13、14]]）

これはaxis = 0であると解釈できますが、欠落している機能は
1次元スライスの独立したシャッフル。

2次元配列の場合、aTをシャッフルしてaxis = 1をエミュレートできますが、これはできません。
独立したシャッフルを取得します。

[184]の場合：a = np.arange（20）.reshape（4,5）

[185]の場合：np.random.shuffle（aT）

[186]で：
アウト[186]：
array（[[4、1、0、3、2]、
[9、6、5、8、7]、
[14、11、10、13、12]、
[19、16、15、18、17]]）

混乱させて、私はaxis = Noneが次のように振る舞うことを期待します
np.random.shuffle（a.flat）。

追加して代替シャッフルを実装すれば問題ありません
それがどのように振る舞うかを制御するシャッフルするための適切な議論、しかし私はしません
そのAPIの提案があります。

—
このメールに直接返信するか、GitHubで表示してください
https://github.com/numpy/numpy/issues/5173#issuecomment-58765220 。

ナサニエル・J・スミス
ポスドク研究員-情報学-エディンバラ大学
http://vorpus.org

ああ、望ましい振る舞いをsortアナログとして説明するのは良い考えです。

ああ、うーん、私はそれがソートのような類似の機能とより一貫していると思いました

私も驚きました。stackoverflowの質問に対するコメントに基づいて、少なくとも2人の経験豊富なnumpyユーザーが驚きました。 メーリングリストで話し合いを始めます。

平均的なユーザーが現在それを間違えているのなら、それは価値があると思います
他のオプションについて言及する-どちらかを選択するための引数を追加することが_可能_
デフォルトで現在の動作を開始する2つの動作、
そしてある時点で、FutureWarningと叫び声を上げた後、デフォルトに切り替えます
人々に警告するために。 しかし、それは醜い移行です...

2014年10月11日土曜日午後11時、Warren Weckesser < [email protected]

書きました：

ああ、うーん、私はそれが類似のものとより一貫していると思った
ソートのような機能

私も驚きました、そしてstackoverflowに関するコメントに基づいて
質問、少なくとも他の2人の経験豊富なnumpyユーザーは驚いた。 病気
メーリングリストでディスカッションを開始します。

—
このメールに直接返信するか、GitHubで表示してください
https://github.com/numpy/numpy/issues/5173#issuecomment-58766099 。

ナサニエル・J・スミス
ポスドク研究員-情報学-エディンバラ大学
http://vorpus.org

彼らはまた、最高の名前のような重要な問題についての提案を持っているかもしれません。

Sueという名前の関数が必要です。

sort（axis = N）と同様に、この機能が存在すると予想していたので、この機能を+1したかっただけです。 メーリングリストで何か決定はありましたか？

メーリングリストのスレッドは次のとおりです。
http://thread.gmane.org/gmane.comp.python.numeric.general/59014

これは本当に便利です！

私もそれをいただければ幸いです！

https://stackoverflow.com/a/35647011/3401634によると、多次元配列の場合X

np.random.shuffle(X)

と同じです

np.take(X, np.random.permutation(X.shape[0]), axis=0, out=X)

では、実装してみませんか

np.random.shuffle(X, axis=axis)

なので

np.take(X, np.random.permutation(X.shape[axis]), axis=axis, out=X)

デフォルトのaxis=0 ？

これに関するニュースはありますか？ この機能が存在しないことに驚きました。 今のところ、回避策としてnp.apply_along_axisとnp.random.permutationを使用しています。

＃13829のため、これを今すぐ閉じることはできますか？

（ここでの例に取り組んでいるときに、新しいシャッフルコードにバグが見つかったことに注意してください。以下では、https：//github.com/numpy/numpy/pull/14662で提案されている修正を使用しています。マージされました。）

@ wkschwartz 、＃13829の変更は便利ですが、ここで要求された拡張機能ではありません。 ＃13829で追加された軸は、引き続き配列をシャッフルされる1次元シーケンスとして扱います。 新しいaxis引数を使用すると、ユーザーはどの軸を1次元軸として表示するかを指定できますが、軸内で独立したシャッフルは実行されません。

例えば、

In [1]: import numpy as np                                                      

In [2]: rng = np.random.default_rng()                                           

In [3]: x = np.arange(20).reshape(2, 10)                                        

In [4]: x                                                                       
Out[4]: 
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]])

In [5]: rng.shuffle(x, axis=1)                                                  

In [6]: x                                                                       
Out[6]: 
array([[ 5,  9,  6,  4,  7,  0,  3,  2,  1,  8],
       [15, 19, 16, 14, 17, 10, 13, 12, 11, 18]])

行が個別にシャッフルされていないことがわかります。 列は再配置されていますが、各列内の値は同じです。

この問題で要求される動作は、上記のdisarrangeコードのように、独立してシャッフルすることです。

In [10]: x = np.arange(20).reshape(2, 10)                                       

In [11]: x                                                                      
Out[11]: 
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]])

In [12]: disarrange(x, axis=1)                                                  

In [13]: x                                                                      
Out[13]: 
array([[ 4,  3,  7,  8,  0,  6,  5,  2,  9,  1],
       [12, 15, 19, 17, 18, 14, 10, 13, 11, 16]])

おそらく水曜日の会議のためにも、これをもう一度浮かせたいと思います。 choiceとpermutation高次元の機能を追加し、1.18では軸の引数も追加しました（したがって、まったく新しいものです）。

これらはすべて、 shuffle along (individual) axis代わりに、現在のシャッフルロジックであるshuffle the subarrays along this axisを使用します。これは、おそらく何が起こるべきかということです。 つまり、「沿って」ではなく「上」に、または指定された軸内でシャッフルします。

ただし、ほとんどの場合、 axisはNumPyの軸に沿ったものを意味apply_over_axesなど、例外はほとんどありません。 だから私はとても大胆になり、議論の名前をover_axis=0変更しても、混乱を避けるために良いと主張します！ 特に、誤ったシャッフルに気付くのが非常に難しい乱数の場合。

上記のgithub相互参照に記載されているように、 https：//github.com/numpy/numpy/pull/15121に進行中のPRがあり

@WarrenWeckesserはかっこいいですが、私が個人的にもっと緊急に懸念しているのは、新しいAPIで、そして最近では、過剰な意味を拡張したことです。
そして、少なくともaxis引数の名前を変更するなどして、それを部分的に引き戻すべきではないかと思います。 または、今のところ、多次元の動作を完全に取り除くことさえできます...

私はこれを見逃したか、以前は最後まで考えていなかったので少しイライラしているので、おそらく今は過剰反応しているだけです...しかし、正直なところ、現在のロジックは非常に危険だと思います。 それが期待に沿った意味を提供しないことは見逃しがちです。 そして、それはnp.sort使用する意味ではありません。

@seberg 、この問題を突いてくれてありがとう。 APIについてはまだ合意に達する必要があると思います。 ここでは、過去のアイデアの概要を簡単に説明します。 axis 2つの解釈には、「over」と「along」を使用するというあなたの慣習に従います。 この時点で、 shuffleとpermutationのaxisの既存の「沿った」解釈を完全に元に戻すことができるかどうかはわかりませんが、多くの人ができれば嬉しいです。 :)

数年前のメーリングリストの議論の終わりに、解決策はshuffleとpermutationのAPIを変更せず、代わりに軸に沿ってランダム化された2つの新しいメソッドを導入することだと思いました。それ以上の代わりに。 1つのメソッドはインプレースで機能し、もう1つのメソッドはコピーを返します。 当時の私の好みはpermuteとpermutedという名前でしたが、これらの名前にはいくつかの反対意見がありました。 昨年12月のPRで、私はそれらをrandomly_permuteとrandomly_permutedと呼びましたが、これらの名前はプレースホルダーと見なす必要があります。 これらの名前を決定する前に、2つの新しい関数を追加することが正しいアプローチであるかどうかを判断する必要があります。 これ以降、簡潔にするために、提案された新しいメソッドをpermuteおよびpermutedと呼びます。

新しい関数を使用すると、次の関連するGeneratorメソッドが作成されます。

meaning    operate     return
of axis    in-place     copy
-------    --------  -----------
"over"     shuffle   permutation
"along"    permute   permuted

（軸の「上」で動作するメソッド、 shuffleおよびpermutation 、すでに存在します。）

2つの新しいメソッドの代わりに、インプレースとコピーの動作を制御するパラメーターを持つ1つだけを使用することが提案されています。 これには2つの提案があります。

（a） outパラメーターを追加します。 インプレースで作業するには、入力配列をoutとして渡します。 outが提供されていない場合は、シャッフルされたコピーを返します。
（b） copyやinplaceなど、目的の動作を指定するブールフラグを追加します。

新しいメソッドを作成する主な方法は、既存のメソッドに新しいパラメーターを追加して、 axis解釈方法を変更することです。 これらをリストする前に、Robert Kernがメーリングリストスレッドで、追加の引数が実際にどのように使用される可能性があるかについてコメントを繰り返します（ここでは以下に示すindependentパラメーターを参照）。

私には、代わりに2つの方法があるのは完全に正当な理由のようです。
1。 文字通りのTrueまたはFalseを使用しないのはいつか想像できません
このため、実際には2つの異なる方法である必要があります。

（編集の余談：必然的にこのような議論では、名前空間（この場合はGenerator名前空間）の成長の問題が発生します（「名前空間の汚染」と呼ばれることもあります）。物事が同じであれば、名前空間は小さい方が良いです。ただし、ほとんどのAPI設計の決定と同様に、考慮すべきトレードオフがあります。名前空間を小さくして、扱いにくいまたは過度に複雑なAPIを使用してメソッドを作成すると、勝ちません。）

そうは言っても、提案されているshuffleの既存の署名への2つの追加があります。

（1） shuffle(x, axis=0, independent=False) ：ブールフラグindependentは、 axis解釈方法を決定します：False-> "over"、True-> "along"。 （おそらくindependentよりも良い名前があります。）
（2） shuffle(x, axis=0, iaxis=???) ：2番目の引数iaxisは、「沿った」動作の軸を示します。 （これがaxisとどのように相互作用するかは、明確な指定が必要です。おそらく、 iaxis値を指定すると、 axisが無視されます。）

思いついたさまざまなAPIのアイデアをすべてカバーしたと思います。 誰かが他の人を知っているなら、私たちに知らせてください。

ここでAPIを増やして満足しています。 それに反対する理由がたくさんあるかどうかはわかりません。

• 私たちはおそらくそれが有用であることに同意することができます
• 既存の機能でそれを達成するための良い方法はありません
• 全体的な動作の切り替えにkwargを使用することは、通常のパターンではないようです。RoberKernは完全にそこにあったと思います。

ここで起こっていることは、 shuffleとpermutation （そしておそらくchoice ）をインデックス作成操作（つまりtake ）と比較できることだと思います。 axisも同じ意味を使用します。 そして、それが私にとって少し奇妙に感じる理由は、おそらくこの定義の欠点であり、通常の配列認識関数とは異なり、NDに一般化することはできません（ arr[..., index]を使用すると、インデックス付け自体でも一般化できます。それだけです。配列のスタックに一般化し、個々の配列に対して以前と同じ操作を実行します）。
ことを注意take_along_axisのための意味"に沿って" NDが一般化提供take （それは複雑なようであっても）正しくNDに。 apply_along_axisとapply_over_axisは、「over」が正しい単語かどうかはわかりませんが、「over」を取得した場所です...

ここでは、 permutation （簡単に変更することはできませんが、 shuffled必要があります）が実際の外れ値であることがわかります。 shuffle - shuffled 、 permute - permutedので、物事はかなり明確で合理的に見え始めたと思います。 shuffledを追加して、 permutation非推奨を開始することをいとわない人permutationは、 itertools.permutations 、FWIWとの動作もあまり一貫していません。

permutation 、 permute 、 permutedは、動作が異なる類似した名前の紛らわしいトリプルだと思います。 これを回避することは（おそらく長期的には）良いでしょう。

既存のAPIを拡張するのは簡単なようですが、動作を根本的に変えるキーワードがないという@rkernのポイントが

インプレースとインプレースではない場合、NumPyには代替のout=スペルがあると思います。 しかし、シャッフルはインプレースであるため、解決策ではなく、シャッフルするのは良いことです。 permuted （つまり、 permuted(arr, out=arr)はpermute(arr)と同じ意味ですが、シャッフルとは異なり、 ndarray変換されます）。
いずれにせよ、新しい名前空間をクリーンアップするためにshuffledを優先して、 permutationを廃止する計画が好きです。

この問題（および関連するPR（https://github.com/numpy/numpy/pull/15121））に戻ります。

元の問題を作成し、現在のshuffle APIで問題を説明しようとしたとき、問題を説明する1つの方法は、ほとんどの人がaxis引数を期待することであると指摘されました。 shuffleのsortのaxis引数と同じように動作します。 sortとの類似性は非常に優れているため、インプレース操作と並べ替えのためのコピーの問題をどのように処理するかを確認することも役立つ場合があります。 関数numpy.sort()は配列のような引数を受け入れ、ソートされたコピーを返します。 インプレースソートの場合、 ndarray sort()メソッドを使用します。 これは既存のndarrayのメソッドであるため、インプレース操作は明確です。 gh-15121では、引数をランダムに並べ替えるインプレース関数の引数は、任意の配列のようなものではなく、ndarrayである必要がnp.arrayが行うすべての形状検出を実行する必要があり、不変であることが判明した入力も拒否する必要があります（たとえば、 [(1, 2, 3, 4), (5, 6, 7, 8)]インプレースシャッフルを実行することはできません）。 ）。

シャッフルされたコピーを返す関数と、インプレースでシャッフルするndarrayメソッドを使用して、 sort APIを本当に複製できれば素晴らしいと思いますが、そのようなものを追加することはないと思います。 ndarrayクラスのメソッドは、受け入れられる可能性があります。

そして、その場でシャッフルするndarray _method_ですが、そのようなメソッドをndarrayクラスに追加しても受け入れられる可能性はないと思います。

シングルトンジェネレータがなければ、これを実現することは不可能だと思います。

@bashtageは書いた

ここでは、 permutation （簡単に変更することはできませんが、 shuffled必要があります）が実際の外れ値であることがわかります。 [もしそれが] shuffle-shuffled 、 permute-permutedだったら、物事はかなり明確で合理的に見え始めると思います。 shuffledを追加して、 permutation非推奨を開始することをいとわない人

これは、メーリングリストの議論（一種）が2014年に収束したものです。Nathanielsの提案へのリンクは次のとおりです： https ：

彼のscramble[d]は、 https：//github.com/numpy/numpy/pull/15121でrandomly_permute[d]と呼んでいます。

permutation代わりにshuffledを追加し、軸permute[d]に沿って動作する新しいメソッドを呼び出すと、関連する関数のテーブルは次のようになります。

meaning    operate
of axis    in-place   return copy
-------    ---------  -----------
"over"     shuffle    shuffled
"along"    permute    permuted

一貫性があります。 このバージョンのAPIでは、どのメソッドにもoutパラメーターがありません。

https://github.com/numpy/numpy/pull/15121で、最近別のメソッドを追加しました。このメソッドは、 out引数がどのようになるかを示す、不格好で明らかに一時的な名前permuted_with_outです。使用済み。 outパラメーターを使用し、既存のメソッドshuffleとpermutationの名前を使用すると、テーブルは次のようになります。

meaning    operate
of axis    in-place                           return copy
-------    ---------------------------------  --------------------
"over"     shuffle(x, axis)                   permutation(x, axis)
"along"    permuted_with_out(x, axis, out=x)  permuted_with_out(x, axis)

ただし、 outパラメータを導入する場合は、一貫性を保ち、 permutationでも使用する必要があります。 また、 permutationをshuffled置き換えることも検討できます。 また、新しいshuffledメソッドにはoutパラメーターがあり、インプレース操作が可能であるため、 shuffleは冗長になり、 permutationとともに非推奨になる可能性があります。 次に、 shuffledとpermutedの「素敵な」名前に切り替えると、テーブルは次のようになります。

    meaning    operate
    of axis    in-place                  return copy
    -------    ------------------------  -----------------
    "over"     shuffled(x, axis, out=x)  shuffled(x, axis)
    "along"    permuted(x, axis, out=x)  permuted(x, axis)

outパラメータは、インプレースで動作するためだけのものではないことに注意してください。 これにより、出力配列を再利用できるため、一時配列の作成を回避できる可能性があります。 これは、 shuffle/shuffled/permute/permuted APIに対するこのAPIの利点ですが、その利点が実際にどれほど重要であるかはわかりません。 このAPIの欠点は、 shuffleとpermutationの2つのメソッドが廃止されることです。 これらは、当面の影響を軽減するために、しばらくの間「ソフト」な非推奨になる可能性があります（つまり、ドキュメントでの使用を強調しませんが、実際には非推奨の警告をしばらく追加しないでください）。

これが、変更の2つの主要な候補の要約です。 shuffle/shuffled/permute/permutedバージョン、またはshuffled/permutedとoutパラメーターを持つバージョンがあります。 2014年に、誰かが議論された変更を実装するために飛び込んだ場合、おそらくすでにshuffle/shuffled/permute/permutedバージョンがあります。 ただし、 outを使用するバージョンには、いくつかの（小さい？重要ではない？）利点があります。4つではなく2つの名前であり、 out使用すると、ユーザーが一時変数を少なくできる可能性があります。 どちらかでよかったです。

人々はどう思いますか？

あなたがリストした3つのシナリオのうち、順番に1、3、2よりかなり後ろにランク付けします。まったく異なることをしている2つの順列は、大きな混乱の原因のようです。 私の個人的な好みは、機能にアクセスするためにoutを強制的に使用することを避けることです。 私は常に、いくつかのシナリオで意味のあるパフォーマンスの選択として考えています。 機能にアクセスするためだけに使い切るように生徒に教えたくはありません。 私はまた、ケース3にすることを前提としますx = shuffled(x, axis, out=x)もうreturn xではなくreturn Noneが所定の位置にあるとき、そう、1がで終わるかもしれないとx 3回登場。

私の個人的な好みは、機能にアクセスするためにoutを強制的に使用することを避けることです。 私は常に、いくつかのシナリオで意味のあるパフォーマンスの選択として考えています。

しかし、その場でシャッフルすることはパフォーマンスの選択ですよね？

しかし、その場でシャッフルすることはパフォーマンスの選択ですよね？

インプレースは、利用可能な場合、コーディングスタイルの選択にもなります。 おそらく紛らわしく、おそらくエラーが発生しやすいものです。

私の個人的な見解は、f（x、out = x）は、何かをすばやく達成するための非常に非自明な方法として使用されることがあるため、常に少し魔法のように感じるときです。 f（x、inplace = True）は、他に何も見えないにもかかわらず、はるかに明確に見えます（ほとんど削除された古いパンダパターンに少し似ています）。

本当ですが、NumPyでは通常out=...を使用して綴られているように見えるコーディングスタイルの選択です（インプレース演算子またはメソッドを使用している場合を除く）。 あるいは、現在ほとんどの場合、NumPyが積極的に簡単にしようとしないのはコーディングスタイルの選択かもしれません...

私はそれが少し魔法であると認めます、そしてinplace= kwargはそれほど魔法ではないかもしれませんが、本当の優先順位がないのですか？ そして、それがそれほど魔法ではないと思われる主な理由が、インプレースシャッフルがここのアルゴリズムのコアにあることであるかどうかはわかりません。 アルゴリズムの詳細はほとんどの学生にとってそれほど重要ではなく、最終的にout=を使用すると、ほぼ1つのコピーと関連するメモリ帯域幅が保護され、ufuncsに匹敵します。 （まあまあ、ufuncsの場合もout=inputは多少魔法のようですが、その一般的な魔法と既知のパターン–上級ユーザー向けです。）

np.shuffled(x, out=x)は、書くのが少し面倒で、読むのがやや遅いかもしれませんが、動作が何であるかについては非常に明確に見えます。 自明ではない部分は、パフォーマンスへの影響のみのように見えます。これは、上級ユーザーが心配する必要のある問題のように思えます。

outの使用を提唱している人への架空の質問：既存の関数numpy.sortとndarray.sort 、現在ソート関数を追加している場合、推奨されるAPIはnumpy.sorted(a, axis=-1, kind=None, order=None, out=None) （インプレースソート用のメソッドndarray.sortを実装する必要はありません）？

ndarray.sortはlist.sortモデルにしているため、APIの選択はおそらく賢明です。 そうは言っても、私はnp.sortが存在せず、代わりにnp.sorted(..., out=...)を支持していたでしょう。

はい、 np.sortはnp.sortedという名前を付ける必要があると思います（結局のところ、Pythonのsorted()同じです）。 メソッドだけがインプレース動作を持っているので、私はあまり心配していません。

「メソッドndarray.sortを実装する必要がない」についてはよくわかりません。 メソッド（またはそのインプレースの動作）に問題はありません。 この方法についての質問は、便利な方法を簡単に提供することが十分に重要であると私たちが感じるかどうかだけです。
インプレース関数バージョンを使用することにも問題はないと思います。 インプレースではないバージョンは、新しいユーザーにとってはより良いように見え、 out=パターンは私にとって十分に一般的であり、上級ユーザーには十分なサービスが提供されます。

「ndarray.sortメソッドを実装する必要がない」かどうかはわかりません。 メソッド（またはそのインプレースの動作）に問題はありません。

それは私のAPI思考実験の一部でした。 私たちが今持っているものに何か問題があることを意味するつもりはありませんでした。 ゼロから始めた場合、つまりリストのPython APIとの一致に関心がないという仮定に追加すると、並べ替えに推奨されるAPIはnumpy.sorted(..., out=...)なると言っていました

もう一つの問題なので、仮定的ではない：使用している場合はout numpyの全体APIの一貫性のために、そして、ここでは好ましい選択肢である、私たちは最終的に追加することを計画すべきであるoutにnumpy.sort 、 numpy.partition 、 numpy.argsort 、そして、まあ、現在それを持っていない

はい、私の意見では、ufuncsと同じセマンティクスを持つout= kwargを追加することは、実質的にすべてのNumPyAPI関数に適しています。 out引数がない場合は、通常、拡張が行われるのを待っています（ただし、実際には小さな拡張であり、まれに、コードの複雑さをあまり追加する価値がない場合もあります）。