python学习之“切片操作从入门到精通”

在python学习开发的过程中,我们总是不断的要对List(列表),Tuple(元组)有取值操作:假如我们有一个列表List1现在想取出1其中的前5个元素,改怎么操作呢?

1 >>> List1 = [‘zhangxueyou‘,‘liuyifei‘,‘liudehua‘,‘huyidao‘,‘haodada‘,‘wumengda‘,‘zhouxingchi‘,‘chenglong‘,‘Jack‘,‘linzhilin‘]
2 >>> List1
3 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘, ‘wumengda‘, ‘zhouxingchi‘, ‘chenglong‘, ‘Jack‘, ‘linzhilin‘]
4 >>> #比较笨的办法是直接取值
5 ...
6 >>> [List1[1],List1[2],List1[3],List1[4],List1[5]]
7 [‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘, ‘wumengda‘]
8 >>> 

以上的直接取值的方法是存在很大的局限性的,假如现在想取前一百万个值的话,是不是就没有办法了呢?但是你还是可以用循环完成:

 1 >>> List1
 2 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘, ‘wumengda‘, ‘zhouxingchi‘, ‘chenglong‘, ‘Jack‘, ‘linzhilin‘]
 3 >>> List2 = []
 4 >>> List2
 5 []
 6 >>> n = 5
 7 >>> for i in range(n):
 8 ...     List2.append(List1[i])
 9 ...
10 >>> List2
11 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘]
12 >>> 

但是,对这种经常取指定索引的范围的操作,假如你使用循环的话使可以解决的,但是相对更好的方法而言,此操作是相当繁琐和费事的。因此python就提供了一个比较重量级的方法:切片(Slice)操作,能大大的简化操作。

对于同样的问题,只需要简单的一个切片操作就可以取得同样的效果:

 1 >>> List1
 2 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘, ‘wumengda‘, ‘zhouxingchi‘, ‘chenglong‘, ‘Jack‘, ‘linzhilin‘]
 3 >>> #比较笨的办法是直接取值
 4 ...
 5 >>> [List1[1],List1[2],List1[3],List1[4],List1[5]]
 6 [‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘, ‘wumengda‘]
 7 >>>
 8 >>>
 9 >>>
10 >>>
11 #使用循环取值:比较繁琐
12 >>> List1
13 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘, ‘wumengda‘, ‘zhouxingchi‘, ‘chenglong‘, ‘Jack‘, ‘linzhilin‘]
14 >>> List2 = []
15 >>> List2
16 []
17 >>> n = 5
18 >>> for i in range(n):
19 ...     List2.append(List1[i])
20 ...
21 >>> List2
22 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘]
23 >>> #切片操作的演示:
24 ...
25 >>> List1[0:4]
26 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘]
27 >>> List1[0:5]
28 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘]
29 >>> 

注意:List1[0:5]表示的含义是,从索引0开始直到取到5个元素,因此,取到的元素索引为:0,1,2,3,4但是不包含第六个数的索引5,这里刚好取到了5个元素。故,记住切片的口诀就是:“顾头不顾尾”。假如你的第一个索引是“0”,那么你可以省略不写:

1 >>> List1
2 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘, ‘wumengda‘, ‘zhouxingchi‘, ‘chenglong‘, ‘Jack‘, ‘linzhilin‘]
3 >>> #索引为0的情况可以省略
4 ...
5 >>> List1[:5]
6 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘]
7 >>> List1[0:5]
8 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘]
9 >>> 

python是支持负索引的,即List1[-1],List1[-2],同样,切片也是支持负索引的:

1 >>> List1
2 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘, ‘wumengda‘, ‘zhouxingchi‘, ‘chenglong‘, ‘Jack‘, ‘linzhilin‘]
3 >>> List1[-2:]
4 [‘Jack‘, ‘linzhilin‘]
5 >>> List1[-2:-1]
6 [‘Jack‘]
7 >>> List1[:-1]
8 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘, ‘wumengda‘, ‘zhouxingchi‘, ‘chenglong‘, ‘Jack‘]
9 >>> #记住:倒数第一个元素的索引采用负索引的话就是-1

切片在python开发过程中是十分有用的,首先我们创建一个0-199的数列:

1 >>> List3 = range(199)
2 >>> List3
3 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198]
4 >>> 

然后,我们就可以在其中取出任意一段长度值:

1 >>> List3[:50]#取出前50个数
2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
3 >>> List3[:-100]#取出前50个数
4 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98]

还可以添加“步长“取值:

