列表和元组

1. 数据结构：
   

   数据结构：通过某种方式将数据元素组织在一起，这个数据元素集合称为数据结构。 

   序列：最基本的数据结构。【0，1，2，···，n-1】或者【-n，···，-3，-2，-1】

   列表、···、xrange对象：Python的6种内建序列。

2. 通用序列操作：
   包括：索引、分片、加、乘、成员资格、长度、最小值、最大值。

   • 序列：

     >>>edward = ['Edward Gumby', 42]
     >>>john = ['John Smith', 40]
     >>>database = [edward, john]
     >>>database
     [['Edward Gumby', 42], ['John Smith', 40]]
     

   • 索引：

     >>>edward[0]
     'Edward Gumby'
     >>>edward[0][0]
     'E'
     >>>edward[0][-1]
     'y'
     

   • 分片：

     >>>numbers = [1, 2, 3, 4, 5]
     # 1:默认步长
     >>>numbers[0]
     1
     >>>numbers[0:1]
     [1]
     >>>numbers[4:5]# 虽然索引5元素不存在，但是列表的边界
     [5]
     >>>numbers[-3:]
     [3, 4, 5]
     >>>numbers[:3]
     [1, 2, 3]
     >>>numbers[:]
     [1, 2, 3, 4, 5]
     # 2：设置步长,注：步长为整数，从左往右，步长为负数，从右往左；开始点元素在结果内，结束点不在；步长为负数时，开始点大于结束点
     >>>numbers[::1]
     [1, 2, 3, 4, 5]
     >>>numbers[::2]
     [1,3,5]
     >>>numbers[4:2:-2]
     [5]

   • 相加：
     只有类型相同的序列才可以相加。

     >>>[1, 2, 3] + [4, 5, 6]
     [1, 2, 3, 4, 5, 6]
     >>>[1, 2, 3] + 'Hello'
     Error

   • 乘法：

     >>>'python' * 5
     'pythonpythonpythonpythonpython'
     # None 是空值，无
     >>>[None] * 5
     [None, None, None, None, None]
     >>>len([None]*5)
     5
     >>>len([]*5)
     0

   • 成员资格：

     >>>numbers = [1, 2, 3, 4, 5]
     >>>[5] in numbers
     False
     >>>5 in numbers
     True 

   • 长度、最大值、最小值：

     >>>numbers = [100， 34， 678]
     >>>len(numbers)
     3
     >>>max(numbers)
     678 
     >>>min(numbers)
     34
     

