python入门练习题目2.2

时间:2023-02-23 00:07:43

题目:用户输入一个列表和2个整数作为下标,然后输出列表中介于2个下标之间的元素组成的子列表。例如用户输入[1, 2, 3, 4, 5, 6]和2,5,程序输出[3, 4, 5, 6]。

方法一:使用切片

import time
import random
x = input('请输入一个列表;')
print(x)
y = int(input('你想从第几个数开始:'))
z = int(input('你想从第几个数结束:'))
if len(x)>5:
   print(x[y:z])
else:
   print('输入错误')


扩展知识(一、切片):

slice在python中的应用

     在python中,list, tuple以及字符串等可以遍历访问的类型都可以应用slice访问。slice本身的意思是指切片,在这些可以遍历访问的类型中截取其中的某些部分。比如如下的代码:

Python代码 python入门练习题目2.2  python入门练习题目2.2python入门练习题目2.2
  1. >>> l = range(10)  
  2. >>> l  
  3. [0123456789]  
  4. >>> l[1:5]  
  5. [1234]  

   首先,我们通过range(10) 生成一个从0到9的列表。在这个列表中取[1:5]的时候返回的是索引1到4的。所以,我们发现他们所取的slice是一个半开半闭的区间。l[a:b]==> l[a, b).

    前面这种情况下,是我们已知列表的长度,然后取他们的某个区段,如果我们不知道列表的长度,或者列表长度的获取比较麻烦呢?如果用其他的语言,我们可能考虑这个列表是否应该有一个list.length之类的属性了。在这里,有另外一个办法来取得:

Python代码 python入门练习题目2.2  python入门练习题目2.2python入门练习题目2.2
  1. >>> l[-1]  
  2. 9  
  3. >>> l[1:-1]  
  4. [12345678]  
  5. >>> l[2:-2]  
  6. [234567]  

    我们可以看到如果要取列表中的最后一个元素,可以用l[-1]的方式,如果从后面向前,可以依次取l[-2], l[-3]...

    既然我们前面提到,在列表中slice是取的一个前面闭合后面开放的区间,也就是说我在l[a:b]的时候,索引值为b的那个元素是不包含在结果中的。如果我们想要包含后面的值那么该怎么办呢?

    这个问题可以分为几种情况来考虑,一个是加入b本身长度比较小,那么我们取l[a:b+1]就好了。比如说如下:

Python代码 python入门练习题目2.2  python入门练习题目2.2python入门练习题目2.2
  1. >>> l[1:3]  
  2. [12]  
  3. >>> l[1:4]  
  4. [123]  

 如果我们想把索引值为3的也包含进来,我们就用l[1:4]就行了。那么,对于处在列表末尾的元素呢?用过c, java开发的人会想到,按照这种方式会不会导致访问数组越界呢?我们试试看吧:

Python代码 python入门练习题目2.2  python入门练习题目2.2python入门练习题目2.2
  1. >>> len(l)  
  2. 10  
  3. >>> l[1:10]  
  4. [123456789]  
  5. >>> l[1:11]  
  6. [123456789]  
  7. >>> l[1:12]  
  8. [123456789]  

    len(l)返回l的长度。我们原来潜意识的认为,既然数组长度为10,那么我们访问的索引最大值也不过为l[9]。实际上,在python这里,可以列出的访问下标值超出数组长度范围,只不过仅仅返回能遍历到的元素而已。

    当然,我们还有另外一种办法:

Python代码 python入门练习题目2.2  python入门练习题目2.2python入门练习题目2.2
  1. >>> l[1:]  
  2. [123456789]  

    这种方式就完全将前面索引到数组末尾的元素都包含进来了。

    这样,我们要包含整个数组中的元素就可以采用如下的几种方式:

Python代码 python入门练习题目2.2  python入门练习题目2.2python入门练习题目2.2
  1. >>> l[0:]  
  2. [0123456789]  
  3. >>> l[:]  
  4. [0123456789]  
  5. >>> l  
  6. [0123456789]  

    从前面我们用l[a:b] 的方式来访问元素来看,我们这里a, b取的值要么满足0<= a <= b 或者 a >= 0 b < 0。实际上,a所对应元素的位置总是在b所对应位置的后面。那么,如果我们把他们的顺序倒过来一下会怎么样呢?比如说:

