一、简介：

（1）列表（list）是Python以及其他语言中最常用到的数据结构之一。列表中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

（2）列表可以进行的操作包括索引，切片，加，乘，检查成员。

（3）Python已经内置确定列表的长度以及确定最大和最小的元素的方法。

（4）列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

（5）列表的数据项不需要具有相同的类型。

二、基本的列表操作

  列表可以使用所有适用于序列的标准操作，例如索引、分片、连接和乘法。本文介绍一些可以改变列表的方法。

        1. list 函数

         通过 list(seq) 函数把一个序列类型转换成一个列表。

1. >>> list('hello')  
2. ['h', 'e', 'l', 'l', 'o']

         list 函数使用于所有类型的序列，而不只是字符串。

         2. 改变列表：元素赋值

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

1. >>> x = [1, 1, 1]  
2. >>> x[1] = 2  
3. >>> x  
4. [1, 2, 1]

         不能为一个位置不存在的元素进行赋值。

         3. 删除元素

         从列表中删除元素也很容易：使用 del 语句来实现。

1. >>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']  
2. >>> del names[2]  
3. >>> names  
4. ['Alice', 'Beth', 'Dee-Dee', 'Earl']

         除了删除列表中的元素，del 语句还能用于删除其他元素。

         4. 分片赋值

1. >>> name = list('Perl')  
2. >>> name  
3. ['P', 'e', 'r', 'l']  
4. >>> name[2:] = list('ar')  
5. >>> name  
6. ['P', 'e', 'a', 'r']

         在使用分片赋值时，可以使用与原序列不等长的序列将分片替换： 

1. >>> name = list('Perl')  
2. >>> name[1:] = list('ython')  
3. >>> name  
4. ['P', 'y', 't', 'h', 'o', 'n']

         分片赋值语句可以在不需要替换任何原有元素的情况下插入新的元素。 

1. >>> numbers = [1, 5]  
2. >>> numbers[1:1] = [2, 3, 4]  
3. >>> numbers  
4. [1, 2, 3, 4, 5]

         通过分片赋值来删除元素也是可行的

1. >>> numbers  
2. [1, 2, 3, 4, 5]  
3. >>> numbers[1:4] = []  
4. >>> numbers  
5. [1, 5]

三、列表方法

        方法是一个与某些对象有紧密联系的函数。一般，方法可以这样进行调用：

                对象.方法(参数)

除了对象被放置到方法名之前，并且两者之间用一个点号隔开。

        1. append

        append方法用于在列表末尾追加新的对象：

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

             append方法和其他一些方法类似，只是在恰当位置修改原来的列表。这意味着，它不是简单地返回一个修改过的新列表——而是直接修改原来的列表。

             2. count

             count 方法统计某个元素在列表中出现的次数：

      1. >>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to')  
2. 2  
3. >>> x = [[1,2], 1, 1, [2, 1, [1, 2]]]  
4. >>> x.count(1)  
5. 2  
6. >>> x.count([1,2])  
7. 1

               3. extend

               extend 方法可以在列表的末尾一次性追加另一个序列中的多个值。

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

               extend 方法修改了被扩展的列表，而原始的连接操作（+）则不然，它会返回一个全新的列表。 

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

               4. index

               index 方法用于从列表中找出某个值第一个匹配项的索引位置：

        1. >>> knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni']  
2. >>> knights.index('who')  
3. 4

                 当搜索不存在的值时，就会引发一个异常。

                 5. insert

                 insert 方法用于将对象插入到列表中：

        1. >>> numbers = [1, 2, 3, 5, 6, 7]  
2. >>> numbers.insert(3, 'four')  
3. >>> numbers  
4. [1, 2, 3, 'four', 5, 6, 7]

                 6. pop

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

          1. >>> x = [1, 2, 3]  
2. >>> x.pop()  
3. 3  
4. >>> x  
5. [1, 2]  
6. >>> x.pop(0)  
7. 1  
8. >>> x  
9. [2]

                   pop方法是唯一一个即能修改列表又返回元素值（除了None）的列表方法。

                   7. remove

                   remove 方法用于移除列表中某个值的第一个匹配项：

            1. >>> x = ['to', 'be', 'or', 'not', 'to', 'be']  
2. >>> x.remove('be')  
3. >>> x  
4. ['to', 'or', 'not', 'to', 'be']  
5. >>> x.remove('bee')  
6. Traceback (most recent call last):  
7. "<stdin>", line 1, in <module>  
8. ValueError: list.remove(x): x not in list

                     只有第一次出现的值被移除，而不存在与列表中的值是不会移除的。

                     remove 是一个没有返回值的原位置改变方法。它修改了列表却没有返回值。

                     8. reverse

                     reverse 方法将列表中的元素反向存放。

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

                     该方法改变了列表但不返回值。

                     9. sort

                     sort 方法用于在原位置对列表进行排序。          

              1. >>> x = [4, 6, 2, 1, 7, 9]  
2. >>> x.sort()  
3. >>> x  
4. [1, 2, 4, 6, 7, 9]

                       sort 方法修改了 x 却返回了空值。