前言

Python中有6种序列：列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。序列通用操作包括：索引、切片、长度、加、乘、最大值、最小值，遍历和检查成员。虽然Python有6中内置序列，但是最常用的是列表和元组。所有本博文将深入列表和元组，掌握其方法！

一、列表（list）

看了上面说的，现在是不是一头雾水，其实上面提到的操作无非不过一些方法而已，熟练应用就掌握了，那先来看看列表的方法吧：

  1. In []: dir(list)
  2. 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']

补充：有些方法有两个前导下划线和两个后置下划线，这是特殊方法的意思，应用于特殊函数，实际应用中很少用到，常用的是普通方法。

可以看到，列表的方法其实不是很多，但是使用技巧却很灵活，盘它！

1.初始化列表

列表的初始化前面已经说过了，这里再来复习一下，被一对方括号括住，元素用逗号隔开就是列表：

  1. In [4]: systems = ['CentOs','Windows', 'Ubuntu']   # 元素全是字符串的列表
  2.  
  3. In [5]: systems = ['CentOs','Windows', 'Ubuntu', 666]   # 元素既有字符串又有数字
  4.  
  5. In [6]: systems = ['CentOs','Windows', 'Ubuntu', 666, ['MacOs']]   #列表包含列表
  6.  
  7. In [7]: systems = ['CentOs','Windows', 'Ubuntu', 666, ['MacOs'],{'phone':'IOS'}]   # 列表还可以包含字典

2.列表索引

列表中每个元素都会被分配一个数字，这个数字就是对应元素的位置，称为索引。第一个元素的索引为0，第二个元素的索引为1，第三个元素的索引为2，依此类推。

注意：计算机中，几乎所有的索引都是从0开始的，在涉及索引操作时，一定要注意这一点

通过索引访问列表元素：

  1. In [8]: systems = ['CentOs','Windows', 'Ubuntu']
  2.  
  3. In [9]: systems[0]
  4. Out[9]: 'CentOs'
  5.  
  6. In [10]: systems[1]
  7. Out[10]: 'Windows'
  8.  
  9. In [11]: systems[2]
  10. Out[11]: 'Ubuntu'

上面说到列表使用技巧灵活，是有道理的：可以使用 索引为-1 来直接获取最后一个元素，也就是说，列表的索引可以倒着来：

  1. In [12]: systems = ['CentOs','Windows', 'Ubuntu']
  2.  
  3. In [13]: systems[-1]     # 直接获取最后一个元素
  4. Out[13]: 'Ubuntu'
  5.  
  6. In [14]: systems[-2]
  7. Out[14]: 'Windows'
  8.  
  9. In [15]: systems[-3]
  10. Out[15]: 'CentOs'
  11.  
  12. In [16]: systems[-4]     # 没有索引-4，会抛出超出范围的异常
  13. ---------------------------------------------------------------------------
  14. IndexError                                Traceback (most recent call last)
  15. <ipython-input-16-2b502eee5f42> in <module>
  16. ----> 1 systems[-4]
  17.  
  18. IndexError: list index out of range

通过元素获取索引：

  1. In [17]: systems = ['CentOs','Windows', 'Ubuntu']
  2.  
  3. In [18]: systems.index('Windows')
  4. Out[18]: 1

3.列表切片

要说列表玩的6不6，就看切片熟不熟。切片其实就是一次性获取多个元素：

  1. In [19]: systems = ['CentOs','Windows', 'Ubuntu']
  2.  
  3. In [20]: systems[0:2]
  4. Out[20]: ['CentOs', 'Windows']

如上面代码所示，切片的操作为：列表[开始:结束:间隔] ，间隔默认为1，可以省略不写。

注意：切片的两个索引取左不取右，也就是是说，左闭右开