1 >>> List3
2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198]
3 >>> List3[:100:5]#步长为5
4 [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
5 >>> 

甚至什么都不写,只写[:]就可以原样复制一个list:

1 >>> List1[:]
2 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘, ‘wumengda‘, ‘zhouxingchi‘, ‘chenglong‘, ‘Jack‘, ‘linzhilin‘]
3 >>> List2[:]
4 [‘zhangxueyou‘, ‘liuyifei‘, ‘liudehua‘, ‘huyidao‘, ‘haodada‘]
5 >>> List3[:]
6 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198]
7 >>> 

tuple也是一种list,唯一区别是tuple不可变。因此,tuple也可以用切片操作,只是操作的结果仍是tuple:

1 >>> tuple1 = (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)
2 >>> tuple1[:10]
3 (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
4 >>> tuple1[:-8]
5 (1, 2, 3, 4, 5, 6, 7)
6 >>> 

字符串‘xxx‘或Unicode字符串u‘xxx‘也可以看成是一种list,每个元素就是一个字符。因此,字符串也可以用切片操作,只是操作结果仍是字符串:

1 >>> "ABCDEFGHIJKLMNOPQRST"[:5]
2 ‘ABCDE‘
3 >>> "ABCDEFGHIJKLMNOPQRST"[:-6]
4 ‘ABCDEFGHIJKLMN‘
5 >>> 

在很多编程语言中,针对字符串提供了很多各种截取函数,其实目的就是对字符串切片。Python没有针对字符串的截取函数,只需要切片一个操作就可以完成,非常简单。

注意:当你的索引超出你要索引的元组或者列表的范围的时候是不会报任何错误的,只会按照列表或者元组的的、最大长度来显示:

1 >>> List3
2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198]
3 >>> List3[:231] #这里明显已经超出了列表的范围
4 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198]

python切片中的高级操作:

1. 切片的原理分析:

list的切片,内部是调用__getitem__,__setitem__,__delitem__和slice函数。而slice函数又是和range()函数相关的。

给切片传递的键是一个特殊的slice对象。该对象拥有可描述所请求切片方位的属性,切片的含义和演示:

