有容乃大的list(2)

对list的操作

list的长度

还记得str的长度怎么获得吗？其长度是什么含呢？那种方法能不能用在list上面呢？效果如何？

做实验：

  1. >>> name = 'qiwsir'
  2. >>> type(name)
  3. <type 'str'>
  4. >>> len(name)
  5. 6
  6. >>> lname = ['sir','qi']
  7. >>> type(lname)
  8. <type 'list'>
  9. >>> len(lname)
  10. 2
  11. >>> length = len(lname)
  12. >>> length
  13. 2
  14. >>> type(length)
  15. <type 'int'>

实验结论：

  • len(x)，对于list一样适用
  • 得到的是list中元素个数
  • 返回值是int类型

合并list

《有容乃大的list(1)》中，对list的操作提到了list.append(x)，也就是将某个元素x 追加到已知的一个list后边。

除了将元素追加到list中，还能够将两个list合并，或者说将一个list追加到另外一个list中。按照前文的惯例，还是首先看官方文档中的描述：

list.extend(L)

Extend the list by appending all the items in the given list; equivalent to a[len(a):] = L.

向所有正在学习本内容的朋友提供一个成为优秀程序员的必备：看官方文档，是必须的。

官方文档的这句话翻译过来：

通过将所有元素追加到已知list来扩充它，相当于a[len(a)]= L

英语太烂，翻译太差。直接看例子，更明白

  1. >>> la
  2. [1, 2, 3]
  3. >>> lb
  4. ['qiwsir', 'python']
  5. >>> la.extend(lb)
  6. >>> la
  7. [1, 2, 3, 'qiwsir', 'python']
  8. >>> lb
  9. ['qiwsir', 'python']

上面的例子，显示了如何将两个list，一个是la，另外一个lb，将lb追加到la的后面，也就是把lb中的所有元素加入到la中，即让la扩容。

学程序一定要有好奇心，我在交互环境中，经常实验一下自己的想法，有时候是比较愚蠢的想法。

  1. >>> la = [1,2,3]
  2. >>> b = "abc"
  3. >>> la.extend(b)
  4. >>> la
  5. [1, 2, 3, 'a', 'b', 'c']
  6. >>> c = 5
  7. >>> la.extend(c)
  8. Traceback (most recent call last):
  9.   File "<stdin>", line 1, in <module>
  10.   TypeError: 'int' object is not iterable

从上面的实验中，看官能够有什么心得？原来，如果extend(str)的时候，str被以字符为单位拆开，然后追加到la里面。

如果extend的对象是数值型，则报错。

所以，extend的对象是一个list，如果是str，则python会先把它按照字符为单位转化为list再追加到已知list。

不过，别忘记了前面官方文档的后半句话，它的意思是：

  1. >>> la
  2. [1, 2, 3, 'a', 'b', 'c']
  3. >>> lb
  4. ['qiwsir', 'python']
  5. >>> la[len(la):]=lb
  6. >>> la
  7. [1, 2, 3, 'a', 'b', 'c', 'qiwsir', 'python']

list.extend(L) 等效于 list[len(list):] = L，L是待并入的list

联想到到上一讲中的一个list函数list.append(),这里的extend函数也是将另外的元素（只不过这个元素是列表）增加到一个已知列表中，那么两者有什么不一样呢？看下面例子：

  1. >>> lst = [1,2,3]
  2. >>> lst.append(["qiwsir","github"])
  3. >>> lst
  4. [1, 2, 3, ['qiwsir', 'github']]  #append的结果
  5. >>> len(lst)
  6. 4
  8. >>> lst2 = [1,2,3]
  9. >>> lst2.extend(["qiwsir","github"])
  10. >>> lst2
  11. [1, 2, 3, 'qiwsir', 'github']   #extend的结果
  12. >>> len(lst2)
  13. 5

append是整建制地追加，extend是个体化扩编。

list中某元素的个数

上面的len(L)，可得到list的长度，也就是list中有多少个元素。python的list还有一个操作，就是数一数某个元素在该list中出现多少次，也就是某个元素有多少个。官方文档是这么说的：

list.count(x)

Return the number of times x appears in the list.

一定要不断实验，才能理解文档中精炼的表达。

  1. >>> la = [1,2,1,1,3]
  2. >>> la.count(1)
  3. 3
  4. >>> la.append('a')
  5. >>> la.append('a')
  6. >>> la
  7. [1, 2, 1, 1, 3, 'a', 'a']
  8. >>> la.count('a')
  9. 2
  10. >>> la.count(2)
  11. 1
  12. >>> la.count(5)     #NOTE:la中没有5,但是如果用这种方法找，不报错，返回的是数字0
  13. 0

元素在list中的位置

《有容乃大的list(1)》中已经提到，可以将list中的元素，从左向右依次从0开始编号，建立索引（如果从右向左，就从-1开始依次编号），通过索引能够提取出某个元素，或者某几个元素。就是如这样做：

  1. >>> la
  2. [1, 2, 3, 'a', 'b', 'c', 'qiwsir', 'python']
  3. >>> la[2]
  4. 3
  5. >>> la[2:5]
  6. [3, 'a', 'b']
  7. >>> la[:7]
  8. [1, 2, 3, 'a', 'b', 'c', 'qiwsir']

如果考虑反过来的情况，能不能通过某个元素，找到它在list中的编号呢？

看官的需要就是python的方向，你想到，python就做到。

  1. >>> la
  2. [1, 2, 3, 'a', 'b', 'c', 'qiwsir', 'python']
  3. >>> la.index(3)
  4. 2
  5. >>> la.index('a')
  6. 3
  7. >>> la.index(1)
  8. 0
  9. >>> la.index('qi')      #如果不存在，就报错
  10. Traceback (most recent call last):
  11.   File "<stdin>", line 1, in <module>
  12.   ValueError: 'qi' is not in list
  13. >>> la.index('qiwsir')
  14. 6

list.index(x)，x是list中的一个元素，这样就能够检索到该元素在list中的位置了。这才是真正的索引，注意那个英文单词index。

依然是上一条官方解释：

list.index(x)

Return the index in the list of the first item whose value is x. It is an error if there is no such item.

是不是说的非常清楚明白了？

先到这里，下讲还继续有容乃大的list.

首页   |   上一讲   |   下一讲