## Python slice with value and value

dongfanger 2021-02-23 08:57:29
python slice value value

section , It's like bread , Give me a few knives , Cut it into pieces , It can be made into toast , You can also make sandwiches , Better taste ：

list （list）、 Tuples （tuple）、 character string （str） Can be sliced , Get the sub segment , Actually slicing is much more powerful than you think , Can take value , It can also assign values .

# Ignore the last element

Slices are described by subscripts and colons , such as `s[2:13]`. about `2, 3, ..., 12` This sequence , Expressed as `[2, 13)`, Left closed right away , Than `[2, 12]` and `(1, 13)` It's more reasonable , For the following reasons ：

1. The upper limit minus the lower limit equals the number of elements , such as `13 - 2 = 11`, Just in time 11 Elements .
2. Continuous ranges don't overlap , such as `[2, 13)` and `[13, 25)` It's two consecutive ranges ,13 It will only be included in the latter one .

# Subscript from 0 Start

about 10 Elements , It's written in `[0, 10)` Than `[1, 11)` More reasonable , For the following reasons ：

1. N Elements ,`[0, N)` Than `[1, N+1)` It's more concise , Unwanted `+1`.

2. The subscript of an element is equal to the number of elements in front of it , Easy to use , such as ：

``````0 1 2 3 4 5 6 7 8 9
^
There is 4 Elements
``````

# Good slicing

The above two mathematical theories bring a lot of benefits to the use of slicing ：

• When there is only the last location information , You can quickly see that there are several elements , such as `my_list[:3]` return 3 Elements .

• When the start and stop position information is visible , You can quickly calculate the length , use `stop - start` That's all right. , such as `my_list[1:3]` The length is 2.

• Use any subscript to cut the sequence into two non overlapping parts , Just write `my_list[:x]` and `my_list[x:]` That's all right. , such as

``````>>> my_list = [10, 20, 30, 40, 50, 60]
>>> my_list[:3]
[10, 20, 30]
>>> my_list[3:]
[40, 50, 60]
``````

Python In the range of （range） Also ignore the last element , Subscript from 0 At the beginning .

# Slice interval

Except for `s[a:b]`, And a third subscript `s[a:b:c]`, It means right s stay a and b Between c Value... For interval ,c It can also be negative , A negative value means a negative value . such as ：

``````>>> s = "bicycle"
>>> s[::3]
"bye"
>>> s[::-1]
"elcycib"
>>> s[::-2]
"eccb"
``````

`a:b:c` A more precise description is `start:stop:step`.

The grammar is so simple , I think it's with my feet Python What magic does ！ In the face of `s[a:b:c]` When you evaluate it ,Python It actually calls `s.__getitem__(slice(a, b, c))`, Familiar formula , Familiar taste .`slice(a, b, c)` yes `a:b:c` Use in `[]` The slice object returned in ,`slice()` yes Python Built in functions , Example ：

``````invoice = "Mini Kit \$34.95 1 \$ 34.95"
SKU = slice(0, 8)
print(invoice[SKU])
``````

# Slice assignment

A powerful function of slicing is to assign values to slices , If you put the slice on the left side of the assignment statement , Or take it as del Object of operation , We can graft the sequence 、 Removal or local modification operations . Example ：

``````>>> l = list(range(10))
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del l[5:7]
>>> l
[0, 1, 2, 3, 4, 7, 8, 9]
>>> l[3:2] = [11, 22]
>>> l
[0, 1, 2, 11, 22, 3, 4, 7, 8, 9]
>>> l[2:5] = [100]
>>> l
[0, 1, 100, 3, 4, 7, 8, 9]
``````

Be careful , If the assigned object is a slice , Then the right side of the assignment statement must be an iteratable object , Even if there's only a single value , Otherwise, an error will be reported ：

``````>>> l[2:5] = 100
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: can only assign an iterable
``````

# Multi slice

Except for one-dimensional slices ,Python It also supports multidimensional slicing , This is reflected in multidimensional arrays .NumPy yes Python Third party Library , Provides high order arrays , bring Python Become the mainstream language of scientific computing applications . Example ：

``````>>> import numpy
>>> a = numpy.arange(12)
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> a.shape
(12,)
>>> a.shape = 3, 4
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> a[:, 1]
array([1, 5, 9])
>>> a[1:2, 2:3]
array([[6]])
>>> a[1:3, 2:4]
array([[ 6, 7],
[10, 11]])
``````

stay NumPy in , Ellipsis `...` Used as a shortcut to slice multidimensional arrays , If x It's a four-dimensional array , that `x[i, ...]` Namely `x[i, :, :, :]` Abbreviation , such as ：

``````>>> a.shape = 2, 2, 3
>>> a
array([[[ 0, 1, 2],
[ 3, 4, 5]],
[[ 6, 7, 8],
[ 9, 10, 11]]])
>>> a[:, :, 1]
array([[ 1, 4],
[ 7, 10]])
>>> a[..., 1]
array([[ 1, 4],
[ 7, 10]])
``````

# Summary

This paper introduces Python Powerful slicing operation , Because ignoring the last element and subscript from 0 Start , So slicing is easy to use , Except for the beginning and the end , You can also set the slice interval , If the interval is negative, the value can be reversed . Slice assignment is another powerful function of slicing , Note that the right side of the assignment statement must be an iteratable object .

Reference material ：

《 smooth Python》

https://blog.wz52.cn/archives/174.html

https://pythonmana.com/2021/02/20210223085707080n.html