来看更灵活的使用方法：

  1. In [21]: systems = ['CentOs','Windows', 'Ubuntu', 'IOS', 'Android']
  2.  
  3. In [22]: systems[2:5]          # 获取索引为2到5的元素，不包括5
  4. Out[22]: ['Ubuntu', 'IOS', 'Android']
  5.  
  6. In [24]: systems[2:-1]         # 获取索引为2到-1的元素，不包括-1
  7. Out[24]: ['Ubuntu', 'IOS']
  8.  
  9. In [25]: systems[0:5]          # 获取开头元素到索引为5的元素，不包括5
  10. Out[25]: ['CentOs', 'Windows', 'Ubuntu', 'IOS', 'Android']
  11.  
  12. In [26]: systems[:5]           # 从开头取的话可以将0忽略，效果与上句一样
  13. Out[26]: ['CentOs', 'Windows', 'Ubuntu', 'IOS', 'Android']
  14.  
  15. In [28]: systems[2:]           # 结尾是列表的最后一个元素时，必须省略不写，写-1的话就取不到最后一个元素了
  16. Out[28]: ['Ubuntu', 'IOS', 'Android']
  17.  
  18. In [29]: systems[:]            # 获取全部元素
  19. Out[29]: ['CentOs', 'Windows', 'Ubuntu', 'IOS', 'Android']
  20.  
  21. In [30]: systems[1:5:2]        # 获取索引为1到5的元素，并且每隔一个元素取一个，不包括5
  22. Out[30]: ['Windows', 'IOS']
  23.  
  24. In [31]: systems[::2]          # 从全部元素中每隔一个取一个
  25. Out[31]: ['CentOs', 'Ubuntu', 'Android']

一定要熟练掌握上述方法

4.列表组合

列表相加：将不同的列表用 + 号加起来，效果如下：

  1. In [32]: name1 = ['MinuteSheep','Mike']
  2.  
  3. In [33]: name2 = ['BigBan', 'Heenoor']
  4.  
  5. In [34]: name1 + name2
  6. Out[34]: ['MinuteSheep', 'Mike', 'BigBan', 'Heenoor']

列表扩展：上面列表相加并没有改变原有列表的元素，name1 + name2 是一个新的列表，可以传给变量 name3；而列表的扩展将直接改变被扩展列表：

  1. In [35]: name3 = name1 + name2   # 将name1+name2传给变量name3
  2.  
  3. In [36]: name3                   # 可以看到name3是一个新列表
  4. Out[36]: ['MinuteSheep', 'Mike', 'BigBan', 'Heenoor']
  5.  
  6. In [37]: name1                   # name1列表并没有被改变
  7. Out[37]: ['MinuteSheep', 'Mike']
  8.  
  9. In [38]: name2                   # name2列表并没有被改变
  10. Out[38]: ['BigBan', 'Heenoor']
  11.  
  12. In [39]: name1.extend(name2)     # 用name2扩展name1，使用extemd()方法
  13.  
  14. In [40]: name1                   # 可以看到name1列表被改变，因为name1是被扩展列表
  15. Out[40]: ['MinuteSheep', 'Mike', 'BigBan', 'Heenoor']
  16.  
  17. In [41]: name2                   # name2列表并没有被改变或者删除
  18. Out[41]: ['BigBan', 'Heenoor']

列表乘法：将一个列表与一个数字 n 相乘，得到一个 n 倍元素的新列表：

  1. In [44]: systems
  2. Out[44]: ['CentOs', 'Windows', 'Ubuntu', 'IOS', 'Android']
  3.  
  4. In [45]: systems * 3
  5. Out[45]:
  6. ['CentOs', 'Windows', 'Ubuntu', 'IOS', 'Android', 'CentOs', 'Windows', 'Ubuntu', 'IOS', 'Android', 'CentOs', 'Windows', 'Ubuntu', 'IOS', 'Android']

5.插入元素

追加：在列表末尾插入一个新的元素：

  1. In [46]: systems
  2. Out[46]: ['CentOs', 'Windows', 'Ubuntu', 'IOS', 'Android']
  3.  
  4. In [47]: systems.append('Unix')      # 使用append()方法追加
  5.  
  6. In [48]: systems
  7. Out[48]: ['CentOs', 'Windows', 'Ubuntu', 'IOS', 'Android', 'Unix']