3. 列表：
   列表可变。

   • list函数：

     # 将字符串转为列表
     >>> somelist = list('Hello')
     >>> somelist
     ['H', 'e', 'l', 'l', 'o']
     # 将列表转为字符串
     >>> str.join(somelist)
     Error
     >>> ''.join(somelist)
     'Hello'
     >>> str=''.join(somelist)
     >>> str
     'Hello'
     >>> str=''
     >>> str
     ''
     >>> str.join(somelist)
     'Hello'
     

     注：list()函数适用于所有类型的序列。

   • 基本的列表操作：
      索引、分片、相加、乘法 + 元素赋值（不能为一个位置不存在的元素赋值）、元素删除、分片删除

     >>> x=[1,1,3]
     # 元素赋值
     >>> x[1]=2
     >>> x
     [1, 2, 3]
     # 元素删除
     >>> del x[1]
     >>> x
     [1, 3]
     # 连续分片赋值，序列长度可以不一致
     >>> x[1:4]=[2,3,4,5]
     >>> x
     [1, 2, 3, 4, 5]
     >>> x[5:5]=[1,2,3,4,5]# 在最后一个列表后赋值
     >>> x
     [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
     >>> x[5:10]=[]# 删除元素
     >>> x
     [1, 2, 3, 4, 5]
     # 不连续分片赋值，序列长度必须一致
     >>> x=[1,2,3,4,5,6,7,8,9,10]
     >>> x[9:5:-2]
     [10, 8]
     >>> x[9:5:-2]=[0]
     ValueError: attempt to assign sequence of size 1 to extended slice of size 2
     >>> x[9:5:-2]=[0,0]
     >>> x
     [1, 2, 3, 4, 5, 6, 7, 0, 9, 0]
     # 元素赋值与分片赋值
     >>> x=[]
     >>> x[0]=1
     Error
     >>> x[0:0]=[1]
     >>> x
     [1]

   • 列表方法：
     append()：在列表末尾追加新的对象。它不是简单地返回一个修改过的新列表，而是直接修改原来的列表。

     >>> x=[1,2,3]
     >>> x.append(4)
     >>> x
     [1, 2, 3, 4]

     count()：统计某个元素在列表中出现的次数。

     >>> x=[[1,2],1,1,[2,1,[1,2]]]
     >>> x.count(1)
     2
     >>> x.count([1,2])
     1
     

     extend()：在列表的末尾一次性追加另一个序列中的多个值。

     >>> a=[1,2,3]
     >>> b=[4,5,6]
     >>> a+b
     [1, 2, 3, 4, 5, 6]
     >>> a
     [1, 2, 3]
     >>> a.extend(b)
     >>> a
     [1, 2, 3, 4, 5, 6]

     index()：从列表中找出某个值第一个匹配项的索引位置。

     >>> lst=['a','b','c','d','e']
     >>> lst.index('b')
     1
     >>> lst[1]
     'b'
     >>> a.index(1)
     ValueError: 1 is not in list

     insert()：将对象插入列表中。

     >>> num=[1,2,3,5]
     >>> num.insert(3,"four")
     >>> num
     [1, 2, 3, 'four', 5]
     # 之前的分片赋值也实现了此功能，但可读性没有insert()好。

     pop()：移除列表中的一个元素，并返回该元素的值。

     >>> x=[1,2,3,4,5]
     >>> x.pop()
     5
     >>> x
     [1, 2, 3, 4]
     >>> x.pop(0)
     1
     >>> x
     [2, 3, 4]
     >>> x.append(x.pop())
     >>> x
     [2, 3, 4]

     remove()：移除列表中某个值的第一个匹配项（注意没有返回值，与pop()相反）。

     >>> x=["to","be","or","not","to","be"]
     >>> x.remove("be")
     >>> x
     ['to', 'or', 'not', 'to', 'be']
     >>> x.remove("bee")
     ValueError: list.remove(x): x not in list

     reserve()：将列表中的元素反向存放。

     >>> x=[1,2,3]
     >>> x.reverse()
     >>> x
     [3, 2, 1]
     ##reversed()函数反向迭代序列。
     >>> x=[1,2,3]
     >>> list(x.reversed())
     [3,2,1]

     sort()：在原位置对列表进行排序，就是原序列改变。

     >>> x=[4,6,2,1,7,4]
     >>> x.sort()
     >>> x
     [,1,2,4,6,7,9]
     #当需要保留原有序列不变，获取排好序的列表副本时
     #错误做法1
     >>> x=[4,6,2,1,7,4]
     >>> y=x.sort()#因为函数返回空值
     >>> y
     None
     >>> x
     [1,2,4,6,7,9]
     #错误做法2
     >>> x=[4,6,2,1,7,4]
     >>> y=x#让x，y指向同一列表
     >>> y.sort()
     >>> y
     [1,2,4,6,7,9]
     >>> x
     [1,2,4,6,7,9]
     #正确做法1
     >>> x=[4,6,2,1,7,4]
     >>> y=x[:]
     >>> y.sort()
     >>> y
     [1,2,4,6,7,9]
     >>> x
     [4,6,2,1,7,4]
     #正确做法2
     >>> x=[4,6,2,1,7,4]
     >>> y=sorted(x)
     >>> y
     [1,2,4,6,7,9]
     >>> x
     [4,6,2,1,7,4]

     高级排序：

     list.sort(cmp=None，key=None，reverse=False)
     cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
     key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
     reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
     详解：https://segmentfault.com/q/1010000000405289
4. 元组：
   元组不可变。逗号很重要！

   • tuple函数：

     >>>tuble([1,2,3])
     (1,2,3)
     >>>tuble('abc')
     ('a','b','c')
     >>>tuble((1,2,3))
     (1,2,3)

   • 基本的元组操作：创建、访问
   • 元组方法：无