概要：

  1. 通用序列操作   （索引、分片、加、乘、迭代、成员资格）

  2. 列表的基本操作   (元素赋值、删除元素、分片赋值、列表方法）

  3. 列表方法：(append\count\extend\index\insert\pop\remove\reverse\sort\cmp)

    方法是一个与某些对象有紧密联系的函数。对象可能是列表、数字、字符串或者其他类型的对象。

    方法调用格式：对象.方法(参数)


数据结构是通过某种方式（例如对元素进行编号）组织在一起的数据元素的集合，这些数据元素可以是数字或者字符，甚至可以是其他数据结构。常见的数据结构有序列（sequence）和字典（dictionary）。


python中包含六种内建的序列：列表；元组；字符串；unicode字符串；buffer对象；xrange对象。


一、列表和元组

序列中的每个元素被分配一个序号（即元素的位置），也称索引。第一个索引是0，第二个是1，以此类推。也可以从最后一个元素开始计数（序列中的最后一个元素标记为-1，倒数第二个元素为-2，以此类推），好处：这样我们就可以从第一个元素向前或向后计数。

1、序列概览

列表和元组的区别：列表可以修改，元组不能修改。

在需要操作一组数值的时候，序列很好用。可以用序列表示数据库中一个人的信息：第一个元素是姓名，第二个元素是年龄。如下：（列表的各个元素通过逗号分割，写在方括号中）

>>> ls=['lisan',42]

>>> ls
['lisan', 42]

序列也可以包含其他的序列，因此构建如下的一个人员信息的列表也是可以的，这个列表就是数据库：

>>> ls=['lisan',42]
>>> zs=['zhangsi',50]
>>> database=[ls,zs]     //database列表中的元素为列表时，元素不需要加引号。
>>> database
[['lisan', 42], ['zhangsi', 50]]
>>>

>>> []        //空列表，里面什么东西都没有
[]
>>> 

>>> [None]    //空列表占位符（python的内建值（表示这里什么也没有）），None的书写一定要正确。
[None]
>>>

注意：python中还有一种名为容器（container）的数据结构。容器基本上是包含其他对象的任意对象。序列（例如列表和元组）和映射（例如字典）是两类主要的容器。序列中的每个元素都有自己的编号，映射中的每个元素都有一个名字（也称为键值）。既不是序列也不是映射的容器类型，集合（set）就是一个例子。


2、通用序列操作   （索引、分片、加、乘、迭代、成员资格）

所有序列类型都可以进行某些特定的操作。这些操作包括：索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）、迭代（iteration）（迭代的意思是依次对序列中的每个元素重复执行某些操作）、检查某个元素是否属于序列的成员（成员资格）。除此之外，python还有计算序列长度、找出最大元素、最小元素的内建函数。


a）、索引

    格式：sequence[索引值]

简单来说索引就是通过元素编号取序列中的元素值。

序列中的元素都是有编号的（从0开始递增），这些元素可以通过编号分别访问：

如：

>>> greeting='hello'    //字符串就是一个由字符组成的序列。
>>> greeting[0]
'h'
>>> greeting[1]
'e'
>>> greeting[3]
'l'
>>> greeting[-1]
'o'
>>>

通过索引编号可以方便获取序列中的元素值。

注意：字符串字面值（就此而言，其他序列字面值也可以）能够直接使用索引，而不需要一个变量引用他们。两种做法是一样样的：

如：

>>> 'hello'[1]
'e'
>>> 'hello'[-1]
'o'
>>> ['lisi',32,'zhangsan',33][1]
32
>>> ['lisi',32,'zhangsan',33][0]
'lisi'
>>> ['lisi',32,'zhangsan',33][-1]
33
>>>


函数调用返回序列，可以直接对返回结果进行索引操作。

如：你只对用户输入的年份的第4个数字感兴趣，可以进行如下操作：

>>> fourth=input('year:')[3]         //python3中
year:2016
>>> fourth
'6'
>>>

>>> fourth=input('year:')[3]        //python2中，可以用raw_input函数替代
year:'2016'
>>> fourth
'6'
>>>

>>> fourth=raw_input ('year:')[3]        //python2中
year:2016
>>> fourth
'6'
>>>


b）、分片

    格式：sequence[分片起始值:分片结束值:步长]   //包含分片起始值，不包含分片结束值；通常情况下步长默认为1，可以根据需要对步长进行更改，步长大于1时，会跳过某些元素值。


分片就是取序列中的一段元素值。

如：

>>> tag="i love u u love u "
>>>
>>> tag[0:-1]        //不包含最后一个空格
'i love u u love u'
>>> tag[0:]            //包含最后一个空格
'i love u u love u '
>>> tag[:]            //包含最后一个空格 ,复制整个序列。
'i love u u love u '

>>> tag[:1]        
'i'
>>>

>>> tag[1:6]
' love'
>>> tag[2:6]
'love'
>>> tag[-3:-1]
' u'
>>> tag[-4:-1]
'e u'
>>>
>>> tag[-4:0]       //这样写的话会输出一个空序列，只要分片左边的索引比它右边的索引晚出现在序列                                    中，结果就是一个空序列。
''
>>>

>>> tag="i love u u love u "[1:5]        //分片也支持赋值的字面取值
>>> tag
' lov'
>>>
>>> "i love u u love u "[1:5]           //分片也支持字面取值

' lov'
>>>


>>> tag="i love u u love u "
>>> tag
'i love u u love u '
>>> tag[1:6:2]            //步长更改为2
' oe'
>>> tag[0:6:2]
'ilv'
>>> tag[0::2]            //不包含最后一个元素值，步长为2
'ilv   oeu'
>>> tag[::2]            //遍历整个序列元素，步长为2
'ilv   oeu'
>>> tag[::3]            //步长更改为3
'io uo '
>>>
>>> tag[::0]            //步长不能为0，否则会报错，因为0的话，不会执行。
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: slice step cannot be zero
>>>

>>> tag[::-1]        //步长可以为负数，即从右向左提取元素值。
' u evol u u evol i'
>>> tag[::-2]
'  vluueo '
>>>
>>> tag[0:-1]
'i love u u love u'
>>> tag[0:-1:2]
'ilv   oeu'
>>> tag[0:-1:-1]
''
>>>


c）、序列相加

    格式：sequence+sequence

通过使用加号（+）可以进行序列的连接操作：

注意：序列的相加需要相同类型的序列才可以操作。

如：

>>> [1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]
>>> a=[1,2,3]
>>> b=[4,5,6]
>>> a+b
[1, 2, 3, 4, 5, 6]
>>> "hello"+'world'
'helloworld'
>>> c='hello'
>>> d='world'
>>> c+d
'helloworld'
>>>
>>> [1,2,3]+'hello'            // 不同类型的序列不能相加，否则会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "str") to list
>>>


d）、乘法

    格式：sequence*数字

用数字x乘以一个序列会生成新的序列，而在新的序列中，原来的序列将被重复x次。

>>> 'hello'*5
'hellohellohellohellohello'
>>> ['he','llo']*5
['he', 'llo', 'he', 'llo', 'he', 'llo', 'he', 'llo', 'he', 'llo']
>>> [1,2]*5
[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
>>>

>>> [None]*10        //初始化一个空序列为10的列表。
[None, None, None, None, None, None, None, None, None, None]

e）、成员资格

    格式：元素值 in sequence

成员资格是验证一个元素值是否在序列中，它是一个逻辑运算（布尔运算），如果元素在序列中就返回true，否则返回false。

如：

>>> 'i' in "i love u"
True
>>> a='ilovu'
>>> 'i' in a
True
>>> 'p' in a
False

>>> jg=input() in a
i
>>> jg
True
>>>

>>>
>>> 12 in [12,23,34,45]
True
>>> 120 in [12,23,34,45]
False
>>>


f）、长度、最小值、最大值

    格式：内建函数len、min、max

len函数返回序列中所包含的元素的数量。

min函数返回序列中最小值。

max函数返回序列中最大值。

如：

>>> c[:]
[1, 2, 3, 4, 5, 6, 7, 8]
>>> len(c)
8
>>>
>>> max(c)
8
>>> min(c)
1
>>>

>>> max(1,2,3,4,5)        //这里的参数并不是一个序列，而是采用了多个数值直接作为参数。
5
>>>


3、列表：

列表是可变的，可以改变列表的内容。

3.1、list函数：

    格式：list（‘字符串’）

由于字符串不能像列表一样被修改，所以有时根据字符串创建列表会很有用。而list函数可是实现此功能。当然list函数适用于所有类型的序列，不只是字符串

如：

>>> a=[1,2,3,4,5,6,7,8,9]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(a)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> st='helloworld'
>>> list(st)
['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']    //将字符串专程列表。
>>>


3.2、列表的基本操作   (元素赋值、删除元素、分片赋值、列表方法）

列表可以使用以上所有适用于序列的标准操作，例如：索引、分片、连接和乘法。但是列表是可以修改的，如：元素赋值、元素删除、分片赋值、列表方法（不是所有的列表方法都可以改变列表）


a）、元素赋值

    格式：sequence[元素位置]=新值

需要使用索引标记来为某个特定的、位置明确的元素赋值，

如：

>>> x=[1,2,3]
>>> x[0]=10
>>> x
[10, 2, 3]
>>>

b）、删除元素

    格式：del sequence[元素位置]

如：

>>> x
[10, 2, 3]
>>> del  x[0]
>>> x
[2, 3]
>>>


c）、分片赋值

如：

>>> name='zhangsan'
>>> name=list('zhangsan')
>>> name
['z', 'h', 'a', 'n', 'g', 's', 'a', 'n']
>>> name[4:]=list('wuji')        //修改元素值，并赋予新值
>>> name
['z', 'h', 'a', 'n', 'w', 'u', 'j', 'i']
>>>
>>> len(name)
8
>>> name[8:]=list('isgoodboy')        //在name序列元素值后面加上新值。
>>> name
['z', 'h', 'a', 'n', 'w', 'u', 'j', 'i', 'i', 's', 'g', 'o', 'o', 'd', 'b', 'o', 'y']
>>>
>>> name[5:]=list('&lisi')                //将name序列从第六个元素值开始替换。
>>> name
['z', 'h', 'a', 'n', 'w', '&', 'l', 'i', 's', 'i']
>>> name[4:4]=list('g&wangwu')    //不替换原有值插入新值在name序列第四个元素后插入g&wangwu 
>>> name
['z', 'h', 'a', 'n', 'g', '&', 'w', 'a', 'n', 'g', 'w', 'u', 'w', '&', 'l', 'i', 's', 'i']
>>> name[4:5]=list('123')            //此处会替换掉值
>>> name
['z', 'h', 'a', 'n', '1', '2', '3', '&', 'w', 'a', 'n', 'g', 'w', 'u', 'w', '&', 'l', 'i', 's', 'i']

>>> name[4:]=[ ]        //利用空虚列赋值
>>> name
['z', 'h', 'a', 'n']
>>>


备注：可以更改序列的步长或步长的正负值进行分片赋值。

>>> name
['z', 'l', 'o', 'v', 'e', 'w', 'u', 'j', 'i']
>>> del name[::2]
>>> name
['l', 'v', 'w', 'j']
>>>
>>> num[1:6:2]=[ ]                        //自行分析。
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: attempt to assign sequence of size 0 to extended slice of size 3
>>>
>>> num[1:6:2]=[11,12,13]
>>> num
[1, 11, 3, 12, 5, 13, 7, 8, 9]
>>>


3.3、列表方法：(append\count\extend\index\insert\pop\remove\reverse\sort\cmp)

方法是一个与某些对象有紧密联系的函数。对象可能是列表、数字、字符串或者其他类型的对象。

    方法调用格式：对象.方法(参数)


a）、append：在列表末尾追加新的对象。它直接修改原来的列表。

和pop方法作用想反

如：

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


b）、count：统计每个元素在列表中出现的次数

如：

>>> a=lst*5
>>> a
[1, 2, 3, [4, 5, 6], 1, 2, 3, [4, 5, 6], 1, 2, 3, [4, 5, 6], 1, 2, 3, [4, 5, 6], 1, 2, 3, [4, 5, 6]]
>>> a[3]
[4, 5, 6]
>>> a[2]
3
>>> a[4]
1
>>> len(a)
20
>>> a.count([4,5,6])
5
>>> a.count(4)
0
>>> a.count(3)
5


c)、extend：在列表的末尾一次性追加另一个序列中的多个值（注意append只能追加一个对象）

可以和分片追加、列表“+”、作对比

如：

>>> a
[1, 2, 3]
>>> b=[4,5,6]
>>> a.extend(b)        //a用extend追加b列表，b的值会扩展a的值后面。
>>> a
[1, 2, 3, 4, 5, 6]
>>> c=[7,8,9]
>>> c.append(b)    //c用append方法追加一个列表b，b列表制作为一个元素值。
>>> c
[7, 8, 9, [4, 5, 6]]
>>>


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

如：

>>> d
[1, 2, 3, 4, 5, 6, 4, 5, 6, 4, 5, 6]
>>> d.index(5)
4


e）、insert：将对象插入到列表中。（也可以通过分片赋值来实现）

如：

>>> num=[1,2,3,4,5]
>>> num.insert(3,100)        //（3，100）中的3代表插入的位置，100代表插入的值。
>>> num
[1, 2, 3, 100, 4, 5]
>>> num.insert(3,'100')
>>> num
[1, 2, 3, '100', 100, 4, 5]
>>>


f）、pop：移除列表中的一个元素（默认是最后一个），并且返回该元素的值。

和append方法作用相反。

如：

>>> num=[1,2,3,4,5,6,7,8]
>>> num.pop( )
8
>>> num
[1, 2, 3, 4, 5, 6, 7]
>>> num.pop(0)
1
>>> num
[2, 3, 4, 5, 6, 7]
>>> num.pop(1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pop() takes at most 1 argument (3 given)
>>>
注意：使用pop方法可以实现一种常见的数据结构---栈。

    栈的原理就像放盘子一样，最后放的最先拿出（LIFO，后进先出），栈有入栈（push放入盘子）和出栈（pop拿走盘子）。python没有入栈方法，但是可以使用append方法来代替，pop方法和append方法的操作结果恰好相反，如果入栈（或者追加）刚刚出栈的值，最后得到的结果还是原来的值。

    如果需要实现一个先进先出（FIFO）的队列，可以使用insert(0，。。。)来代替append方法，或者也可以继续使用append方法，但是必须用pop（0）来代替pop（）。当然更好的解决方案是使用collection模块中的deque对象。


g）、remove：移除列表中某个值的第一个匹配项。

>>> a
[2, 3, 4, 5, 6, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6]
>>> a.remove(5)
>>> a
[2, 3, 4, 6, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6]
>>>


h）、reverse：将列表中的元素反向存放。

>>> a=[1,2,3,4,5]
>>> a.reverse( )
>>> a
[5, 4, 3, 2, 1]
>>>
>>> a=‘helloworld’                //reverse对字符串序列不适用。
  File "<stdin>", line 1
    a=‘helloworld’
      ^
SyntaxError: invalid syntax
>>> a='helloworld'
>>> a.reverse()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'reverse'
>>> a=['b','c','d','e','f','g']    //。。。。。。
>>> a.reverse()
>>> a
['g', 'f', 'e', 'd', 'c', 'b']
>>>

i）、sort：用于在原位置对列表进行排序。在“原位置排序”意味着改变原来的列表，从而让其中的元素能按照一定的顺序排列，而不是简单地返回一个已排列的列表副本。

如：

>>> x=[4,7,6,32,8]        //对整数序列排序
>>> x.sort()
>>> x
[4, 6, 7, 8, 32]
>>> y=['a','i','c','r','f']        //对字符序列排序
>>> y.sort()
>>> y
['a', 'c', 'f', 'i', 'r']
>>> c='helloworld'            //不能对字符串序列排序。
>>> c.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'sort'
>>>
>>> x=[4,7,6,32,8]


需要一个排好序的列表副本，又保留原来的列表不变的问题解析

>>> x
[4, 7, 6, 32, 8]
>>> y=x.sort()        //不能使用sort方法赋值给变量，因为sort方法修改了x却返回了空值。
>>> y
>>> print(y)
None
>>>

>>> x
[4, 6, 7, 8, 32]
要实现上述功能的做法：

方法一、

>>> x
[4, 7, 6, 32, 8]
>>> y=x[:]                //1、将序列x所有元素赋给y；注意此处不能写成y=x，这样y、x都指向一个列表了。
>>> y
[4, 7, 6, 32, 8]
>>> y.sort()            //2、用y进行序列排序
>>> y
[4, 6, 7, 8, 32]
>>> x
[4, 7, 6, 32, 8]
>>>
方法二、

>>> x
[4, 7, 6, 32, 8]
>>> y=sorted(x)        //使用sorted函数来赋值
>>> x
[4, 7, 6, 32, 8]
>>> y
[4, 6, 7, 8, 32]
>>>


>>> sorted("hello")        //sorted函数可用于任何序列，总返回一个列表，已经排好序的列表。

['e', 'h', 'l', 'l', 'o']
>>> sorted([13,27,4])
[4, 13, 27]
>>>

注意：如果想把一些元素按相反的顺序排列，可以先使用sort或者sorted进行排序，然后在使用reverse方法进行反向存放。


j）、cmp:  (高级排序：)   注意：cmp方法只能用在python2.x版本中。

如果希望元素能够按照特定的方式进行排序（而不是像sort方法默认的方式），可以通过使用compare(x,y)的形式自定义比较函数。

compare(x,y)函数会在x<y时，返回负数；

compare(x,y)函数会在x>y时，返回正数；

compare(x,y)函数会在x=y时，返回0（根据自己定义）；

，定义好compare函数后，可以提供给sort（）方法作为参数

>>> cmp(33,44)
-1
>>> cmp(44,33)
1
>>> cmp(3,3)
0
>>>

>>> num=[3,2,6,4]
>>> num.sort(cmp)
>>> num
[2, 3, 4, 6]
>>>