任意位置插入：在列表的任意位置插入新元素，之前存在元素的位置向后加一：

  1. In [48]: systems
  2. Out[48]: ['CentOs', 'Windows', 'Ubuntu', 'IOS', 'Android', 'Unix']
  3.  
  4. In [49]: systems.insert(3,'Dos')     # 使用 insert(位置,新元素名称) 方法插入新元素
  5.  
  6. In [50]: systems
  7. Out[50]: ['CentOs', 'Windows', 'Ubuntu', 'Dos', 'IOS', 'Android', 'Unix']

6.修改列表

直接将被修改的元素重新赋值即可：

  1. In [50]: systems
  2. Out[50]: ['CentOs', 'Windows', 'Ubuntu', 'Dos', 'IOS', 'Android', 'Unix']
  3.  
  4. In [51]: systems[3]
  5. Out[51]: 'Dos'
  6.  
  7. In [52]: systems[3]= '我是之前的Dos，我被修改了'   # 直接将被修改元素重新赋值即可
  8.  
  9. In [53]: systems
  10. Out[53]: ['CentOs', 'Windows', 'Ubuntu', '我是之前的Dos，我被修改了', 'IOS', 'Android', 'Unix']

7.删除元素

删除最后一个元素：将列表的末尾元素删除：

  1. In [53]: systems
  2. Out[53]: ['CentOs', 'Windows', 'Ubuntu', '我是之前的Dos，我被修改了', 'IOS', 'Android', 'Unix']
  3.  
  4. In [54]: systems.pop()      # 使用pop()方法删除末尾元素，并且返回末尾元素
  5. Out[54]: 'Unix'
  6.  
  7. In [55]: systems
  8. Out[55]: ['CentOs', 'Windows', 'Ubuntu', '我是之前的Dos，我被修改了', 'IOS', 'Android']

删除任意位置元素：将列表中任意位置的元素删除：

  1. In [55]: systems
  2. Out[55]: ['CentOs', 'Windows', 'Ubuntu', '我是之前的Dos，我被修改了', 'IOS', 'Android']
  3.  
  4. In [56]: del systems[3]     # 使用 del 命令删除元素
  5.  
  6. In [57]: systems
  7. Out[57]: ['CentOs', 'Windows', 'Ubuntu', 'IOS', 'Android']

删除指定元素：删除列表中指定的元素，不通过索引删除，直接通过元素的名称删除：

  1. In [57]: systems
  2. Out[57]: ['CentOs', 'Windows', 'Ubuntu', 'IOS', 'Android']
  3.  
  4. In [58]: systems.remove('IOS')   # 使用remove()方法删除指定元素
  5.  
  6. In [59]: systems
  7. Out[59]: ['CentOs', 'Windows', 'Ubuntu', 'Android']

列表清空：将列表清空，列表依然存在，直是没有元素而已，是一个空列表：

  1. In [59]: systems
  2. Out[59]: ['CentOs', 'Windows', 'Ubuntu', 'Android']
  3.  
  4. In [60]: systems.clear()        # 使用clear()方法将列表清空
  5.  
  6. In [61]: systems
  7. Out[61]: []

8.列表统计

统计列表长度：使用len()统计列表中元素的个数：

  1. In [62]: systems = ['CentOs','Windows', 'Ubuntu', 'IOS', 'Android']
  2.  
  3. In [63]: len(systems)   # 统计个数
  4. Out[63]: 5

统计列表中某个元素的个数：使用count()方法统计指定元素的个数：

  1. In [64]: systems = ['CentOs','Windows', 'Ubuntu', 'IOS', 'Android','IOS','Windows','IOS']
  2.  
  3. In [65]: systems.count('CentOs')   # 使用count()方法计数
  4. Out[65]: 1
  5.  
  6. In [66]: systems.count('IOS')
  7. Out[66]: 3

正排序：按照ASC码进行从小到大的排序：

  1. In [67]: systems
  2. Out[67]: ['CentOs', 'Windows', 'Ubuntu', 'IOS', 'Android', 'IOS', 'Windows', 'IOS']
  3.  
  4. In [68]: systems.sort()   # 使用sort()方法，从小到大排序
  5.  
  6. In [69]: systems
  7. Out[69]: ['Android', 'CentOs', 'IOS', 'IOS', 'IOS', 'Ubuntu', 'Windows', 'Windows']

