Python：切片操作详解

一时失言乱红尘 2023-07-25 12:49 9阅读 0赞

# 基本语法： #

object[start:end:step=1]

1.  step：正负数均可，其绝对值大小决定了切取数据时的‘‘步长”，而正负号决定了“切取方向”，正表示“从左往右”取值，负表示“从右往左”取值。当step省略时，默认为1，即从左往右以步长1取值。
2.  start：开始位置索引。
3.  end：结束位置索引。

功效：从 start 到 end 按照 step 选取元素作为一个新的对象。（包括 start，不包括 end）

如果只出现出现一个冒号：则为第一个冒号。

**Note: 最重要的是 step 操作，它不仅决定了切片的步长，还决定了切片的方向。更进一步的是还会影响 start 和 end 的默认取值。**

# 理解精髓 #

**- step 为正数：切片方向从左到右，start 默认为 0（即为最左边位置索引）， end 默认为 length（对象长度，即为最右边位置索引的下一位，（因为取不到 end））。   
 \- step 为负数：切片方向从右到左，start 默认为 length-1（对象长度减一，即为最右边位置索引）， end 默认为 -1（即为最左边位置索引的前一位（因为取不到 end））**

# 浅拷贝 or 深拷贝？ #

a_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    b_list = a_list[0:5]
    
    print('Id of a_list:', id(a_list))
    print('Id of a_list:', id(b_list))
    
    for i in a_list:
        print('%s-th element in a_list: %s' % (i+1, id(i)))
    
    print('*********')
    
    for i in b_list:
        print('%s-th element in b_list: %s' % (i+1, id(i)))

结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzU4OTU3NQ_size_16_color_FFFFFF_t_70]  
了解浅拷贝的都知道，这是一种典型的浅拷贝方式！再用一个例子证明：

a_list = [0, 1, [2, 3, 4]]
    
    b_list = a_list[0:3]
    
    b_list[-1][0] = 20
    
    print(a_list)

结果如下：  
![在这里插入图片描述][20200415103638431.png]  
修改浅拷贝对象中的可变对象元素相互影响。这就是浅拷贝的注意事项啊。如果不了解浅拷贝，可以参考：[Python：赋值，浅拷贝（copy）和深拷贝（deepcopy）][Python_copy_deepcopy]

# 3. 例子： #

## 3.1 a\[:\] and a\[::\] ##

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    print(a[:])
    print(a[::])

![在这里插入图片描述][20200415103943752.png]  
**理解：step 默认为 1， 正数，方向从左到右，start 和 end 分别为最左边和最右边索引的下一位（取不到 end）。**

## 3.2 超出索引会如何？ ##

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    print(a[0:100])

![在这里插入图片描述][20200415104341842.png]  
**不会报错！**

## 3.3 step 大于 0 ##

Note: 我们始终把握我们理解的精髓：step 大于 0，切片方向从左到右，start 默认最左边位置，end 默认最右边位置的下一个位置（因为取不到 end）。记住这个，下面的所有情况就很好理解了。

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    print('a[1:6]:', a[1:6])
    print('a[6:2]:', a[6:2])
    print('a[:6]:', a[:6])
    print('a[6:]:', a[6:])
    print('a[-1:-6]:', a[-1:-6])
    print('a[-6:-1]:', a[-6:-1])
    print('a[:-6]:', a[:-6])
    print('a[-6:]', a[-6:])
    print('a[1:-6]', a[1:-6])
    print('a[-1:6]', a[-1:6])

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzU4OTU3NQ_size_16_color_FFFFFF_t_70 1]  
a\[1:6\]：没啥好说的，1 索引到 6 索引，但是不包括 6 索引；  
a\[6:2\]：切片方向为左到右，从 6 索引切到 2 索引，不包括 2 索引。因此这样切不出来，即为空列表；  
a\[:6\]：step 为正，start 默认为 0，因此等价于 a\[0:6\]；  
a\[6:\]：step 为正，end 默认为 10（length，最右边位置的下一位）, 等价于 a\[6:10\]；  
a\[-1:-6\]: step 为正，因此这样切不出来，即为空列表；  
a\[-6:-1\]：step 为正，从倒数第 6 个到倒数第 1 个，取不到倒数第 1 个；  
a\[:-6\]：step 为正，start 默认为 0，因此是去 0 索引到倒数第 6 个，不包括倒数第 6 个；  
a\[-6:\]：step 为正，end 默认为 10（length，最右边位置的下一位），因此为倒数第 6 个之后的所用元素；  
a\[1:-6\]：step 为正，从 1 索引到倒数第 6 个，不包括倒数第 6 个；  
a\[-1:6\]：step 为正，从倒数第一个从左往右切到 6 索引，不包括 6 索引，切不出来，即为空列表。  
Note: 负索引代表倒数第几个元素，例如 a\[-1\] 即为最后第一个元素，a\[-6\] 即为最后第六个元素。

