1.切片获取列表中的技术要点

1.1切片获取列表中的概念总结

使用切片的方法获取列表中的一个或多个元素，是Python编程中经常要用的代码片段，一定要搞明白。

所谓的切片，指的是根据条件从列表中截取了一份片段，这个片段仍然是以列表的形式返回，简单理解为就是根据切片条件截取了列表中部分的元素。

在上面通过索引名一次我们只能获取一个列表元素，当使用切片的方法时，一次就可以获取列表中的多个元素。

切片的使用也非常简单，指定要获取的元素在列表中的索引范围，即可将这个索引号范围内的元素全部读取出来，使用切片获取列表中的索引时，声明的索引号范围一定是一个连续且有规律的，通过切片一次可以读取列表中的一个元素或者多个元素。

注意使用切片获取列表中的元素时，只能获取一个连续范围的索引所对应的元素，不能获取不连续的索引对应的元素，例如我想获取索引号为1/5/9的元素，这种需求切片是做不到的，切片只能读取到连续范围的索引对应的元素，例如获取索引号为1-5对应的元素。

1.2.切片的语法格式以及含义

切片可以不单单可以对列表进行切片，还可以对变量、字典、字符串等等进行切片。

print(列表名称[start:stop:step])

#start：起始索引号
#stop：结束索引号
#step：步长

例子：print(mylist[1:5:1])
#解释：打印出mylist列表中索引号1~5，但不输出索引5对应的元素，其他索引对应的元素都会被打印，步长为1。

在切片的语法中，有一些注意的点：

• 在使用切片时，切片后得到的仍然是一个列表，切片后的列表只是原列表中的一部分。
• 使用切片时指定了stop结束索引号，在得到的切片中不会包括stop结束索引对应的元素，切片只会截取start到stop范围之内索引对应的元素，会包括start起始索引对应的元素，不会包括stop结束索引对应的元素。
• 使用切片时，如果不指定step步长，默认值为1，此时的切片语法格式可以简化成[start:stop]
• 另外当step步长值为正数时：
  • 如果不指定start起始索引，切片的第一个元素默认是列表中的第一个元素。
  • 如果不指定stop结束索引，切片的最后一个元素默认是列表中的最后一个元素。
  • 如果指定了start、stop，当step为正数时，从start起始索引处，包含起始索引对应的元素，开始往后计算切片。
• 另外当step步长值为负数时：
  • 如果不指定start起始索引，切片的第一个元素默认是列表中的最后一个元素。
  • 如果不指定stop结束索引，切片的最后一个元素默认是列表中的第一个元素。
  • 如果指定了start、stop，当step为负数时，从start起始索引处，包含起始索引对应的元素，开始往前计算切片。

在切片中，无论step是正数还是负数，只是切片的顺序不同，当step是正数时，切片会从start处向右（往后）开始切片，当step是负数时，切片会从start处向左（往前）开始切片。

在使用切片获取列表中的元素时，一般都使用大于0的索引作为范围，去读取列表中一个范围内的元素。

3.使用切片方法获取列表中元素

3.1.定义一个原始列表列表

将上图中的列表定义出来，我在图中标记了列表中每个元素的索引号，下面我们通过切片获取元素时，就有了上图的参考依据。

##定义一个列表
mylist = ["jiangxl", "jiangxiaolong", "bjjtdx", "devops", "python", 11, 22, 33, 89]
print(list(mylist))

3.2.当step步长为正数时切片的案例

当step步长值为正数时：

• 如果不指定start起始索引，切片的第一个元素默认是列表中的第一个元素。
• 如果不指定stop结束索引，切片的最后一个元素默认是列表中的最后一个元素。
• 如果指定了start、stop，当step为正数时，从start起始索引处，包含起始索引对应的元素，开始往后计算切片。

当step步长为正数时，切片的顺序是从列表的第一个元素向后找索引范围进行切片。

1）使用切片获取索引号1到7范围内的元素，并指定步长为2

分析：要获取索引1~7这几个索引对应的多个元素，需要通过切片来实现，使用切片时指定起始索引号为1，结束索引号为7，步长为2，切片是不会获取结束索引对应的元素，根据上图元素与索引的对应关系，本次需求获取的结果将会是：[jiangxiaolong, jsjkxjs, python]。

#使用切片获取索引号1到7范围内的元素，并指定步长为2
print(mylist[1:7:2])
#输出结果：['jiangxiaolong', 'jsjkxjs', 'python']

指定的结束索引对应的元素不会列入切片后的列表中，相当于被切片的范围只是索引号1_{6对应的元素，但是指定了步长为2（间隔为1），1}6索引号对应的元素每隔1位取一个元素划入到切片列表中，从而得到如下结果。

切片的范围是索引1_{7，但是结束索引不会被列入到切片的范围内，此时切片的范围仅是1}6这几个索引，步长为2间隔就为1，因此1~6这几个索引会每隔1位取一个，最终只会取出1/3/5这三个索引对应的元素，作为切片列表。