逆排序：按照ASC码进行从大到小的排序：

  1. In [69]: systems
  2. Out[69]: ['Android', 'CentOs', 'IOS', 'IOS', 'IOS', 'Ubuntu', 'Windows', 'Windows']
  3.  
  4. In [70]: systems.reverse()   #使用reverse()方法，从大到小排序
  5.  
  6. In [71]: systems
  7. Out[71]: ['Windows', 'Windows', 'Ubuntu', 'IOS', 'IOS', 'IOS', 'CentOs', 'Android']

注意：Python3中，列表例的数据类型一致才可以排序，否则会报错

9.列表拷贝

关于列表的拷贝，有好多种方法，每一种方法都有差别，一起来看下：

方法1： b = a   # a是一个列表 

  1. In [87]: a = [1,2,3]
  2.  
  3. In [88]: b = a         # 把a拷贝给b
  4.  
  5. In [89]: id(a)         # 可以看到a和b的地址相同，指向同一块地址
  6. Out[89]: 2762625492040
  7.  
  8. In [90]: id(b)
  9. Out[90]: 2762625492040
  10.  
  11. In [91]: a.append(5)   # 列表a追加元素
  12.  
  13. In [92]: a
  14. Out[92]: [1, 2, 3, 5]
  15.  
  16. In [93]: b             # 列表b也改变了，还记得第五节在讲变量时化的那个图吗？
  17. Out[93]: [1, 2, 3, 5]

方法二： b = a[:] 

  1. In [94]: a = [1,2,3]
  2.  
  3. In [95]: b = a[:]   # 把a列表拷贝给b
  4.  
  5. In [96]: a.append(5)
  6.  
  7. In [97]: a
  8. Out[97]: [1, 2, 3, 5]
  9.  
  10. In [98]: b          # 可以看到，b并没有跟着改变
  11. Out[98]: [1, 2, 3]
  12.  
  13. In [99]: id(a)      # 说明a和b指向不同的地址
  14. Out[99]: 2762624748936
  15.  
  16. In [100]: id(b)
  17. Out[100]: 2762626722504

但是~~

  1. In [107]: a = [1,2,[3]]        # a列表里面包含了一个新的列表
  2.  
  3. In [108]: b = a[:]
  4.  
  5. In [109]: a[-1].append(5)      # 子列表追缴一个新的元素
  6.  
  7. In [110]: a.append(6)          # a列表追加一个新的元素
  8.  
  9. In [111]: a
  10. Out[111]: [1, 2, [3, 5], 6]    # a变成了这样
  11.  
  12. In [112]: b                    # 但是b的子列表却跟着改变了，见鬼了！
  13. Out[112]: [1, 2, [3, 5]]
  14.  
  15. In [113]: id(a)                # a和b指向的地址并不一样
  16. Out[113]: 2762626869896
  17.  
  18. In [114]: id(b)
  19. Out[114]: 2762602977160

虽然b = a[:] 这种方式可以拷贝出一个新的列表，但是当列表中包含子列表的时候，拷贝出来的新列表中的子列表会跟着改变╮(╯▽╰)╭，应用的时候一定要注意呐

方式三： b = list(a)  

  1. In [115]: a = [1,2,3]
  2.  
  3. In [116]: b = list(a)
  4.  
  5. In [117]: a.append(5)
  6.  
  7. In [118]: a
  8. Out[118]: [1, 2, 3, 5]
  9.  
  10. In [119]: b
  11. Out[119]: [1, 2, 3]
  12.  
  13. In [120]: a = [1,2,[3]]
  14.  
  15. In [121]: b = list(a)
  16.  
  17. In [122]: a[-1].append(5)
  18.  
  19. In [123]: a.append(6)
  20.  
  21. In [124]: a
  22. Out[124]: [1, 2, [3, 5], 6]
  23.  
  24. In [125]: b
  25. Out[125]: [1, 2, [3, 5]]
  26.  
  27. In [126]: id(a)
  28. Out[126]: 2762627298696
  29.  
  30. In [127]: id(b)
  31. Out[127]: 2762627301000