Python代码 python入门练习题目2.2  python入门练习题目2.2python入门练习题目2.2
  1. >>> l[5:2]  
  2. []  
  3. >>> l[-1:3]  
  4. []  

    在这里,我们发现,如果实际取的元素先从右边开始然后到左边的话,并不是我们所期望的返回一个倒过来的数组,而是返回一个空的数组。我举的这个例子有什么用呢?别急,看了后面那一节你就知道了。

理解extended slice

    前面那一部分相对来说还是比较好理解的。现在,如果我们有一些其他的要求,比如说,我们想返回数组里面索引为奇数的元素,或者索引为偶数的元素,那么该怎么办呢?

我们可以有几种办法来做,其中的一种就是采用extended slice,一个典型的解决方法如下:

Python代码 python入门练习题目2.2  python入门练习题目2.2python入门练习题目2.2
  1. >>> l[::2]  
  2. [02468]  
  3. >>> l[1::2]  
  4. [13579]  
  5. >>>   

    前面这种包含两个冒号的样式是怎么回事呢?

     实际上,我们这边第一个冒号隔开的这两个部分和前面的意思是一样的,就是指定数组中间元素的区间。所以前面第一个l[::2]前面就是指的整个数组的元素。而后面那个部分则是指的一个步长。这表示什么意思呢?就是既然我们前面指定的是整个数组,那么它就是从0开始,然后每次访问后面相邻的元素。而设置为2之后呢,则访问后面和它距离为2的元素,而不是直接相邻的元素。这样,我们也就容易理解l[1::2],它就是从元素1开始到结尾的元素集合里取间隔为2的这些元素。

    到这一步,就离我们理解前面那个古怪的l[::-1]很接近了。我们前面的这个取步长是将步长设置为正数,所以在取元素的集合里它表示从左到右的取指定步长覆盖的元素。如果我们将步长设置为负数呢?我们来看:

Python代码 python入门练习题目2.2  python入门练习题目2.2python入门练习题目2.2
  1. >>> l[1:9:-1]  
  2. []  
  3. >>> l[9:1:-1]  
  4. [98765432]  

    有了前面这一部分的代码,相信就不难理解了。我们取区间[1, 9),结果取步长为-1的时候返回的是一个空的集合。而我们取9到1的时候,步长为-1取出来了倒序的数组。这是因为如果我们指定的步长为负数的话,那么它必须和数据指定的区间方向一致。也就是说,如果我们前面指定的区间是从数组小的索引到大的索引,那么我指定的步长必然也要从小到大。所以必须为正数。而如果我们指定的区间是从后面往前的话,则步长必须指定为负数。否则返回的结果都是空的数组。

总结

    有了前面那么多的讨论,我们再来看数组的slice访问。他们无非就是这么几个情况,在l[a:b]的情况下,必须保证a所在的索引位置在前,b所在的索引位置在后,否则返回结果为空。在l[a:b:step]的情况下,我们首先要根据a, b的位置来判断方向,a在前,b在后的话,step应该为正,否则应该为负。不符合这些情况的话,则返回空的数组。也就是说,看a, b的位置来确定方向,不要犯方向性的错误,否则就竹篮打水一场空了:)

扩展知识(二、切片):

eval()函数十分强大,官方demo解释为:将字符串str当成有效的表达式来求值并返回计算结果。

so,结合math当成一个计算器很好用。

其他用法,可以把list,tuple,dict和string相互转化。见下例子:

a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"

b = eval(a)

b
Out[3]: [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]

type(b)
Out[4]: list

a = "{1: 'a', 2: 'b'}"

b = eval(a)

b
Out[7]: {1: 'a', 2: 'b'}

type(b)
Out[8]: dict

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

b = eval(a)

b
Out[11]: ([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))