列表和元组的內建方法的使用

• 列表的內建方法

  • cmp()--->进行序列比较
    • 如果比较的元素是同类型的，则比较其值，返回结果-1或者1
    • 如果两个元素不是同一类型的，则检查他们是否是数字
      • 如果是数字，执行必要的数字强制类型转换，然后比较
      • 如果有一方的元素是数字，则另一方的元素"大"(数字是最小的)
      • 否则，通过类型名字的字母顺序进行比较
    • 如果有一个列表首先到达末尾，另一个长一点的列表大
    • 如果列表长度相同且所有元素按顺序都是相等的，那么两个序列就是相等的返回一个0
    • cmp()函数进行比较的时候，是按照顺序比较的
      • 因数字的值小，所以数字在前的元素的值永远是最小的

  In [202]: list1 = ["abc","def",123]
  In [203]: list2 = ["abc",123,"def"]
  In [204]: cmp(list1, list2)
  Out[204]: 1
  In [205]: list2 = [123,"def","sum"]
  In [206]: list3 = ["def",123,"sum"]
  In [207]: cmp(list2, list3)
  Out[207]: -1
  

  In [209]: list1 = [1,2,3,4,5]
  In [210]: list2 = [1,2,3,4,5,6,7]
  In [211]: cmp(list1, list2)
  Out[211]: -1
  In [212]: list1 = ['a','b','c']
  In [213]: list2 = ['d','e','f']
  In [214]: cmp(list1, list2)
  Out[214]: -1
  In [215]: list1 = ['a','b',123]
  In [216]: list2 = ['d','e','f']
  In [217]: cmp(list1, list2)
  Out[217]: -1
  In [218]: list1 = ['a','b','c']
  In [219]: list2 = ['a','b','c']
  In [220]: cmp(list1, list2)
  Out[220]: 0
  

• 列表、元组、字符串中通用的方法

  • len()-->返回字符串的长度，就是字符串包含的字符个数；对于列表或者元组来说，它会返回列表或者元组的元素个数
  • max()和min()-->对于字符串操作，是获取字符串中最大和最小字符；对于列表和元组，或者列表和元组最大和最小的元素
  • enumerate()和zip()-->前者输出可迭代对象的index和元素值组成一个新的元组；后者等长的两个列表对应位的的元素组成一个元组，生成一个元组列表
  • sum()和reduce()-->对数字列表进行求和
  • list()与tuple()接受可迭代的对象作为参数，并通过浅拷贝数据来创建一个新的列表或元组
  • range()函数接受一个数值作为输入，输出一个符合标准的列表

  ---

• 列表类型內建函数列表

In [254]: list1 = ['a','b','c']
In [255]: len(list1)
Out[255]: 3
In [256]: max(list1)
Out[256]: 'c'
In [257]: min(list1)
Out[257]: 'a'

# enumerate     -->返回一个元组，由每个元素的下标index和item组成
In [133]: s = "foobar"
In [135]: for x, y in enumerate(s):
 ...:     print x, y
0 f
1 o
2 o
3 b
4 a
5 r

# zip           -->返回一个列表，由两个字符串按顺序组成的元组
In [138]: s = "foa"
In [139]: t = "obr"
In [140]: zip(s,t)
Out[140]: [('f', 'o'), ('o', 'b'), ('a', 'r')]

• 列表的一些操作方法

  In [1]: list1 = [1,2,'a','b',3,4]
  In [2]: list1.append(11)                        # 向列表中增添一个元素，默认添加到最后一位
  In [3]: list1
  Out[3]: [1, 2, 'a', 'b', 3, 4, 11]
  In [4]: list1.count(2)                          # 查看列表中这个obj对象出现的次数
  Out[4]: 1
  In [5]: m = ['c','d']
  In [6]: list1.extend(m)                         # 把一个列表添加到另一个列表中，默认添加到最后
  In [7]: list1
  Out[7]: [1, 2, 'a', 'b', 3, 4, 11, 'c', 'd']
  In [8]: list1.append(1)         、
  In [9]: list1
  Out[9]: [1, 2, 'a', 'b', 3, 4, 11, 'c', 'd', 1]
  In [11]: list1.index(1)                         # 查询列表中这个obj对象第一次出现的下标
  Out[11]: 0
  In [14]: list1.index('d')
  Out[14]: 8
  In [17]: list1.index(1,3,11)                    # 指定一个范围查询obj对象第一次出现的下标；
  Out[17]: 9
  In [18]: list1.insert(2,'f')                    # 在下标2中插入对象obj
  In [19]: list1
  Out[19]: [1, 2, 'f', 'a', 'b', 3, 4, 11, 'c', 'd', 1]
  In [20]: list1.pop()                            # 删除一个对象，默认是删除最后一个，返回这个对象值
  Out[20]: 1
  In [21]: list1
  Out[21]: [1, 2, 'f', 'a', 'b', 3, 4, 11, 'c', 'd']
  In [22]: list1.remove('a')                      # 从列表中移除一个obj对象
  In [23]: list1
  Out[23]: [1, 2, 'f', 'b', 3, 4, 11, 'c', 'd']
  In [24]: list1.reverse()                        # 列表的反序，修改原来的列表
  In [25]: list1
  Out[25]: ['d', 'c', 11, 4, 3, 'b', 'f', 2, 1]
  In [26]: list1.sort()                           # 列表的排序，修改原来列表
  In [27]: list1
  Out[27]: [1, 2, 3, 4, 11, 'b', 'c', 'd', 'f']
  
  

• 元组的一些操作方法

  • 元组是不可变的，所有没有像列表中排序、替换、添加等这些操作

• 元组中有的操作方法

  • cmp()---->两个序列进行比较
  • min()/max()---->得到元组中的最小值和最大值
  • len()---->得到元组的长度

  In [28]: tup = (1,2,3,4)
  In [29]: tup * 2
  Out[29]: (1, 2, 3, 4, 1, 2, 3, 4)
  In [30]: tup
  Out[30]: (1, 2, 3, 4)
  In [31]: max(tup)
  Out[31]: 4
  In [32]: min(tup)
  Out[32]: 1
  In [33]: 
  In [33]: len(tup)
  Out[33]: 4
  In [34]: tup1 = (1,2,3,4)
  In [35]: 
  In [35]: cmp(tup,tup1)
  Out[35]: 0
  
  

• 元组和列表没有自己专用的操作符和內建函数；有的只是一些常用的操作；