可以看到与方法二大同小异=====(￣▽￣*)b

方法四： b = a * 1   # a为列表 

  1. In [128]: a = [1,2,3]
  2.  
  3. In [129]: b = a * 1
  4.  
  5. In [130]: a.append(5)
  6.  
  7. In [131]: a
  8. Out[131]: [1, 2, 3, 5]
  9.  
  10. In [132]: b
  11. Out[132]: [1, 2, 3]
  12.  
  13. In [133]: a = [1,2,[3]]
  14.  
  15. In [134]: b = a * 1
  16.  
  17. In [135]: a[-1].append(5)
  18.  
  19. In [136]: a.append(6)
  20.  
  21. In [137]: a
  22. Out[137]: [1, 2, [3, 5], 6]
  23.  
  24. In [138]: b
  25. Out[138]: [1, 2, [3, 5]]
  26.  
  27. In [139]: id(a)
  28. Out[139]: 2762627326280
  29.  
  30. In [140]: id(b)
  31. Out[140]: 2762627611016

可以看到，与方法二、方法三大同小异,,ԾㅂԾ,,

方法五： b = a.copy()    # a是列表 

  1. In [170]: a = [1,2,3]
  2.  
  3. In [171]: b = a.copy()
  4.  
  5. In [172]: a.append(5)
  6.  
  7. In [173]: a
  8. Out[173]: [1, 2, 3, 5]
  9.  
  10. In [174]: b
  11. Out[174]: [1, 2, 3]
  12.  
  13. In [175]: a = [1,2,[3]]
  14.  
  15. In [176]: b = a.copy()
  16.  
  17. In [177]: a[-1].append(5)
  18.  
  19. In [178]: a.append(6)
  20.  
  21. In [179]: a
  22. Out[179]: [1, 2, [3, 5], 6]
  23.  
  24. In [180]: b
  25. Out[180]: [1, 2, [3, 5]]
  26.  
  27. In [181]: id(a)
  28. Out[181]: 2762628171912
  29.  
  30. In [182]: id(b)
  31. Out[182]: 2762628181320

可以看到，与方法二、方法三、方法四大同小异(ˉ▽ˉ；)...

方法六： b = copy.copy(a)    # a为列表 

  1. In [141]: import copy     # 需要导入 copy 模块
  2.  
  3. In [142]: a = [1,2,3]
  4.  
  5. In [143]: b = copy.copy(a)
  6.  
  7. In [144]: a.append(5)
  8.  
  9. In [145]: a
  10. Out[145]: [1, 2, 3, 5]
  11.  
  12. In [146]: b
  13. Out[146]: [1, 2, 3]
  14.  
  15. In [147]: a = [1,2,[3]]
  16.  
  17. In [148]: b = copy.copy(a)
  18.  
  19. In [149]: a[-1].append(5)
  20.  
  21. In [150]: a.append(6)
  22.  
  23. In [151]: a
  24. Out[151]: [1, 2, [3, 5], 6]
  25.  
  26. In [152]: b
  27. Out[152]: [1, 2, [3, 5]]
  28.  
  29. In [153]: id(a)
  30. Out[153]: 2762602926984
  31.  
  32. In [154]: id(b)
  33. Out[154]: 2762627609608

可以看到，与方法二、方法三、方法四、方法五大同小异(ˉ▽ˉ；)...

方法七： b = copy.deepcopy(a)    # a为列表 

  1. In [155]: import copy
  2.  
  3. In [156]: a = [1,2,3]
  4.  
  5. In [157]: b = copy.deepcopy(a)
  6.  
  7. In [158]: a.append(5)
  8.  
  9. In [159]: a
  10. Out[159]: [1, 2, 3, 5]
  11.  
  12. In [160]: b
  13. Out[160]: [1, 2, 3]
  14.  
  15. In [161]: a = [1,2,[3]]
  16.  
  17. In [162]: b = copy.deepcopy(a)
  18.  
  19. In [163]: a[-1].append(5)
  20.  
  21. In [164]: a.append(6)
  22.  
  23. In [165]: a
  24. Out[165]: [1, 2, [3, 5], 6]
  25.  
  26. In [166]: b                 # 这次b终于没有被改变
  27. Out[166]: [1, 2, [3]]
  28.  
  29. In [167]: id(a)
  30. Out[167]: 2762627600712
  31.  
  32. In [168]: id(b)
  33. Out[168]: 2762625604936

