类型转换以及序列內建函数 len() enumerater() sorted() reversed() zip()的使用

• 类型转换

  • 序列类型转换工厂函数

  函数	含义
  list(iter)	把可迭代对象转换为列表
  str(obj)	把obj对象转换成字符串(对象的字符串表示法)
  unicode(obj)	把对象转换为Unicode字符串(使用默认编码)
  basestring	抽象工厂函数，其作用仅仅是为str和unicode函数提供父类，所以不能被实例化，也不能被调用
  tuple(iter)	把一个可迭代对象转换成一个元组对象

  In [96]: a = (1,2,3,4,5)
  In [97]: type(a)
  Out[97]: tuple
  In [98]: l = list(a)
  In [99]: l
  Out[99]: [1, 2, 3, 4, 5]
  In [100]: type(l)
  Out[100]: list
  In [101]: a = 1
  In [102]: a = str(a)
  In [103]: type(a)
  Out[103]: str
  In [104]: a = "中文"
  In [105]: type(a)
  Out[105]: str
  In [106]: a = a.decode("utf-8")
  In [107]: type(a)
  Out[107]: unicode
  In [109]: l
  Out[109]: [1, 2, 3, 4, 5]
  In [110]: t = tuple(l)
  In [111]: t
  Out[111]: (1, 2, 3, 4, 5)
  In [112]: type(t)
  Out[112]: tuple
  

• 序列內建函数的使用

  • 序列类型可用的內建函数
    • 序列类型函数支持列表、元组、字符串使用

  函数名称	功能
  enumerate(iter)	接受一个可迭代对象作为参数,返回一个enumerate对象(同时也是一个迭代器),该对象生成由iter每个元素的index值和item值组成的元组
  len(seq)	返回seq的长度
  max(iter)	返回iter中的最大值
  min(iter)	返回iter中的最小值
  reversed(seq)	接受一个序列作为参数，返回一个逆序访问的迭代器
  sorted(iter,fuc=None,key=None,reverse=False)	接受一个可迭代对象作为参数,返回一个有序的列表：可选参数fuc、key、reverse的含义list.sort()內建函数的参数含义一样
  sum(seq,init=0)	返回seq和可选参数init的总和,其效果等同于reduce(operator.add,seq,init)
  zip([it0,it1..itN])	返回一个列表，其第一个元素是it0、it1..这些元素的第一个元素组成的一个元组，第二个依次类推

  # len
  In [126]: str1 = "abc"
  In [127]: len(str1)
  Out[127]: 3
  
  # max min
  In [128]: str2 = "lmn"
  In [130]: str3 = "xyz"
  In [131]: max(str2)
  Out[131]: 'n'
  In [132]: min(str3)
  Out[132]: 'x'
  
  # 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')]
      
  # sorted        -->排序，不改变原来的列表，重新打印出一个新的列表
  In [153]: list4 = [5,3,4,6,2,1]
  In [154]: ll = sorted(list4)
  In [155]: print list4
  [5, 3, 4, 6, 2, 1]
  In [156]: print ll
  [1, 2, 3, 4, 5, 6]
   
  In [247]: list1 = [('a', 1), ('b', 2), ('c', 6), ('d', 4), ('e', 3)]
  In [248]: sorted(list1,key=lambda x:x[0])
  Out[248]: [('a', 1), ('b', 2), ('c', 6), ('d', 4), ('e', 3)]
  In [249]: sorted(list1,key=lambda x:x[0], reverse=True)
  Out[249]: [('e', 3), ('d', 4), ('c', 6), ('b', 2), ('a', 1)]
  
  # reversed      -->接受一个序列作为参数，返回一个逆向访问的迭代器
  In [180]: a = [1,2,3,4,5]
  In [181]: aa = reversed(a)
  In [182]: print aa
  <listreverseiterator object at 0x7f0307e4c650>
  In [183]: for i in aa:
       ...:     print i
  5
  4
  3
  2
  1
  

• sort、sorted、reverse、reversed的区别

  • reverse()和sort()的使用方式是一样的，无需参数，无返回值，二者均是列表的用法，调用后会改变原列表
  • reversed()和sorted()的调用方式相同，需要给出参数，参数可以是列表、元组、字符串，调用后不改变原对象