Python中列表/字符串切片slice？

Posted 2023-04-08

(1)、lst = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
#lst[3*3::3] output:[9, 12, 15]
lst[3*3::3] = len(lst[3*3::3])*[0]
output:[0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 10, 11, 0, 13, 14, 0]
(2)、s = '0123456789'
s[::-1] '9876543210'
s[::-2] '97531'
s[::-3] '9630'
s = '0123456789'
s[:2:-1] '9876543'
s[1:2:-1] ''
s[2:1:-1] '2'
s[2::-1] '210'
s[-1:-2:-1] '9'
s[-1:-5:-2] '97'
这两段看不懂能否帮忙详细就此题解答?

s = \'0123456789\'
s[::-1]：表示将s倒序排列
s[::-2]：表示将s倒序排列并且步长是2
s[::-3]：表示将s倒序排列并且步长是3

s[:2:-1]：表示将s倒序排列，并且到s的第2个元素就结束
s[1:2:-1]：表示将s倒序排列，并且从第一个元素开始，第二个元素结束

s[-1:-5:-2]：表示将s倒序排列步长为2，也就是\'97531\'。然后是从s的-1个元素位置开始，也就是9。到s的-5个元素结束，也就是5，但不包括5。最后的结果也就是\'97\' 参考技术A 不知道你那里不懂，，这个挺简单的啊。 给你解释两个你就明白了
lst[3*3::3] output:[9, 12, 15] 中 中括号第一个：前是从3*3开始，第二个：是空也就是没有结束走完整个集合，第三个：后是 3 也就是步长 3 。
s[:2:-1] '9876543' 这个是 第一个：前为空 也就是开头，第二个：后是2 也就是到 2 结束。第三个：后是 -1 也就是反向字符串，或者理解为从右开始数 参考技术B 你好的！
这个是基础知识：
（一）start_index、end_index、step可同为正、同为负，也可正负混合使用。但必须遵循一个原则，否则无法正确切取到数据：当start_index的位置在end_index的左边时，表示从左往右取值，此时step必须是正数（同样表示从左往右）；当start_index的位置在end_index的右边时，表示从右往左取值，此时step必须是负数（同样表示从右往左），即两者的取值顺序必须是相同的。对于特殊情况，当start_index或end_index省略时，起始索引和终止索引由step的正负来决定，不会存在取值方向出现矛盾的情况（即不会返回空列表[]），但正和负取到的结果是完全不同的，因为一个向左一个向右。
（二）在利用切片时，step的正负是必须要考虑的，尤其是当step省略时。比如a[-1:]，很容易就误认为是从“终点”开始一直取到“起点”，即a[-1:]= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]，但实际上a[-1:]=a[-1]=9，原因在于step=1表示从左往右取值，而起始索引start_index=-1本身就是对象的最右边的元素了，再往右已经没数据了，因此只有a[-1]一个元素。

具体百度一下python切片详解！
望采纳

golang基础---Slice切片

切片Slice在go语言中是单独的类型（指向底层的数组），不同于python(对可迭代对象操作的工具)，注意区分数组和slice的区别

• 定义一个空slice,格式var s []int,这种既没有长度也没有元素赋值的类型（相比叫array）

• 数组的基本操作如下 ，类似与python中列表切片的操作，详见实例

  package main
  import "fmt"
  
  func main() {
      var s1 []int                                //这样就是一个slice类型，既没有长度也没有元素赋值
      a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} //这是一个数组
      s2 := a[5:10]                               //切片，索引5到10的元素，不包含索引为10
      s3 := a[:3]                                 //切片，索引1-3的元素，不包含索引3
      s4 := a[6:]                                 //切片，第6个索引到最后一个索引的元素
      s5 := a[:]                                  //切片，复制一个数组
      fmt.Println(s1)
      fmt.Println(a)
      fmt.Println(s2) //数组的切片，类似python
      fmt.Println(s3)
      fmt.Println(s4)
      fmt.Println(s5)
  }
  
  /*输出
  s1--->  []
  a--->   [0 0 0 0 0 0 0 0 0 0]
  s2--->  [6 7 8 9 10]
  s3--->  [1 2 3]
  s4--->  [7 8 9 10]
  s5--->  [1 2 3 4 5 6 7 8 9 10]
  */