## 3.3 step 小于 0 ##

Note: 我们始终把握我们理解的精髓：step 小于 0，切片方向从右到左，start 默认为 length-1（对象长度减一，即为最右边位置索引）， end 默认为 -1（即为最左边位置索引的前一位（因为取不到 end））。记住这个，下面的所有情况就很好理解了。

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    print('a[1:6:-1]:', a[1:6:-1])
    print('a[:6:-1]:', a[:6:-1])
    print('a[6::-1]:', a[6::-1])
    print('a[-1:-6:-1]:', a[-1:-6:-1])
    print('a[:-6:-1]:', a[:-6:-1])
    print('a[-6::-1]:', a[-6::-1])
    print('a[1:-6:-1]:', a[1:-6:-1])
    print('a[-1:6:-1]', a[-1:6:-1])

![在这里插入图片描述][20200415111154797.png]  
a\[1:6:-1\]：从右到左切 1 索引到 6 索引，不包括 6 索引，切不出来，所以为空；  
a\[:6:-1\]：step 为负，start 默认为 9 （length - 1），因此是取最后 1 个到 6 索引，不包括 6 索引；  
a\[6::-1\]：step 为负，end 默认为 -1，因此从右往左取 6 索引到 -1 索引，不包括 -1 索引。  
a\[-1:-6:-1\]：step 为负，从右到左去倒数第 1 个到倒数第 6 个，不包括倒数第 6 个。  
a\[:-6:-1\]：step 为负，start 默认为 9 （length - 1），从右到左取倒数第 1 个到倒数第 6 个，不包括倒数第 6 个，等价于上一个。  
a\[-6::-1\]：step 为负，end 默认为 -1，从右到左取倒数第 6 个之前的所有。  
a\[1:-6:-1\]：step 为负，从右到左去倒数第 6 个到倒数第 1 个，不包括倒数第一个，取不出来，所以为空列表。  
a\[-1:6:-1\]：step 为负，从右到左去倒数第 1 个到 6 索引，不包括 6 索引。

# 总结：把握精髓，step 不仅决定切片方向，还会影响 start 和 end 的默认取值。 #

# 4. 常见应用： #

## 4.1 取偶数索引位置： ##

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    print(a[::2])

![在这里插入图片描述][20200415112423118.png]

## 4.2 取奇数索引位置： ##

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    print(a[1::2])

![在这里插入图片描述][20200415112505691.png]

## 4.3 插入元素： ##

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    a[1:1] = [100]
    print(a)

![在这里插入图片描述][20200415112704236.png]  
注意我们切出来的是一个 list，所以赋值为 \[100\]。  
这里可能和浅拷贝的理解有偏差：

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    b = a[:]
    b[1] = 100
    print(a)

![在这里插入图片描述][20200415112913349.png]  
这样符合浅拷贝的理解：修改的是不可变对象，因此相互之间不影响。  
但是上一种情况是由于没有赋值给一个新的变量，而是在原来变量上面操作的。

## 4.3 少修改多元素/多修改少元素： ##

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    a[1:1] = [100, 200]
    print(a)

多修改少，可以看到 a 变长了。

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    a[1:5] = [100, 200]
    print(a)

少修改多，可以看到 a 变短了。

# 5. 其他 #

可以切片的还包括字符串（str）和元素（tuple）等，不过原理都是一样的，这里不再赘述。

# END #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzU4OTU3NQ_size_16_color_FFFFFF_t_70]: /images/20230528/cc0a211fd36948a8b665efcd9aa32628.png
[20200415103638431.png]: /images/20230528/04de8814f2ef42bdafae46b676616004.png
[Python_copy_deepcopy]: https://blog.csdn.net/weixin_37589575/article/details/105447772
[20200415103943752.png]: /images/20230528/bf7cb24bf8404e86b376463be00a1d17.png
[20200415104341842.png]: /images/20230528/8b9e4b5513fc4ef5ab5cdfbb20c93705.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzU4OTU3NQ_size_16_color_FFFFFF_t_70 1]: /images/20230528/2462c4e8bd854a64949bd2c76cdfaa19.png
[20200415111154797.png]: /images/20230528/de01abcc6de74752b18448a0c8b90969.png
[20200415112423118.png]: /images/20230528/2d3478b6e6d84546aecee631d8d906c8.png
[20200415112505691.png]: /images/20230528/983930aca4584e06933b7f17981c1e0b.png
[20200415112704236.png]: /images/20230528/f0922e640ab8484ba3c961cd16ccf4dc.png
[20200415112913349.png]: /images/20230528/7edb74497c864d23ae61d0cd58a4c7d3.png