1 >>> List4 = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
2 >>> List4
3 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
4 >>> x = List4[1:10] #x = List4.__getitem__(slice(1,10,None))
5 >>> List4[1:5]=[100,111,122] #List4.setitem__(slice(1,3,None),[100,111,122])
6 >>> del List4[1:4] #List4.del__delitem__(slice(1,4,None))
7 >>> List4
8 [1, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
9 >>> 

带步长的python切片:

1 >>> List4
2 [1, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
3 >>> List4[0:20:2] #其中2为步长值
4 [1, 7, 9, 11, 13, 15, 17, 19]
5 >>> 

注意:步进值为step

当step > 0 时

切片从 start(含start)处开始,到end(不含end)处结束,**从左往右**,每隔(step-1)(索引之间的差仍为step,但相隔的元素是step-1个)个元素进行一次截取。

这时,start 指向的位置应该在end指向的位置的左边,否则返回值为空

当step < 0 时

切片从 start(含start)处开始,到end(不含end)处结束,**从右往左**,每隔(step-1)(索引之间的差仍为step,但相隔的元素是step-1个)个元素进行一次截取。

这时,start 指向的位置应该在end指向的位置的右边,否则返回值为空

这里有一个比较经典的字符串反向的例子:

1 >>> strin = "Hello World!"
2 >>> strin[::-1]
3 ‘!dlroW olleH‘
4 >>> 

切片的边界问题:

1 s=[1,2,3,4]       # S 上界为 0 下界为 4
2 s[-100:100]       #返回 [1,2,3,4] -100超出了上界,100超出了下界:等价于 s[0:4]
3 s[-100:-200]      #返回 [] -100,-200均超出了上界,自动取上界:等价于s[0:0]
4 s[100:200]        #返回 [] 100,200均超出了下界,自动取下界值:等价于s[4:4]
5 s[:100]           #返回 [1,2,3,4] 开始值省略表示从第0个开始
6 s[0:]             #返回 [1,2,3,4] 结束值为空表示到最后一个结束

2. 切片的扩展知识:

 1 >>> id(List4)
 2 140115516658320
 3 #直接通过列表来赋值 List5 = List4,指向的内存地址空间是不变的,都是(140115516658320),无论删除List4还是List5这个列表都会被删除,即List4和List5都没有元素了。
 4 >>> List5 = List4
 5 >>> List5
 6 [1, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
 7 >>> List4
 8 [1, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
 9 >>> id(List5)
10 140115516658320
11 #但是,通过切片来命名的两个列表他们指向的内存地址编号是不同的,140115516658320 !=  140115516604784
12 >>> List6 = List5
13 >>> id(List6)
14 140115516658320
15 >>> List6 = List4[:]
16 >>> id(List6)
17 140115516604784
18 >>> #地址改变
19 ...
20 >>> 
时间: 2024-10-11 12:33:14

python学习之“切片操作从入门到精通”的相关文章

Python学习(一):入门篇:python中的一些数据结构

Python里的一些基本知识点总结 Last Edit 2014/5/2 这里记录的是Python2.7版本的语法特征,部分与Python3.0是不一样的. 一,关于开发环境 在windows下可以直接在官网下载相关的版本,然后默认安装.使用直带的IDLE编辑器. IDLE中两个有用的快捷键: ALT+P:重复历史命令(从最近到最老) ALT+N:   重复历史命令(从最老到最近) IDLE中没有清屏功能. 在cmd中进行: 1,首先要在环境变量的path中添加相关的路径: C:\Python2

Python中的切片操作

Python中的切片操作功能十分强大,通常我们利用切片来进行提取信息,进行相关的操作,下面就是一些切片的列子,一起来看看吧,希望对大家学习python有所帮助. 列如我们从range函数1-100中取7的倍数,函数及结果如下所示: >>> for i in range(1,100)[6::7]: print i 7 14 21 28 35 42 49 56 63 70 77 84 91 98 取一个list或tuple的部分元素是非常常见的操作.比如,一个list如下: >>

[Python] Python 学习 - 可视化数据操作(一)

Python 学习 - 可视化数据操作(一) GitHub:https://github.com/liqingwen2015/my_data_view 目录 折线图 散点图 随机漫步 骰子点数概率 文件目录 折线图 cube_squares.py import matplotlib.pyplot as plt x_values=list(range(1, 5000)) y_values=[pow(x, 3) for x in x_values] plt.scatter(x_values, y_v

Python学习(三):入门篇:Python中怎么编写类

Python中怎么编写类 Last Edit 2013/5/2 先看一个例子: #person.py class person: """class to representaion a person""" def __init__(self,name,age): self.name=name if 0<age<=150: self.age=age else: print 'age is no valid!' def display(s

Python学习(二):入门篇:python中流程控制与函数编写

python中流程控制与函数编写 Last Eidt 2014/5/2 转载请注明出处http://blog.csdn.net/jxlijunhao 一,流程控制 1)布尔逻辑 Python中利用True来表示逻辑真,False来逻辑假 not :非 and:与 or   :或 ==  :逻辑等 >>> False==True False >>> False==False True >>> not False True >>> Fal

Python基础知识详解 从入门到精通(七)类与对象

本篇主要是介绍python,内容可先看目录其他基础知识详解,欢迎查看本人的其他文章Python基础知识详解 从入门到精通(一)介绍Python基础知识详解 从入门到精通(二)基础Python基础知识详解 从入门到精通(三)语法与函数Python基础知识详解 从入门到精通(四)列表.元组.字典.集合Python基础知识详解 从入门到精通(五)模块管理Python基础知识详解 从入门到精通(六)文件操作PS:很多人在学习Python的过程中,往往因为遇问题解决不了或者没好的教程从而导致自己放弃,为此

Python序列的切片操作与技巧

切片操作 对于具有序列结构的数据来说,切片操作的方法是:consequence[start_index: end_index: step]. start_index: 表示是第一个元素对象,正索引位置默认为0:负索引位置默认为 -len(consequence) end_index: 表示是最后一个元素对象,正索引位置默认为 len(consequence)-1:负索引位置默认为 -1. step: 表示取值的步长,默认为1,步长值不能为0. [注意]对于序列结构数据来说,索引和步长都具有正负两

python学习日常-切片&amp;迭代&amp;列表生成式

切片:顾名思义,就是将一个东西切成一块一块的,python中的切片就是将数组切成一片一片的 L=list(range(1,100)); L(f:e:p)#f代表开始切的位置,e代表结束的位置(但不包括),p代表切的间隔. 比如L(10:26:2)代表从第10位开始切(即从数字为11开始)到26结束(即数字27),但是不包括第26位,其中间隔为2. 切片也支持从后面切比如L(-10:-1:none)就是从倒数第10位开始切到最后一位. 值得注意的是切片的三个参数都是可以缺省的. 迭代:非常简单的一

Python学习之--文件操作

Python中对文件操作可以用内置的open()函数 读文件 f=open('/home/test/test.txt','r') # 读模式打开文件 f.read() # 读取文件内容 除了正常的读取文件内容,一个常用的操作是判断文件内容是否为空,如下: if len(f.read())==0: # 如果文件内容为空 xxxx 判断一个文件或者路径是否存在,如下(这里需要在代码中导入os module: import os): file='/home/test/test.txt' dir='/h