使用make初始化一个slice类型，包含三个参数

• ①切片类型 []int
• ②初始长度 len

• ③容量 cap

  package main
  import "fmt"
  
  func main() {
      s1 := make([]int, 3, 10)      //使用make初始化一个slice,包含三个参数：①切片类型②初始长度③容量
      fmt.Println(len(s1), cap(s1)) //输出长度，容量
      fmt.Println(s1)
  }
  
  /*输出：
  len(s1)--->3
  cap(s1)--->10
  s1--->  [0 0 0]  //可变数组
  */

Reslice ,在原slice基础上再次切片，slice一个数组时，不仅取出了len,同时容量也会得到相应的切片。

• 示例

  //Reslice,在slice基础上再次slice.
  package main
  import "fmt"
  
  func main() {
      a := []byte{‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘, ‘k‘, ‘m‘} //定义一个数组，元素为byte类型
      sa := a[3:5]                                             // slice切片，取索引三到五，不包含索引5
      sb := sa[1:3]
      fmt.Println(string(sa))
      fmt.Println(len(sa), cap(sa))
      fmt.Println(string(sb))
      fmt.Println(len(sb), cap(sb))
  }
  
  /*输出
  sting(sa)--->   de
  len(sa)--->     2
  cap(sa)--->     6
  string(sb)--->  ef
  len(sb)--->     2
  cap(sb)--->     5
  */

Append,类似python中list类型，使用append,从数组尾部追加元素

• 可以将一个slice追加在另一个slice尾部
• 如果最终长度未超过追加到slice的容量，则返回原始slice

• 如果超过追加的slice的容量则将重新分配数组并拷贝原始数据

  package main
  import "fmt"
  
  func main() {
      s1 := make([]int, 3, 8) //初始化slice,长度位3，容量为8
      fmt.Printf("%p
  ", s1)  //输出s1的内存地址
      fmt.Println(s1)
      s1 = append(s1, 1, 2, 3) //末尾追加三个元素,cap依然为8
      fmt.Printf("%p
  ", s1)   //原来的slice
      fmt.Println(s1)
      s1 = append(s1, 1, 2, 3, 4) //继续追加元素，超过原s1容量，会重新分配新的内存地址
      fmt.Printf("%p
  ", s1)      //cap容量超过8，为9
      fmt.Println(s1)
  }
  
  /*
  p*s1--->    0xc042070040
  s1--->      [0 0 0]
  p*s1s1-->   0xc042070040
  s1--->      [0 0 0 1 2 3]
  p*s1--->    0xc04205e080   //新的内存地址
  s1--->      [0 0 0 1 2 3 1 2 3 4]
  */

• 当两个slice同时指向某一个数组时，改变某一个slice索引时，另一个slice索引值及原数组的索引也会改变

  package main
  import "fmt"
  
  func main() {
      a := []int{1, 2, 3, 4, 5, 6}
      s1 := a[2:5]
      s2 := a[1:3]
      fmt.Println(s1, s2)
      s1[0] = 9
      fmt.Println(s1, s2)
      fmt.Println(a)
  }
  
  /*
  s1--->  [3 4 5]
  s2--->  [2 3]
  //更改s1的slice索引后，s2的索引也会改
  s1--->  [9 4 5]
  s2--->  [2 9]
  a--->   [1 2 9 4 5 6]
  */

copy，格式 copy(s1,s2), 将s2拷贝到s1数组中，当len(s1) > len(s2)时，最终将s2中的索引
替换掉s1的索引，当len(s1)<len(s2)时，s1的索引值全部被对应s2的索引替换

• 示例

  package main
  import "fmt"
  
  func main() {
      s1 := []int{1, 2, 3, 4, 5}
      s2 := []int{6, 7, 8}
      copy(s1, s2) //将s2的元素拷贝到s1,s2
      fmt.Println(s1)
  
      copy(s2, s1)
      fmt.Println(s2)
  
      copy(s1, s2[2:3]) //只拷贝某一切片的索引
      fmt.Println(s1)
  }
  
  /*输出
  s1--->  [6 7 8 4 5]
  s2--->  [1 2 3]
  s1--->  [8 2 3 4 5]
  */