2）使用切片获取索引1到7范围内的元素，不指定步长

分析：需求和上一个一样，只不过不指定步长，不指定步长时，步长值为1，间隔为0，此时就会打印出切片范围内索引对应的所有元素。

#使用切片获取索引1到7范围内的元素，不指定步长
'''
    在切片的语法格式中，存在三个参数：start:stop:step
    切片的三个参数可以选择性的使用，当不需要指定某个参数时：
        如果这个参数是start、stop，那么直接写上:就表示使用这个参数使用默认值，我们不指定该参数的具体值。
            例如：[6:]（不指定stop的值）、[:6]（不指定start的值）
        如果这个参数是step，可以写上:表示使用默认值，也可以省略不写，此时的切片语法格式就是[start:stop]
            例如：[6:11:]、[6:11]
    
'''
#两种写法：使用:声明step步长使用默认值，或者直接不写step参数
print(mylist[1:7:])
print(mylist[1:7])

#输出结果：['jiangxiaolong', 'bjjtdx', 'jsjkxjs', 'devops', 'python', 11]

3）使用切片获取整个原列表中的所有元素

当不指定start起始索引和stop结束索引是，步长使用默认值，就会得到一个完整的原列表元素。

##切片整个原列表中的所有元素
print(mylist[::])

#输出结果：
['jiangxl', 'jiangxiaolong', 'bjjtdx', 'jsjkxjs', 'devops', 'python', 11, 22, 33, 89]

3.3.当step步长为负数时切片的案例

当step步长值为负数时：

• 如果不指定start起始索引，切片的第一个元素默认是列表中的最后一个元素。
• 如果不指定stop结束索引，切片的最后一个元素默认是列表中的第一个元素。
• 如果指定了start、stop，当step为负数时，从start起始索引处，包含起始索引对应的元素，开始往前计算切片。

当step步长为负数时，切片的顺序是相反的，从列表的最后一个元素向前找索引范围进行切片。

1）使用切片获取整个原列表中的所有元素，指定step步长为-1

当step步长为负数时，如果不指定start和stop，就会从列表中最后一个元素处向前一直到第一个元素处，进行切片，此时获取的切片列表就是和原列表完全反向。

print(mylist[::-1])

#输出结果：[89, 33, 22, 11, 'python', 'devops', 'jsjkxjs', 'bjjtdx', 'jiangxiaolong', 'jiangxl']

2）使用切片获取索引8到0范围内的元素，指定步长为-2

分析：使用切片获取8~0索引对应的元素，从切片的范围上明显是一个反向范围的切片，步长为-2更说明了这一点，step步长为负数时，就会从指定的起始索引处向前（左）开始切片，结束索引依旧不会列入到切片列表中，如下图所示，反向切片后，从索引8处开始切片，结束索引0不列入切片中，步长的间隔为1，最终就会打印出索引8/6/2/4对应的元素。

print(mylist[8:0:-2])

#输出结果；[33, 11, 'devops', 'bjjtdx']

当步长为负数时，从列表中反向切片，因此索引8对应的元素会打印在最前面，切片返回的也是一个列表，如果从中切片列表上看，索引8在切片后就会称为索引0。

3）使用切片片获取0到8范围内的元素，指定步长为-2

分析：步长为负数，反向切片，0是起始索引，如前面的列表示意图所示，索引0前面没有任何元素了，作为负数步长来说，索引0是列表中的最后一个元素，而步长为-2，间隔就是1，那么此时是不会返回任何元素的，会返回一个空列表。

print(mylist[0:8:-2])

#输出结果：[]

4）切片时指定起始索引为5，不指定结束索引，指定步长为-2

分析：切片的起始索引为5，不指定结束索引，当步长为负数，默认的结束索引就是列表中的第一个元素，反向切片，步长为-2，间隔为1，每隔1位切片一个元素，最终索引5/3/1对应的元素会被切片出来。

print(mylist[5::-2])

#输出结果：['python', 'jsjkxjs', 'jiangxiaolong']

5）切片时不指定起始索引，指定结束索引为7，步长为-2

分析：当步长为负数时，不指定起始索引，默认是从列表中最后一个元素处切片，结束索引为7，那么范围就是最后一个元素索引到索引7之内的元素，步长为-2，那么间隔就为1，范围不大，最后只会打印出起始索引（最后一个元素）这一个元素。

print(mylist[:7:-2])

#输出结果：[89]

3.4.使用负数索引作为切片范围

列表中的元素都有2个索引，在3.3.2和3.3.3中，我们都是用元素的正数索引进行切片的，下面我用负数索引切片。（大多数情况下都是用正数索引作为切片范围的）

道理都一样，负数索引是从-1开始，值约小约靠后，值约大约靠前。

当步长为正数时，从指定的起始索引处向后开始切片，当步长为负数时，从指定的起始索引处向前切片。

