Python のスライス表記法についての適切な説明が必要です (参照はプラスです)。
私にとって、この表記法は少し理解する必要があります。
非常に強力に見えますが、私はそれについてよく理解していません。
2483213 次
33 に答える
5838
それは本当に簡単です：
a[start:stop] # items start through stop-1
a[start:] # items start through the rest of the array
a[:stop] # items from the beginning through stop-1
a[:] # a copy of the whole array
step上記のいずれかで使用できる値もあります。
a[start:stop:step] # start through not past stop, by step
覚えておくべき重要な点は、値が選択したスライスにない:stop最初の値を表すことです。したがって、との違いは、選択された要素の数です（1の場合、デフォルト）。stopstartstep
もう1つの機能は、startまたはstopが負の数である可能性があることです。これは、配列の最初ではなく最後から数えることを意味します。それで：
a[-1] # last item in the array
a[-2:] # last two items in the array
a[:-2] # everything except the last two items
同様にstep、負の数である可能性があります。
a[::-1] # all items in the array, reversed
a[1::-1] # the first two items, reversed
a[:-3:-1] # the last two items, reversed
a[-3::-1] # everything except the last two items, reversed
要求するアイテムよりもアイテムが少ない場合、Pythonはプログラマーに親切です。たとえば、要求して要素が1つしかない場合、エラーではなく空のリストが表示されますa[:-2]。aエラーを好む場合もあるので、これが発生する可能性があることに注意する必要があります。
slice()オブジェクトとの関係
スライス演算子[]は、実際には上記のコードで、表記法（内でのみ有効）をslice()使用するオブジェクトで使用されています。つまり、次のようになります。:[]
a[start:stop:step]
と同等です：
a[slice(start, stop, step)]
スライスオブジェクトも、引数の数に応じて、と同様にわずかに異なる動作をします。range()つまり、両方slice(stop)とslice(start, stop[, step])がサポートされます。与えられた引数の指定をスキップするには、を使用することができますNone。そのため、ega[start:]は。と同等a[slice(start, None)]またはa[::-1]同等a[slice(None, None, -1)]です。
:ベースの表記法は単純なスライスには非常に役立ちますが、slice()オブジェクトを明示的に使用すると、プログラムによるスライスの生成が単純化されます。
于 2009-02-03T22:48:24.687 に答える
633
Pythonチュートリアルでは、それについて説明しています（スライスに関する部分に到達するまで、少し下にスクロールします）。
ASCIIアート図は、スライスがどのように機能するかを思い出すのにも役立ちます。
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
スライスがどのように機能するかを覚える1つの方法は、インデックスを文字間を指すものと考えることです。最初の文字の左端には0の番号が付けられます。次に、n文字の文字列の最後の文字の右端にインデックスnが付きます。
于 2009-02-03T22:49:04.247 に答える
477
文法によって許可される可能性を列挙します。
>>> seq[:] # [seq[0], seq[1], ..., seq[-1] ]
>>> seq[low:] # [seq[low], seq[low+1], ..., seq[-1] ]
>>> seq[:high] # [seq[0], seq[1], ..., seq[high-1]]
>>> seq[low:high] # [seq[low], seq[low+1], ..., seq[high-1]]
>>> seq[::stride] # [seq[0], seq[stride], ..., seq[-1] ]
>>> seq[low::stride] # [seq[low], seq[low+stride], ..., seq[-1] ]
>>> seq[:high:stride] # [seq[0], seq[stride], ..., seq[high-1]]
>>> seq[low:high:stride] # [seq[low], seq[low+stride], ..., seq[high-1]]
もちろん、 の場合(high-low)%stride != 0、終点は より少し低くなりhigh-1ます。
が負の場合stride、カウント ダウンしているため、順序が少し変更されます。
>>> seq[::-stride] # [seq[-1], seq[-1-stride], ..., seq[0] ]
>>> seq[high::-stride] # [seq[high], seq[high-stride], ..., seq[0] ]
>>> seq[:low:-stride] # [seq[-1], seq[-1-stride], ..., seq[low+1]]
>>> seq[high:low:-stride] # [seq[high], seq[high-stride], ..., seq[low+1]]
拡張スライシング (カンマと省略記号を使用) は、主に特別なデータ構造 (NumPy など) でのみ使用されます。基本シーケンスはそれらをサポートしていません。
>>> class slicee:
... def __getitem__(self, item):
... return repr(item)
...
>>> slicee()[0, 1:2, ::5, ...]
'(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)'
于 2009-02-03T23:08:22.477 に答える
394
上記の回答では、スライスの割り当てについては説明していません。スライスの割り当てを理解するには、ASCII アートに別の概念を追加すると役立ちます。
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
Slice position: 0 1 2 3 4 5 6
Index position: 0 1 2 3 4 5
>>> p = ['P','y','t','h','o','n']
# Why the two sets of numbers:
# indexing gives items, not lists
>>> p[0]
'P'
>>> p[5]
'n'
# Slicing gives lists
>>> p[0:1]
['P']
>>> p[0:2]
['P','y']
ヒューリスティックの 1 つは、ゼロから n までのスライスの場合、次のように考えることです。
>>> p[5] # the last of six items, indexed from zero
'n'
>>> p[0:5] # does NOT include the last item!
['P','y','t','h','o']
>>> p[0:6] # not p[0:5]!!!
['P','y','t','h','o','n']
別のヒューリスティックは、「任意のスライスについて、開始をゼロに置き換え、前のヒューリスティックを適用してリストの最後を取得し、最初の数を数えて最初から項目を切り取る」です。
>>> p[0:4] # Start at the beginning and count out 4 items
['P','y','t','h']
>>> p[1:4] # Take one item off the front
['y','t','h']
>>> p[2:4] # Take two items off the front
['t','h']
# etc.
スライス代入の最初の規則は、スライスはリストを返すため、スライス代入にはリスト (またはその他の反復可能) が必要であるということです。
>>> p[2:3]
['t']
>>> p[2:3] = ['T']
>>> p
['P','y','T','h','o','n']
>>> p[2:3] = 't'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only assign an iterable
スライス割り当ての 2 番目のルールは、これも上で確認できますが、スライスのインデックス付けによってリストのどの部分が返されても、それはスライス割り当てによって変更されるのと同じ部分であるということです。
>>> p[2:4]
['T','h']
>>> p[2:4] = ['t','r']
>>> p
['P','y','t','r','o','n']
スライス割り当ての 3 番目の規則は、割り当てられたリスト (反復可能) は同じ長さである必要はないということです。インデックス付きのスライスは単にスライスされ、割り当てられているものにまとめて置き換えられます。
>>> p = ['P','y','t','h','o','n'] # Start over
>>> p[2:4] = ['s','p','a','m']
>>> p
['P','y','s','p','a','m','o','n']
慣れるのが最も難しいのは、空のスライスへの割り当てです。ヒューリスティック 1 と 2 を使用すると、空のスライスのインデックス作成について簡単に理解できます。
>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
['P','y','t','h']
>>> p[1:4]
['y','t','h']
>>> p[2:4]
['t','h']
>>> p[3:4]
['h']
>>> p[4:4]
[]
そして、それを確認したら、空のスライスへのスライスの割り当ても理にかなっています。
>>> p = ['P','y','t','h','o','n']
>>> p[2:4] = ['x','y'] # Assigned list is same length as slice
>>> p
['P','y','x','y','o','n'] # Result is same length
>>> p = ['P','y','t','h','o','n']
>>> p[3:4] = ['x','y'] # Assigned list is longer than slice
>>> p
['P','y','t','x','y','o','n'] # The result is longer
>>> p = ['P','y','t','h','o','n']
>>> p[4:4] = ['x','y']
>>> p
['P','y','t','h','x','y','o','n'] # The result is longer still
スライスの 2 番目の番号 (4) を変更していないため、空のスライスに割り当てている場合でも、挿入されたアイテムは常に「o」に対してスタックされることに注意してください。したがって、空のスライス割り当ての位置は、空でないスライス割り当ての位置の論理拡張です。
少し戻って、スライスの始まりをカウントアップするプロセスを続けるとどうなりますか?
>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
['P','y','t','h']
>>> p[1:4]
['y','t','h']
>>> p[2:4]
['t','h']
>>> p[3:4]
['h']
>>> p[4:4]
[]
>>> p[5:4]
[]
>>> p[6:4]
[]
スライスを使用すると、完了したら完了です。逆方向にスライスし始めません。Python では、負の数を使用して明示的に要求しない限り、負のストライドは得られません。
>>> p[5:3:-1]
['n','o']
「完了したら、完了」というルールには、いくつかの奇妙な結果があります。
>>> p[4:4]
[]
>>> p[5:4]
[]
>>> p[6:4]
[]
>>> p[6]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
実際、インデックス作成と比較して、Python スライシングは奇妙にエラー防止です。
>>> p[100:200]
[]
>>> p[int(2e99):int(1e99)]
[]
これは便利な場合もありますが、やや奇妙な動作につながる可能性もあります。
>>> p
['P', 'y', 't', 'h', 'o', 'n']
>>> p[int(2e99):int(1e99)] = ['p','o','w','e','r']
>>> p
['P', 'y', 't', 'h', 'o', 'n', 'p', 'o', 'w', 'e', 'r']
アプリケーションによっては、それが期待していたものである場合もあれば、そうでない場合もあります。
以下は、私の元の回答のテキストです。多くの人に役立ってきたので、削除したくありませんでした。
>>> r=[1,2,3,4]
>>> r[1:1]
[]
>>> r[1:1]=[9,8]
>>> r
[1, 9, 8, 2, 3, 4]
>>> r[1:1]=['blah']
>>> r
[1, 'blah', 9, 8, 2, 3, 4]
これにより、スライスとインデックス作成の違いも明確になる場合があります。
于 2011-01-18T21:37:57.723 に答える
154
そして、スライス構文を最初に見たとき、すぐにはわからなかったことがいくつかあります。
>>> x = [1,2,3,4,5,6]
>>> x[::-1]
[6,5,4,3,2,1]
シーケンスを逆にする簡単な方法！
そして、何らかの理由で、逆の順序で 2 つおきの項目が必要な場合は、次のようにします。
>>> x = [1,2,3,4,5,6]
>>> x[::-2]
[6,4,2]
于 2009-02-03T23:15:02.633 に答える
106
Python 2.7 では
Python でのスライス
[a:b:c]
len = length of string, tuple or list
c -- default is +1. The sign of c indicates forward or backward, absolute value of c indicates steps. Default is forward with step size 1. Positive means forward, negative means backward.
a -- When c is positive or blank, default is 0. When c is negative, default is -1.
b -- When c is positive or blank, default is len. When c is negative, default is -(len+1).
インデックスの割り当てを理解することは非常に重要です。
In forward direction, starts at 0 and ends at len-1
In backward direction, starts at -1 and ends at -len
[a:b:c] と言うときは、c の符号 (前方または後方) に応じて、a で始まり b で終わる (b 番目のインデックスの要素を除く) と言っています。上記のインデックス付け規則を使用すると、この範囲内の要素のみが検索されることに注意してください。
-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1
しかし、この範囲は両方向に無限に続きます。
...,-len -2 ,-len-1,-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1, len, len +1, len+2 , ....
例えば：
0 1 2 3 4 5 6 7 8 9 10 11
a s t r i n g
-9 -8 -7 -6 -5 -4 -3 -2 -1
上記の a、b、c のルールを使用してトラバースするときに、選択した a、b、および c が上記の範囲との重複を許容する場合、(トラバーサル中にタッチされた) 要素を含むリストを取得するか、空のリストを取得します。
最後に 1 つ: a と b が等しい場合、空のリストも取得します。
>>> l1
[2, 3, 4]
>>> l1[:]
[2, 3, 4]
>>> l1[::-1] # a default is -1 , b default is -(len+1)
[4, 3, 2]
>>> l1[:-4:-1] # a default is -1
[4, 3, 2]
>>> l1[:-3:-1] # a default is -1
[4, 3]
>>> l1[::] # c default is +1, so a default is 0, b default is len
[2, 3, 4]
>>> l1[::-1] # c is -1 , so a default is -1 and b default is -(len+1)
[4, 3, 2]
>>> l1[-100:-200:-1] # Interesting
[]
>>> l1[-1:-200:-1] # Interesting
[4, 3, 2]
>>> l1[-1:-1:1]
[]
>>> l1[-1:5:1] # Interesting
[4]
>>> l1[1:-7:1]
[]
>>> l1[1:-7:-1] # Interesting
[3, 2]
>>> l1[:-2:-2] # a default is -1, stop(b) at -2 , step(c) by 2 in reverse direction
[4]
于 2012-10-22T05:33:39.697 に答える
99
http://wiki.python.org/moin/MovingToPythonFromOtherLanguagesでこの素晴らしいテーブルを見つけました
Python indexes and slices for a six-element list.
Indexes enumerate the elements, slices enumerate the spaces between the elements.
Index from rear: -6 -5 -4 -3 -2 -1 a=[0,1,2,3,4,5] a[1:]==[1,2,3,4,5]
Index from front: 0 1 2 3 4 5 len(a)==6 a[:5]==[0,1,2,3,4]
+---+---+---+---+---+---+ a[0]==0 a[:-2]==[0,1,2,3]
| a | b | c | d | e | f | a[5]==5 a[1:2]==[1]
+---+---+---+---+---+---+ a[-1]==5 a[1:-1]==[1,2,3,4]
Slice from front: : 1 2 3 4 5 : a[-2]==4
Slice from rear: : -5 -4 -3 -2 -1 :
b=a[:]
b==[0,1,2,3,4,5] (shallow copy of a)于 2011-09-06T06:50:08.920 に答える
69
for少し使用した後、最も簡単な説明は、ループ内の引数とまったく同じであることに気付きました...
(from:to:step)
それらのいずれかはオプションです。
(:to:step)
(from::step)
(from:to)
次に、負のインデックス付けでは、文字列の長さを負のインデックスに追加して理解する必要があります。
これはとにかく私のために働きます...
于 2009-02-19T20:52:44.687 に答える
53
それがどのように機能するかを覚えるのが簡単だと思います。そうすれば、特定の開始/停止/ステップの組み合わせを理解できます。
最初に理解することは有益range()です：
def range(start=0, stop, step=1): # Illegal syntax, but that's the effect
i = start
while (i < stop if step > 0 else i > stop):
yield i
i += step
から開始しstart、増分しstep、に到達しないでくださいstop。とてもシンプルです。
ネガティブステップについて覚えておくべきことはstop、それが高いか低いかにかかわらず、常に除外された端であるということです。同じスライスを逆の順序で使用する場合は、反転を個別に実行する方がはるかにクリーンです。たとえば'abcde'[1:-2][::-1]、左から1文字、右から2文字をスライスしてから、反転します。（も参照してくださいreversed()。）
シーケンスのスライスは同じですが、最初に負のインデックスを正規化し、シーケンスの外に出ることはできません。
TODO：以下のコードには、abs（step）>1の場合に「シーケンスの外に出ない」というバグがありました。正しいパッチを当てたと思いますが、わかりづらいです。
def this_is_how_slicing_works(seq, start=None, stop=None, step=1):
if start is None:
start = (0 if step > 0 else len(seq)-1)
elif start < 0:
start += len(seq)
if not 0 <= start < len(seq): # clip if still outside bounds
start = (0 if step > 0 else len(seq)-1)
if stop is None:
stop = (len(seq) if step > 0 else -1) # really -1, not last element
elif stop < 0:
stop += len(seq)
for i in range(start, stop, step):
if 0 <= i < len(seq):
yield seq[i]
詳細について心配する必要はありません。シーケンス全体を提供するために、is None省略しstartたり、stop常に正しいことを行ったりすることを忘れないでください。
最初に負のインデックスを正規化すると、開始および/または停止を最後から独立してカウントでき'abcde'[1:-2] == 'abcde'[1:3] == 'bc'ますrange(1,-2) == []。正規化は「長さを法として」と考えられることもありますが、長さを1回だけ追加することに注意してください。たとえば'abcde'[-53:42]、文字列全体です。
于 2012-03-29T10:15:12.803 に答える
42
Index:
------------>
0 1 2 3 4
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
0 -4 -3 -2 -1
<------------
Slice:
<---------------|
|--------------->
: 1 2 3 4 :
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
: -4 -3 -2 -1 :
|--------------->
<---------------|
これがPythonでリストをモデル化するのに役立つことを願っています。
参照：http ：//wiki.python.org/moin/MovingToPythonFromOtherLanguages
于 2013-02-04T07:20:03.337 に答える
42
私はそれについて自分で考える「要素間のインデックスポイント」方法を使用しますが、他の人がそれを理解するのに役立つことがある説明の1つの方法は次のとおりです。
mylist[X:Y]
X は、必要な最初の要素のインデックスです。
Y は、不要な最初の要素のインデックスです。
于 2009-02-06T21:16:28.940 に答える
39
これは私が初心者にスライスを教える方法です:
インデックス作成とスライスの違いを理解する:
Wiki Python には、インデックス作成とスライスを明確に区別するこの驚くべき図があります。
これは、6 つの要素を含むリストです。スライスをよりよく理解するために、このリストを 6 つのボックスを 1 組にまとめたものと考えてください。各ボックスにはアルファベットが入っています。
インデックス作成は、ボックスの内容を処理するようなものです。任意のボックスの内容を確認できます。ただし、一度に複数のボックスの内容を確認することはできません。ボックスの中身を入れ替えることもできます。ただし、1 つのボックスに 2 つのボールを配置したり、一度に 2 つのボールを交換したりすることはできません。
In [122]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']
In [123]: alpha
Out[123]: ['a', 'b', 'c', 'd', 'e', 'f']
In [124]: alpha[0]
Out[124]: 'a'
In [127]: alpha[0] = 'A'
In [128]: alpha
Out[128]: ['A', 'b', 'c', 'd', 'e', 'f']
In [129]: alpha[0,1]
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-129-c7eb16585371> in <module>()
----> 1 alpha[0,1]
TypeError: list indices must be integers, not tuple
スライスは箱そのものを扱うようなものです。最初の箱を手に取り、別のテーブルに置くことができます。箱を拾うために必要なのは、箱の始まりと終わりの位置だけです。
最初の 3 つのボックス、最後の 2 つのボックス、または 1 から 4 までのすべてのボックスを選択することもできます。したがって、最初と最後がわかっている場合は、任意のボックスのセットを選択できます。これらの位置は、開始位置と停止位置と呼ばれます。
興味深いのは、一度に複数のボックスを交換できることです。また、複数のボックスを好きな場所に配置することもできます。
In [130]: alpha[0:1]
Out[130]: ['A']
In [131]: alpha[0:1] = 'a'
In [132]: alpha
Out[132]: ['a', 'b', 'c', 'd', 'e', 'f']
In [133]: alpha[0:2] = ['A', 'B']
In [134]: alpha
Out[134]: ['A', 'B', 'c', 'd', 'e', 'f']
In [135]: alpha[2:2] = ['x', 'xx']
In [136]: alpha
Out[136]: ['A', 'B', 'x', 'xx', 'c', 'd', 'e', 'f']
ステップでスライス:
これまで、ボックスを継続的に選択してきました。ただし、個別にピックアップする必要がある場合もあります。たとえば、2 つおきの箱を拾うことができます。最後から 3 つおきのボックスをピックアップすることもできます。この値はステップ サイズと呼ばれます。これは、連続するピックアップ間のギャップを表します。ボックスを最初から最後まで選択する場合、またはその逆の場合、ステップ サイズは正の値にする必要があります。
In [137]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']
In [142]: alpha[1:5:2]
Out[142]: ['b', 'd']
In [143]: alpha[-1:-5:-2]
Out[143]: ['f', 'd']
In [144]: alpha[1:5:-2]
Out[144]: []
In [145]: alpha[-1:-5:2]
Out[145]: []
Python が不足しているパラメータを見つける方法:
スライスするときにパラメーターを省略すると、Python は自動的にそれを見つけようとします。
CPythonのソース コードを確認すると、指定されたパラメータのスライスのインデックスを計算する PySlice_GetIndicesEx() という関数が見つかります。Python で論理的に同等のコードを次に示します。
この関数は、スライス用の Python オブジェクトとオプションのパラメーターを受け取り、要求されたスライスの開始、停止、ステップ、およびスライスの長さを返します。
def py_slice_get_indices_ex(obj, start=None, stop=None, step=None):
length = len(obj)
if step is None:
step = 1
if step == 0:
raise Exception("Step cannot be zero.")
if start is None:
start = 0 if step > 0 else length - 1
else:
if start < 0:
start += length
if start < 0:
start = 0 if step > 0 else -1
if start >= length:
start = length if step > 0 else length - 1
if stop is None:
stop = length if step > 0 else -1
else:
if stop < 0:
stop += length
if stop < 0:
stop = 0 if step > 0 else -1
if stop >= length:
stop = length if step > 0 else length - 1
if (step < 0 and stop >= start) or (step > 0 and start >= stop):
slice_length = 0
elif step < 0:
slice_length = (stop - start + 1)/(step) + 1
else:
slice_length = (stop - start - 1)/(step) + 1
return (start, stop, step, slice_length)
これは、スライスの背後にあるインテリジェンスです。Python にはスライスと呼ばれる組み込み関数があるため、いくつかのパラメーターを渡して、欠落しているパラメーターがどれだけスマートに計算されるかを確認できます。
In [21]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']
In [22]: s = slice(None, None, None)
In [23]: s
Out[23]: slice(None, None, None)
In [24]: s.indices(len(alpha))
Out[24]: (0, 6, 1)
In [25]: range(*s.indices(len(alpha)))
Out[25]: [0, 1, 2, 3, 4, 5]
In [26]: s = slice(None, None, -1)
In [27]: range(*s.indices(len(alpha)))
Out[27]: [5, 4, 3, 2, 1, 0]
In [28]: s = slice(None, 3, -1)
In [29]: range(*s.indices(len(alpha)))
Out[29]: [5, 4]
注:この投稿は、もともと私のブログThe Intelligence Behind Python Slicesで書かれたものです。
于 2015-03-24T16:08:36.130 に答える
34
スライス割り当てを使用して、リストから 1 つまたは複数の要素を削除することもできます。
r = [1, 'blah', 9, 8, 2, 3, 4]
>>> r[1:4] = []
>>> r
[1, 2, 3, 4]
于 2013-04-05T01:59:41.697 に答える
33
これはいくつかの追加情報のためだけです...以下のリストを検討してください
>>> l=[12,23,345,456,67,7,945,467]
リストを逆にするための他のいくつかのトリック：
>>> l[len(l):-len(l)-1:-1]
[467, 945, 7, 67, 456, 345, 23, 12]
>>> l[:-len(l)-1:-1]
[467, 945, 7, 67, 456, 345, 23, 12]
>>> l[len(l)::-1]
[467, 945, 7, 67, 456, 345, 23, 12]
>>> l[::-1]
[467, 945, 7, 67, 456, 345, 23, 12]
>>> l[-1:-len(l)-1:-1]
[467, 945, 7, 67, 456, 345, 23, 12]
于 2012-03-22T17:20:59.600 に答える
29
原則として、多くのハードコーディングされたインデックス値を含むコードを記述すると、読みやすさとメンテナンスの混乱につながります。たとえば、1 年後にコードに戻った場合、それを見て、それを書いたときに何を考えていたのか疑問に思うでしょう。示されているソリューションは、コードが実際に行っていることをより明確に示す方法にすぎません。一般に、組み込みの slice() は、スライスが許可されている場所ならどこでも使用できるスライス オブジェクトを作成します。例えば：
>>> items = [0, 1, 2, 3, 4, 5, 6]
>>> a = slice(2, 4)
>>> items[2:4]
[2, 3]
>>> items[a]
[2, 3]
>>> items[a] = [10,11]
>>> items
[0, 1, 10, 11, 4, 5, 6]
>>> del items[a]
>>> items
[0, 1, 4, 5, 6]
スライス インスタンス s がある場合、その s.start、s.stop、および s.step 属性をそれぞれ調べることで、それに関する詳細情報を取得できます。例えば：
>>> a = slice(10, 50, 2) >>> a.start 10 >>> a.stop 50 >>> a.step 2 >>>
于 2013-12-07T16:52:45.600 に答える
28
于 2017-01-09T12:52:44.083 に答える
16
#!/usr/bin/env python
def slicegraphical(s, lista):
if len(s) > 9:
print """Enter a string of maximum 9 characters,
so the printig would looki nice"""
return 0;
# print " ",
print ' '+'+---' * len(s) +'+'
print ' ',
for letter in s:
print '| {}'.format(letter),
print '|'
print " ",; print '+---' * len(s) +'+'
print " ",
for letter in range(len(s) +1):
print '{} '.format(letter),
print ""
for letter in range(-1*(len(s)), 0):
print ' {}'.format(letter),
print ''
print ''
for triada in lista:
if len(triada) == 3:
if triada[0]==None and triada[1] == None and triada[2] == None:
# 000
print s+'[ : : ]' +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] == None and triada[1] == None and triada[2] != None:
# 001
print s+'[ : :{0:2d} ]'.format(triada[2], '','') +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] == None and triada[1] != None and triada[2] == None:
# 010
print s+'[ :{0:2d} : ]'.format(triada[1]) +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] == None and triada[1] != None and triada[2] != None:
# 011
print s+'[ :{0:2d} :{1:2d} ]'.format(triada[1], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] != None and triada[1] == None and triada[2] == None:
# 100
print s+'[{0:2d} : : ]'.format(triada[0]) +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] != None and triada[1] == None and triada[2] != None:
# 101
print s+'[{0:2d} : :{1:2d} ]'.format(triada[0], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] != None and triada[1] != None and triada[2] == None:
# 110
print s+'[{0:2d} :{1:2d} : ]'.format(triada[0], triada[1]) +' = ', s[triada[0]:triada[1]:triada[2]]
elif triada[0] != None and triada[1] != None and triada[2] != None:
# 111
print s+'[{0:2d} :{1:2d} :{2:2d} ]'.format(triada[0], triada[1], triada[2]) +' = ', s[triada[0]:triada[1]:triada[2]]
elif len(triada) == 2:
if triada[0] == None and triada[1] == None:
# 00
print s+'[ : ] ' + ' = ', s[triada[0]:triada[1]]
elif triada[0] == None and triada[1] != None:
# 01
print s+'[ :{0:2d} ] '.format(triada[1]) + ' = ', s[triada[0]:triada[1]]
elif triada[0] != None and triada[1] == None:
# 10
print s+'[{0:2d} : ] '.format(triada[0]) + ' = ', s[triada[0]:triada[1]]
elif triada[0] != None and triada[1] != None:
# 11
print s+'[{0:2d} :{1:2d} ] '.format(triada[0],triada[1]) + ' = ', s[triada[0]:triada[1]]
elif len(triada) == 1:
print s+'[{0:2d} ] '.format(triada[0]) + ' = ', s[triada[0]]
if __name__ == '__main__':
# Change "s" to what ever string you like, make it 9 characters for
# better representation.
s = 'COMPUTERS'
# add to this list different lists to experement with indexes
# to represent ex. s[::], use s[None, None,None], otherwise you get an error
# for s[2:] use s[2:None]
lista = [[4,7],[2,5,2],[-5,1,-1],[4],[-4,-6,-1], [2,-3,1],[2,-3,-1], [None,None,-1],[-5,None],[-5,0,-1],[-5,None,-1],[-1,1,-2]]
slicegraphical(s, lista)
このスクリプトを実行して実験することができます。以下は、スクリプトから取得したサンプルの一部です。
+---+---+---+---+---+---+---+---+---+
| C | O | M | P | U | T | E | R | S |
+---+---+---+---+---+---+---+---+---+
0 1 2 3 4 5 6 7 8 9
-9 -8 -7 -6 -5 -4 -3 -2 -1
COMPUTERS[ 4 : 7 ] = UTE
COMPUTERS[ 2 : 5 : 2 ] = MU
COMPUTERS[-5 : 1 :-1 ] = UPM
COMPUTERS[ 4 ] = U
COMPUTERS[-4 :-6 :-1 ] = TU
COMPUTERS[ 2 :-3 : 1 ] = MPUT
COMPUTERS[ 2 :-3 :-1 ] =
COMPUTERS[ : :-1 ] = SRETUPMOC
COMPUTERS[-5 : ] = UTERS
COMPUTERS[-5 : 0 :-1 ] = UPMO
COMPUTERS[-5 : :-1 ] = UPMOC
COMPUTERS[-1 : 1 :-2 ] = SEUM
[Finished in 0.9s]
負のステップを使用する場合、答えが 1 だけ右にシフトされることに注意してください。
于 2014-10-18T17:40:45.040 に答える
6
基本的なスライス手法は、開始点、停止点、およびステップ サイズ (ストライドとも呼ばれます) を定義することです。
まず、スライスで使用する値のリストを作成します。
スライスする 2 つのリストを作成します。1 つ目は、1 から 9 までの数値リスト (リスト A) です。2 番目も 0 から 9 までの数値リストです (リスト B)。
A = list(range(1, 10, 1)) # Start, stop, and step
B = list(range(9))
print("This is List A:", A)
print("This is List B:", B)
A の 3 番と B の 6 番にインデックスを付けます。
print(A[2])
print(B[6])
基本的なスライス
スライスに使用される拡張インデックス構文は aList[start:stop:step] です。start 引数と step 引数の両方のデフォルトは none です。必要な引数は stop だけです。これは、リスト A と B を定義するために範囲が使用された方法と似ていることに気付きましたか? これは、スライス オブジェクトが range(start, stop, step) で指定された一連のインデックスを表すためです。Python 3.4 ドキュメント。
ご覧のとおり、stop のみを定義すると、1 つの要素が返されます。start のデフォルトは none であるため、これは 1 つの要素のみを取得することになります。
最初の要素はインデックス 1 ではなくインデックス0 であることに注意してください。これが、この演習で 2 つのリストを使用する理由です。リスト A の要素には序数の位置に従って番号が付けられます (最初の要素は 1、2 番目の要素は 2 など)。一方、リスト B の要素はインデックスに使用される番号です (最初の要素 0 の場合は [0]、等。）。
拡張インデックス構文を使用して、値の範囲を取得します。たとえば、すべての値はコロンで取得されます。
A[:]
要素のサブセットを取得するには、開始位置と停止位置を定義する必要があります。
パターン aList[start:stop] を指定して、リスト A から最初の 2 つの要素を取得します。
于 2018-07-23T13:06:55.537 に答える
2
rangeスライスをインデックスを与える に関連付けることができれば、理解しやすいです。スライスは、次の 2 つのカテゴリに分類できます。
1. ステップなしまたはステップ > 0。たとえば、[i:j]または[i:j:k](k>0)
シーケンスが であるとしますs=[1,2,3,4,5]。
- もし
0<i<len(s)そして0<j<len(s)なら[i:j:k] -> range(i,j,k)
例えば、[0:3:2] -> range(0,3,2) -> 0, 2
i>len(s)またはの場合j>len(s)、i=len(s)またはj=len(s)
例えば、[0:100:2] -> range(0,len(s),2) -> range(0,5,2) -> 0, 2, 4
i<0またはの場合j<0、i=max(0,len(s)+i)またはj=max(0,len(s)+j)
例えば、[0:-3:2] -> range(0,len(s)-3,2) -> range(0,2,2) -> 0
別の例として、[0:-1:2] -> range(0,len(s)-1,2) -> range(0,4,2) -> 0, 2
iが指定されていない場合、i=0
例えば、[:4:2] -> range(0,4,2) -> range(0,4,2) -> 0, 2
jが指定されていない場合、j=len(s)
例えば、[0::2] -> range(0,len(s),2) -> range(0,5,2) -> 0, 2, 4
2. ステップ < 0。たとえば、[i:j:k](k<0)
シーケンスが であるとしますs=[1,2,3,4,5]。
- もし
0<i<len(s)そして0<j<len(s)なら[i:j:k] -> range(i,j,k)
例えば、[5:0:-2] -> range(5,0,-2) -> 5, 3, 1
i>len(s)またはの場合j>len(s)、i=len(s)-1またはj=len(s)-1
例えば、[100:0:-2] -> range(len(s)-1,0,-2) -> range(4,0,-2) -> 4, 2
i<0またはの場合j<0、i=max(-1,len(s)+i)またはj=max(-1,len(s)+j)
例えば、[-2:-10:-2] -> range(len(s)-2,-1,-2) -> range(3,-1,-2) -> 3, 1
iが指定されていない場合、i=len(s)-1
例えば、[:0:-2] -> range(len(s)-1,0,-2) -> range(4,0,-2) -> 4, 2
jが指定されていない場合、j=-1
例えば、[2::-2] -> range(2,-1,-2) -> 2, 0
別の例として、[::-1] -> range(len(s)-1,-1,-1) -> range(4,-1,-1) -> 4, 3, 2, 1, 0
要約すれば
于 2018-12-28T04:34:41.117 に答える