哇~~这一次b列表终于没有跟着改变ヾ(≧▽≦*)o

从以上七种方法可以看到，方法一最不推荐使用，方法二、方法三、方法四、方法五、方法六大同小异，都是复制列表后得到一个新的列表，但是一点列表中含有子列表，复制过来的列表中的子列表还是会跟着改变，方法七才会真正的做到完全复制且不是任何影响。

来一个列表的总结：

  1. a.append(x)              # 列表a追加元素x
  2. a.clear()                # 将列表a清空
  3. a.copy()                 # 拷贝列表a
  4. a.count(x)               # 对a列表的元素x计数
  5. a.extend(b)              # 把b列表扩展到a列表中
  6. a.index(x)               # 查询a列表中x元素的索引
  7. a.insert(n,x)            # 在列表a的第n个位置处插入元素x
  8. a.pop()                  # 将列表a的末尾元素删除，并返回这个元素
  9. a.remove(x)              # 将列表a的元素x删除
  10. a.reverse()              # 按ASC码进行从大到小的排序
  11. a.sort()                 # 按ASC码进行从小到大的排序

二、元组

元组与列表相似，只不过元组不能修改其内部元素。列表使用方括号，而元组使用圆括号。

  1. In [193]: dir(tuple)
  2. Out[193]:
  3. ['__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 方法

1.初始化元组

与列表类似，用一对圆括号括起来，元素之间用逗号分隔开,需要注意的是元组最后一定要加逗号：

  1. In [184]: systems = ('Linux', 'Windows', 'Unix',)
  2.  
  3. In [185]: systems = ('Linux', 'Windows', 'Unix', 666,)
  4.  
  5. In [186]: systems = ('Linux', 'Windows', 'Unix', 666, [1, 3,5],)
  6.  
  7. In [187]: systems = ('Linux', 'Windows', 'Unix', 666, [1, 3,5], (2,4,6),)
  8.  
  9. In [188]: systems = ('Linux', 'Windows', 'Unix', 666, [1, 3,5], (2,4,6), {'a':250},)
  10.  
  11. # 与列表极为相似

2.元组索引

同列表一样

  1. In [189]: systems = ('Linux', 'Windows', 'Unix',)   
  2.  
  3. In [190]: systems[1]
  4. Out[190]: 'Windows'

3.元组切片

同列表一样

  1. In [191]: systems = ('Linux', 'Windows', 'Unix',)
  2.  
  3. In [192]: systems[2:]
  4. Out[192]: ('Unix',)

4.元组组合

同列表一样

  1. In [194]: systems
  2. Out[194]: ('Linux', 'Windows', 'Unix',)
  3.  
  4. In [197]: systems1 = ('IOS',)
  5.  
  6. In [198]: systems + systems1
  7. Out[198]: ('Linux', 'Windows', 'Unix', 'IOS',)
  8.  
  9. In [200]: systems * 3
  10. Out[200]:
  11. ('Linux', 'Windows', 'Unix', 'Linux', 'Windows', 'Unix', 'Linux', 'Windows', 'Unix',)

5.元组统计

同列表一样

  1. In [202]: systems = ('Linux', 'Windows', 'Unix',)
  2.  
  3. In [203]: systems.count('Linux')
  4. Out[203]: 1

In [204]: len(systems)
  Out[204]: 3

元组就这么多o_o ....

#9 Python列表和元组的更多相关文章

  1. Python列表、元组、字典和字符串的常用函数

    Python列表.元组.字典和字符串的常用函数 一.列表方法 1.ls.extend(object) 向列表ls中插入object中的每个元素,object可以是字符串,元组和列表(字符串“abc”中 ...

  2. python列表与元组的用法

    python列表与元组的用法 目录: 列表的用法: 1.增   append   +    extend 2.删  del    remove 3.改   insert 4.查  index 5.反向 ...

  3. (转)python 列表与元组的操作简介

    python 列表与元组的操作简介 原文:https://www.cnblogs.com/QG-whz/p/4782809.html 阅读目录 列表 list函数 列表的基本操作 列表方法 元组 tu ...

  4. Python列表和元组

    Python是没有数组的概念,但是和数组比较相近的概念是列表和元素. 下面两个例子展示列表和元组. # coding=utf-8 # 元组 students = ('小明', '小黄', '小李', ...

  5. 认识Python 列表和元组

    列表用方括号   l=[['xyz',123], 'abc', 3140000000.0, (23+1.3j), 'ddd'] 元组用圆括号   t=(['xyz', 123],'abc', 3140 ...

  6. Python: 列表，元组，字典的区别

    Python中有3种内建的数据结构:列表,元组和字典 1.列表 list是处理一组有序项目的数据结构,即可以在一个列表中存储一个序列的项目.列表中项目应该包括在方括号中,这样python就知道是在指明 ...

  7. [python01] python列表，元组对比Erlang的区别总结

    数据结构是通过某种方式组织在一起的数据元素的集合,这些数据元素可以是数字,字符,甚至可以是其他的数据结构. python最基本的数据结构是sequence(序列):6种内建的序列:列表,元组,字符串, ...

  8. python 列表，元组，字符串方法和属性

    python序列包含列表[].元组().字符串三种 -------列表-------------- 一.列表基本内容 1.建立:a=[1,2,3,5],通过[ , ,], >>>b= ...

  9. Python 列表、元组、字典及集合操作详解

    一.列表 列表是Python中最基本的数据结构,是最常用的Python数据类型,列表的数据项不需要具有相同的类型 列表是一种有序的集合,可以随时添加和删除其中的元素 列表的索引从0开始 1.创建列表 ...

随机推荐

  1. 查看class实际执行的类路径

    查看class真实归属的jar包位置getClass().getClassLoader().getResource(getClass().getName().replace('.', '/') + & ...

  2. @WebFilter怎么控制多个filter的执行顺序

    转自:http://blog.csdn.net/liming_0820/article/details/53332070 之前我们控制多个filter的执行顺序是通过web.xml中控制filter的 ...

  3. 用scp这个命令来通过ssh传输文件

    小结: 1. upload files 到 ssh 服务器 localhost $ scp localfile root@172.20.34.**:~/remotepath 2. 从 ssh 服务器d ...

  4. iOS安装包瘦身的那些事儿

    在我们提交安装包到App Store的时候,如果安装包过大,有可能会收到类似如下内容的一封邮件: 收到这封邮件的时候,意味着安装包在App Store上下载的时候,有的设备下载的安装包大小会超过100 ...

  5. WPF 依赖属性&附加属性

    依赖属性 暂无 附加属性 1.在没有控件源码的前提下增加控件的属性 2.多个控件需要用到同一种属性 使用附加属性可以减少代码量,不必为每一个控件都增加依赖属性 3.属性不确定是否需要使用 在某些上下文 ...

  6. Linux程序设计：进程通信

      日期:忘了. 关键词:Linux程序设计:System-V:进程通信:共享内存:消息队列. 一.共享内存   1.1 基本知识 (待补充)   1.2 代码 一个基于share memory实现的 ...

  7. 从零开始的程序逆向之路 第一章——认识OD(Ollydbg)以及常用汇编扫盲

    作者:Crazyman_Army 原文来自:https://bbs.ichunqiu.com/thread-43041-1-1.html 0×00 序言: 1.自从上次笔者调戏完盗取文件密码大黑客后, ...

  8. java 手动实现远程执行功能（深入理解java虚拟机）

     1.功能类 功能类共有五,分别是: package org.jvm; import java.io.*; /** * 对字节数组操作的工具类 */ public class ByteUtils { ...

  9. Android精通教程-第一节Android入门简介

    前言 大家好,给大家带来Android精通教程-第一节Android入门简介的概述,希望你们喜欢 每日一句 If life were predictable it would cease to be ...

  10. Zabbix--1

    ZABBIX 与其他监控程序比较.