1）步长为正数，使用负数索引作为切片范围

切片的范围从索引-10一直到索引-2，步长为正数2，从第一个索引-10处向后切片，一直到结束索引-2，-2不会列入到切片中，并且本次的步长为2，间隔就为1，最终索引-10、-8、-6、-4对应的元素会被切片出来。

-10到-2相当于0到8，一般都会用正数作为切片范围，看起来爽快。

print(mylist[-10:-2:2])

#输出结果；['jiangxl', 'bjjtdx', 'devops', 11]

2）步长为负数，使用负数索引作为切片范围

切片的范围从索引-3一直到索引-9，步长为负数-2，从第一个索引-3处向后切片，一直到结束索引-9，-9不会列入到切片中，并且本次的步长为-2，间隔就为1，反向切片，最终索引-3、-5、-7对应的元素会被切片出来。

print(mylist[-3:-9:-2])

#输出结果：[22, 'python', 'jsjkxjs']

4.将切片后的列表赋值给新的变量

使用切片从原列表中取出多个元素后，会形成一个新的列表，可以将切片后的列表赋给另一个变量。

mylist = ["jiangxl", "jiangxiaolong", "bjjtdx", "jsjkxjs", "devops", "python", 11, 22, 33, 89]
mylist2 = mylist[1:7:2]
print(mylist2)

#输出结果；['jiangxiaolong', 'jsjkxjs', 'python']

5.切片操作获取列表中的多个元素允许索引越界

什么是索引越界呢？指的是从列表中取元素时，指定的索引在列表中不存在，这就叫越界，在之前使用索引去元素时，当索引在列表中不存在时，就会抛出valueerror的异常。

当使用切片操作获取元素时，指定的索引在列表中不存在时，则不会报错，会将列表中能够承受范围的所有元素全部输出。

##列表中的最后一个元素的正数索引是9，我们通过切片指定结束索引是100，观察效果
print(mylist[:100])
#100索引在列表中不存在，且列表中的最大索引是9，此时Python就会将能够承受范围的全部元素输出出来，也就是会将列表中的全部元素输出
#输出结果：['jiangxl', 'jiangxiaolong', 'bjjtdx', 'jsjkxjs', 'devops', 'python', 11, 22, 33, 89]


##列表中的最大的负数索引是-10，也是列表中的第一个元素，我们通过切片指定起始索引是-100，观察效果
print(mylist[-100:])
#此时也会将全部元素输出出来：['jiangxl', 'jiangxiaolong', 'bjjtdx', 'jsjkxjs', 'devops', 'python', 11, 22, 33, 89]

6.调用slice函数方法实现切片获取列表元素的效果

调用slice函数方法也可以实现切片获取列表多个元素的效果，slice函数的输出结果和切片操作是相同的。

调用slice函数有三种方式：

• 只指定stop结束索引。
• 指定start起始索引和stop结束索引。
• 指定start起始索引和stop结束索引以及step步长。

slice函数的语法格式：

slice(stop)
slice(start,stop)
slice(start,stop,step)

对于slice函数而言：start、stop、step三个参数的值都是None，并没有默认实际值

1）定义一个列表

mylist = ["jiangxl", "jiangxiaolong", "bjjtdx", "devops", "python", 11, 22, 33, 89]
print(list(mylist))

2）获取索引1到7范围内的元素，并指定步长为2

#切片实现
print(mylist[1:7:2])
#slice函数实现
print(mylist[slice(1,7,2)])

3）获取列表中全部的元素

#切片实现
print(mylist[::])
#slice函数实现
print(mylist[slice(None, None, None)])

4）获取索引1到7范围内的元素，不指定步长

#切片实现
print(mylist[1:7])

#slice函数实现
print(mylist[slice(1,7)])
print(mylist[slice(1,7,None)])

5）仅指定结束索引

在切片操作中，如果只指定结束索引，步长是正数，那么起始索引默认是从列表中第一个元素处开始切片，slice函数也是相同的原理，如果起始索引start为None，步长为None或者正数，默认也是从列表的第一个元素处开始切片。

#切片实现
print(mylist[:8])
print(mylist[:-8])

#slice函数实现
print(mylist[slice(8)])
print(mylist[slice(-8)])
print(mylist[slice(None, 8, None)])

7.一次打印多个不连续的元素

如果我们想打印列表中的多个元素，且元素的索引不是连续的，无法通过切片来打印，基于这种情况，也可以使用笨方法，如下所示打印多个元素，一般情况下，要么遍历列表中的所有元素，要么也是通过切片打印连续的多个元素，很少有这种需求。

print([mylist[2], mylist[5]])

mylist3 = [mylist[2], mylist[5]]
print(mylist3)

8.使用切片一次性打印列表的全部元素

mylist = ["jiangxl", "linux", "k8s", "devops", 789, 987]
print(mylist[:])