标签：开头 lis 个数 new 注意 划线 删除 unicode ubunt
Python中有6种序列：列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。序列通用操作包括：索引、切片、长度、加、乘、最大值、最小值，遍历和检查成员。虽然Python有6中内置序列，但是最常用的是列表和元组。所有本博文将深入列表和元组，掌握其方法！
看了上面说的，现在是不是一头雾水，其实上面提到的操作无非不过一些方法而已，熟练应用就掌握了，那先来看看列表的方法吧：
In [3]: dir(list) Out[3]: [‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__iadd__‘, ‘__imul__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__reversed__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘append‘, ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘]
补充：有些方法有两个前导下划线和两个后置下划线，这是特殊方法的意思，应用于特殊函数，实际应用中很少用到，常用的是普通方法。
可以看到，列表的方法其实不是很多，但是使用技巧却很灵活，盘它！
列表的初始化前面已经说过了，这里再来复习一下，被一对方括号括住，元素用逗号隔开就是列表：
In [4]: systems = [‘CentOs‘,‘Windows‘, ‘Ubuntu‘] # 元素全是字符串的列表 In [5]: systems = [‘CentOs‘,‘Windows‘, ‘Ubuntu‘, 666] # 元素既有字符串又有数字 In [6]: systems = [‘CentOs‘,‘Windows‘, ‘Ubuntu‘, 666, [‘MacOs‘]] #列表包含列表 In [7]: systems = [‘CentOs‘,‘Windows‘, ‘Ubuntu‘, 666, [‘MacOs‘],{‘phone‘:‘IOS‘}] # 列表还可以包含字典
列表中每个元素都会被分配一个数字，这个数字就是对应元素的位置，称为索引。第一个元素的索引为0，第二个元素的索引为1，第三个元素的索引为2，依此类推。
注意：计算机中，几乎所有的索引都是从0开始的，在涉及索引操作时，一定要注意这一点
通过索引访问列表元素：
In [8]: systems = [‘CentOs‘,‘Windows‘, ‘Ubuntu‘] In [9]: systems[0] Out[9]: ‘CentOs‘ In [10]: systems[1] Out[10]: ‘Windows‘ In [11]: systems[2] Out[11]: ‘Ubuntu‘
上面说到列表使用技巧灵活，是有道理的：可以使用 索引为-1 来直接获取最后一个元素，也就是说，列表的索引可以倒着来：
In [12]: systems = [‘CentOs‘,‘Windows‘, ‘Ubuntu‘] In [13]: systems[-1] # 直接获取最后一个元素 Out[13]: ‘Ubuntu‘ In [14]: systems[-2] Out[14]: ‘Windows‘ In [15]: systems[-3] Out[15]: ‘CentOs‘ In [16]: systems[-4] # 没有索引-4，会抛出超出范围的异常 --------------------------------------------------------------------------- IndexError Traceback (most recent call last) <ipython-input-16-2b502eee5f42> in <module> ----> 1 systems[-4] IndexError: list index out of range
通过元素获取索引：
In [17]: systems = [‘CentOs‘,‘Windows‘, ‘Ubuntu‘] In [18]: systems.index(‘Windows‘) Out[18]: 1
要说列表玩的6不6，就看切片熟不熟。切片其实就是一次性获取多个元素：
In [19]: systems = [‘CentOs‘,‘Windows‘, ‘Ubuntu‘] In [20]: systems[0:2] Out[20]: [‘CentOs‘, ‘Windows‘]
如上面代码所示，切片的操作为：列表[开始:结束:间隔] ，间隔默认为1，可以省略不写。
注意：切片的两个索引取左不取右，也就是是说，左闭右开
来看更灵活的使用方法：
In [21]: systems = [‘CentOs‘,‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘] In [22]: systems[2:5] # 获取索引为2到5的元素，不包括5 Out[22]: [‘Ubuntu‘, ‘IOS‘, ‘Android‘] In [24]: systems[2:-1] # 获取索引为2到-1的元素，不包括-1 Out[24]: [‘Ubuntu‘, ‘IOS‘] In [25]: systems[0:5] # 获取开头元素到索引为5的元素，不包括5 Out[25]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘] In [26]: systems[:5] # 从开头取的话可以将0忽略，效果与上句一样 Out[26]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘] In [28]: systems[2:] # 结尾是列表的最后一个元素时，必须省略不写，写-1的话就取不到最后一个元素了 Out[28]: [‘Ubuntu‘, ‘IOS‘, ‘Android‘] In [29]: systems[:] # 获取全部元素 Out[29]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘] In [30]: systems[1:5:2] # 获取索引为1到5的元素，并且每隔一个元素取一个，不包括5 Out[30]: [‘Windows‘, ‘IOS‘] In [31]: systems[::2] # 从全部元素中每隔一个取一个 Out[31]: [‘CentOs‘, ‘Ubuntu‘, ‘Android‘]
一定要熟练掌握上述方法
列表相加：将不同的列表用 + 号加起来，效果如下：
In [32]: name1 = [‘MinuteSheep‘,‘Mike‘] In [33]: name2 = [‘BigBan‘, ‘Heenoor‘] In [34]: name1 + name2 Out[34]: [‘MinuteSheep‘, ‘Mike‘, ‘BigBan‘, ‘Heenoor‘]
列表扩展：上面列表相加并没有改变原有列表的元素，name1 + name2 是一个新的列表，可以传给变量 name3；而列表的扩展将直接改变被扩展列表：
In [35]: name3 = name1 + name2 # 将name1+name2传给变量name3 In [36]: name3 # 可以看到name3是一个新列表 Out[36]: [‘MinuteSheep‘, ‘Mike‘, ‘BigBan‘, ‘Heenoor‘] In [37]: name1 # name1列表并没有被改变 Out[37]: [‘MinuteSheep‘, ‘Mike‘] In [38]: name2 # name2列表并没有被改变 Out[38]: [‘BigBan‘, ‘Heenoor‘] In [39]: name1.extend(name2) # 用name2扩展name1，使用extemd()方法 In [40]: name1 # 可以看到name1列表被改变，因为name1是被扩展列表 Out[40]: [‘MinuteSheep‘, ‘Mike‘, ‘BigBan‘, ‘Heenoor‘] In [41]: name2 # name2列表并没有被改变或者删除 Out[41]: [‘BigBan‘, ‘Heenoor‘]
列表乘法：将一个列表与一个数字 n 相乘，得到一个 n 倍元素的新列表：
In [44]: systems Out[44]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘] In [45]: systems * 3 Out[45]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘, ‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘, ‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘]
追加：在列表末尾插入一个新的元素：
In [46]: systems Out[46]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘] In [47]: systems.append(‘Unix‘) # 使用append()方法追加 In [48]: systems Out[48]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘, ‘Unix‘]
任意位置插入：在列表的任意位置插入新元素，之前存在元素的位置向后加一：
In [48]: systems Out[48]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘, ‘Unix‘] In [49]: systems.insert(3,‘Dos‘) # 使用 insert(位置,新元素名称) 方法插入新元素 In [50]: systems Out[50]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘Dos‘, ‘IOS‘, ‘Android‘, ‘Unix‘]
直接将被修改的元素重新赋值即可：
In [50]: systems Out[50]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘Dos‘, ‘IOS‘, ‘Android‘, ‘Unix‘] In [51]: systems[3] Out[51]: ‘Dos‘ In [52]: systems[3]= ‘我是之前的Dos，我被修改了‘ # 直接将被修改元素重新赋值即可 In [53]: systems Out[53]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘我是之前的Dos，我被修改了‘, ‘IOS‘, ‘Android‘, ‘Unix‘]
删除最后一个元素：将列表的末尾元素删除：
In [53]: systems Out[53]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘我是之前的Dos，我被修改了‘, ‘IOS‘, ‘Android‘, ‘Unix‘] In [54]: systems.pop() # 使用pop()方法删除末尾元素，并且返回末尾元素 Out[54]: ‘Unix‘ In [55]: systems Out[55]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘我是之前的Dos，我被修改了‘, ‘IOS‘, ‘Android‘]
删除任意位置元素：将列表中任意位置的元素删除：
In [55]: systems Out[55]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘我是之前的Dos，我被修改了‘, ‘IOS‘, ‘Android‘] In [56]: del systems[3] # 使用 del 命令删除元素 In [57]: systems Out[57]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘]
删除指定元素：删除列表中指定的元素，不通过索引删除，直接通过元素的名称删除：
In [57]: systems Out[57]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘] In [58]: systems.remove(‘IOS‘) # 使用remove()方法删除指定元素 In [59]: systems Out[59]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘Android‘]
列表清空：将列表清空，列表依然存在，直是没有元素而已，是一个空列表：
In [59]: systems Out[59]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘Android‘] In [60]: systems.clear() # 使用clear()方法将列表清空 In [61]: systems Out[61]: []
统计列表长度：使用len()统计列表中元素的个数：
In [62]: systems = [‘CentOs‘,‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘] In [63]: len(systems) # 统计个数 Out[63]: 5
统计列表中某个元素的个数：使用count()方法统计指定元素的个数：
In [64]: systems = [‘CentOs‘,‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘,‘IOS‘,‘Windows‘,‘IOS‘] In [65]: systems.count(‘CentOs‘) # 使用count()方法计数 Out[65]: 1 In [66]: systems.count(‘IOS‘) Out[66]: 3
正排序：按照ASC码进行从小到大的排序：
In [67]: systems Out[67]: [‘CentOs‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘Android‘, ‘IOS‘, ‘Windows‘, ‘IOS‘] In [68]: systems.sort() # 使用sort()方法，从小到大排序 In [69]: systems Out[69]: [‘Android‘, ‘CentOs‘, ‘IOS‘, ‘IOS‘, ‘IOS‘, ‘Ubuntu‘, ‘Windows‘, ‘Windows‘]
逆排序：按照ASC码进行从大到小的排序：
In [69]: systems Out[69]: [‘Android‘, ‘CentOs‘, ‘IOS‘, ‘IOS‘, ‘IOS‘, ‘Ubuntu‘, ‘Windows‘, ‘Windows‘] In [70]: systems.reverse() #使用reverse()方法，从大到小排序 In [71]: systems Out[71]: [‘Windows‘, ‘Windows‘, ‘Ubuntu‘, ‘IOS‘, ‘IOS‘, ‘IOS‘, ‘CentOs‘, ‘Android‘]
注意：Python3中，列表例的数据类型一致才可以排序，否则会报错
关于列表的拷贝，有好多种方法，每一种方法都有差别，一起来看下：
方法1： b = a # a是一个列表
In [87]: a = [1,2,3] In [88]: b = a # 把a拷贝给b In [89]: id(a) # 可以看到a和b的地址相同，指向同一块地址 Out[89]: 2762625492040 In [90]: id(b) Out[90]: 2762625492040 In [91]: a.append(5) # 列表a追加元素 In [92]: a Out[92]: [1, 2, 3, 5] In [93]: b # 列表b也改变了，还记得第五节在讲变量时化的那个图吗？ Out[93]: [1, 2, 3, 5]
方法二： b = a[:]
In [94]: a = [1,2,3] In [95]: b = a[:] # 把a列表拷贝给b In [96]: a.append(5) In [97]: a Out[97]: [1, 2, 3, 5] In [98]: b # 可以看到，b并没有跟着改变 Out[98]: [1, 2, 3] In [99]: id(a) # 说明a和b指向不同的地址 Out[99]: 2762624748936 In [100]: id(b) Out[100]: 2762626722504
但是~~
In [107]: a = [1,2,[3]] # a列表里面包含了一个新的列表 In [108]: b = a[:] In [109]: a[-1].append(5) # 子列表追缴一个新的元素 In [110]: a.append(6) # a列表追加一个新的元素 In [111]: a Out[111]: [1, 2, [3, 5], 6] # a变成了这样 In [112]: b # 但是b的子列表却跟着改变了，见鬼了！ Out[112]: [1, 2, [3, 5]] In [113]: id(a) # a和b指向的地址并不一样 Out[113]: 2762626869896 In [114]: id(b) Out[114]: 2762602977160
虽然b = a[:] 这种方式可以拷贝出一个新的列表，但是当列表中包含子列表的时候，拷贝出来的新列表中的子列表会跟着改变╮(╯▽╰)╭，应用的时候一定要注意呐
方式三： b = list(a)
In [115]: a = [1,2,3] In [116]: b = list(a) In [117]: a.append(5) In [118]: a Out[118]: [1, 2, 3, 5] In [119]: b Out[119]: [1, 2, 3] In [120]: a = [1,2,[3]] In [121]: b = list(a) In [122]: a[-1].append(5) In [123]: a.append(6) In [124]: a Out[124]: [1, 2, [3, 5], 6] In [125]: b Out[125]: [1, 2, [3, 5]] In [126]: id(a) Out[126]: 2762627298696 In [127]: id(b) Out[127]: 2762627301000
可以看到与方法二大同小异=====(￣▽￣*)b
方法四： b = a * 1 # a为列表
In [128]: a = [1,2,3] In [129]: b = a * 1 In [130]: a.append(5) In [131]: a Out[131]: [1, 2, 3, 5] In [132]: b Out[132]: [1, 2, 3] In [133]: a = [1,2,[3]] In [134]: b = a * 1 In [135]: a[-1].append(5) In [136]: a.append(6) In [137]: a Out[137]: [1, 2, [3, 5], 6] In [138]: b Out[138]: [1, 2, [3, 5]] In [139]: id(a) Out[139]: 2762627326280 In [140]: id(b) Out[140]: 2762627611016
可以看到，与方法二、方法三大同小异,,???,,
方法五： b = a.copy() # a是列表
In [170]: a = [1,2,3] In [171]: b = a.copy() In [172]: a.append(5) In [173]: a Out[173]: [1, 2, 3, 5] In [174]: b Out[174]: [1, 2, 3] In [175]: a = [1,2,[3]] In [176]: b = a.copy() In [177]: a[-1].append(5) In [178]: a.append(6) In [179]: a Out[179]: [1, 2, [3, 5], 6] In [180]: b Out[180]: [1, 2, [3, 5]] In [181]: id(a) Out[181]: 2762628171912 In [182]: id(b) Out[182]: 2762628181320
可以看到，与方法二、方法三、方法四大同小异(ˉ▽ˉ；)...
方法六： b = copy.copy(a) # a为列表
In [141]: import copy # 需要导入 copy 模块 In [142]: a = [1,2,3] In [143]: b = copy.copy(a) In [144]: a.append(5) In [145]: a Out[145]: [1, 2, 3, 5] In [146]: b Out[146]: [1, 2, 3] In [147]: a = [1,2,[3]] In [148]: b = copy.copy(a) In [149]: a[-1].append(5) In [150]: a.append(6) In [151]: a Out[151]: [1, 2, [3, 5], 6] In [152]: b Out[152]: [1, 2, [3, 5]] In [153]: id(a) Out[153]: 2762602926984 In [154]: id(b) Out[154]: 2762627609608
可以看到，与方法二、方法三、方法四、方法五大同小异(ˉ▽ˉ；)...
方法七： b = copy.deepcopy(a) # a为列表
In [155]: import copy In [156]: a = [1,2,3] In [157]: b = copy.deepcopy(a) In [158]: a.append(5) In [159]: a Out[159]: [1, 2, 3, 5] In [160]: b Out[160]: [1, 2, 3] In [161]: a = [1,2,[3]] In [162]: b = copy.deepcopy(a) In [163]: a[-1].append(5) In [164]: a.append(6) In [165]: a Out[165]: [1, 2, [3, 5], 6] In [166]: b # 这次b终于没有被改变 Out[166]: [1, 2, [3]] In [167]: id(a) Out[167]: 2762627600712 In [168]: id(b) Out[168]: 2762625604936
哇~~这一次b列表终于没有跟着改变ヾ(≧▽≦*)o
从以上七种方法可以看到，方法一最不推荐使用，方法二、方法三、方法四、方法五、方法六大同小异，都是复制列表后得到一个新的列表，但是一点列表中含有子列表，复制过来的列表中的子列表还是会跟着改变，方法七才会真正的做到完全复制且不是任何影响。
来一个列表的总结：
a.append(x) # 列表a追加元素x a.clear() # 将列表a清空 a.copy() # 拷贝列表a a.count(x) # 对a列表的元素x计数 a.extend(b) # 把b列表扩展到a列表中 a.index(x) # 查询a列表中x元素的索引 a.insert(n,x) # 在列表a的第n个位置处插入元素x a.pop() # 将列表a的末尾元素删除，并返回这个元素 a.remove(x) # 将列表a的元素x删除 a.reverse() # 按ASC码进行从大到小的排序 a.sort() # 按ASC码进行从小到大的排序
元组与列表相似，只不过元组不能修改其内部元素。列表使用方括号，而元组使用圆括号。
In [193]: dir(tuple) Out[193]: [‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__getnewargs__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘count‘, ‘index‘]
可以看到，元组的方法少的可怜，只有 count 和 index 方法
与列表类似，用一对圆括号括起来，元素之间用逗号分隔开,需要注意的是元组最后一定要加逗号：
In [184]: systems = (‘Linux‘, ‘Windows‘, ‘Unix‘,) In [185]: systems = (‘Linux‘, ‘Windows‘, ‘Unix‘, 666,) In [186]: systems = (‘Linux‘, ‘Windows‘, ‘Unix‘, 666, [1, 3,5],) In [187]: systems = (‘Linux‘, ‘Windows‘, ‘Unix‘, 666, [1, 3,5], (2,4,6),) In [188]: systems = (‘Linux‘, ‘Windows‘, ‘Unix‘, 666, [1, 3,5], (2,4,6), {‘a‘:250},) # 与列表极为相似
同列表一样
In [189]: systems = (‘Linux‘, ‘Windows‘, ‘Unix‘,) In [190]: systems[1] Out[190]: ‘Windows‘
同列表一样
In [191]: systems = (‘Linux‘, ‘Windows‘, ‘Unix‘,) In [192]: systems[2:] Out[192]: (‘Unix‘,)
同列表一样
In [194]: systems Out[194]: (‘Linux‘, ‘Windows‘, ‘Unix‘,) In [197]: systems1 = (‘IOS‘,) In [198]: systems + systems1 Out[198]: (‘Linux‘, ‘Windows‘, ‘Unix‘, ‘IOS‘,) In [200]: systems * 3 Out[200]: (‘Linux‘, ‘Windows‘, ‘Unix‘, ‘Linux‘, ‘Windows‘, ‘Unix‘, ‘Linux‘, ‘Windows‘, ‘Unix‘,)
同列表一样
In [202]: systems = (‘Linux‘, ‘Windows‘, ‘Unix‘,) In [203]: systems.count(‘Linux‘) Out[203]: 1
In [204]: len(systems)
Out[204]: 3
元组就这么多o_o ....
标签：开头 lis 个数 new 注意 划线 删除 unicode ubunt
原文地址：https://www.cnblogs.com/minutesheep/p/10325694.html
