python学习（五）列表

    列表是Python中内置有序可变序列，列表的所有元素放 在一对中括号“[]”中，并使用逗号分隔开；

    当列表元素增加或删除时，列表对象自动进行扩展或收 缩内存，保证元素之间没有缝隙；

    在Python中，一个列表中的数据类型可以各不相同，可 以同时分别为整数、实数、字符串等基本类型，甚至是 列表、元组、字典、集合以及其他自定义类型的对象。

x=[5,4,3,2,1]
x=[5,'hello','abc',6]
x=[6,'hello',['my','name',666],'why']

列表常用方法

方法	功能
lst.append(x)	将元素x添加至列表lst尾部
lst.extend(L)	将列表L中所有元素添加至列表lst尾部
lst.insert(index, x)	在列表lst指定位置index处添加元素x，该位置后面的所有元 素后移一个位置
lst.remove(x)	在列表lst中删除首次出现的指定元素，该元素之后的所有元 素前移一个位置
lst.pop([index])	删除并返回列表lst中下标为index（默认为-1）的元素
lst.clear()	删除列表lst中所有元素，但保留列表对象
lst.index(x)	返回列表lst中第一个值为x的元素的下标，若不存在值为x的 元素则抛出异常
lst.count(x)	返回指定元素x在列表lst中的出现次数
lst.reverse()	对列表lst所有元素进行逆序
lst.sort(key=None, reverse=False)	对列表lst中的元素进行排序，key用来指定排序依据， reverse决定升序（False）还是降序（True）
lst.copy()	返回列表lst的浅复制

列表的创建：

        1.使用“=”直接将一个列表赋值给变量即可创建列表对象

>>> a_list = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> a_list = [] #创建空列表

       2.也可以使用list()函数将元组、range对象、字符串或其他 类型的可迭代对象类型的数据转换为列表。

>>> a_list = list((3,5,7,9,11))
>>> a_list
[3, 5, 7, 9, 11]
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]
>>> list('hello world')
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
>>> x = list()#创建空列表

列表元素的增加

      1.可以使用“+”运算符将元素添加到列表中。

>>> aList = [3,4,5]
>>> aList = aList + [7]
>>> aList
[3, 4, 5, 7]

     严格意义上来讲，这并不是真的为列表添加元素，而是创建一个新列表， 并将原列表中的元素和新元素依次复制到新列表的内存空间。由于涉及 大量元素的复制，该操作速度较慢，在涉及大量元素添加时不建议使用 该方法。

     2.使用列表对象的append()方法，原地修改列表，是真 正意义上的在列表尾部添加元素，速度较快。

>>> aList.append(9)
>>> aList
[3, 4, 5, 7, 9]

      Python采用的是基于值的自动内存管理方式，当为对象修 改值时，并不是真的直接修改变量的值，而是使变量指向 新的值，这对于Python所有类型的变量都是一样的。

>>> a = [1,2,3]
>>> id(a) #返回对象的内存地址
20230752
>>> a = [1,2]
>>> id(a)
20338208

      列表中包含的是元素值的引用，而不是直接包含元素值。 如果是直接修改序列变量的值，则与Python普通变量的情 况是一样的，而如果是通过下标来修改序列中元素的值或 通过可变序列对象自身提供的方法来增加和删除元素时， 序列对象在内存中的起始地址是不变的，仅仅是被改变值 的元素地址发生变化，也就是所谓的“原地操作” 。

>>> a = [1,2,4]
>>> b = [1,2,3]
>>> a == b
False
>>> id(a) == id(b)
False
>>> id(a[0]) == id(b[0])
True
>>> a = [1,2,3]
>>> id(a)
25289752
>>> a.append(4)
>>> id(a)
25289752
>>> a.remove(3)
>>> a
[1, 2, 4]
>>> id(a)
25289752
>>> a[0] = 5
>>> a
[5, 2, 4]
>>> id(a)
25289752

        3.使用列表对象的extend()方法可以将另一个迭代对象的 所有元素添加至该列表对象尾部。通过extend()方法来增加 列表元素也不改变其内存首地址，属于原地操作。

>>> a.extend([7,8,9])
>>> a
[5, 2, 4, 7, 8, 9]
>>> id(a)
25289752
>>> aList.extend([11,13])
>>> aList
[3, 4, 5, 7, 9, 11, 13]
>>> aList.extend((15,17))
>>> aList
[3, 4, 5, 7, 9, 11, 13, 15, 17]
>>>x=[1,2,3]
>>>y=[1,2,['hello',3],4]
>>>x.extend(y)
>>>x
[1, 2, 3, 1, 2, ['hello', 3], 4]
>>>x.extend(y[2])
>>>x
[1, 2, 3, 1, 2, ['hello', 3], 4, 'hello', 3]

      4.使用列表对象的insert()方法将元素添加至列表的指定 位置。

>>>x=[1,2,3]
>>>x.insert(1,'hello')
>>>x
[1, 'hello', 2, 3]

     5.使用乘法来扩展列表对象，将列表与整数相乘，生成 一个新列表，新列表是原列表中元素的重复。

>>> aList = [3,5,7]
>>> aList = aList*3
>>> aList
[3, 5, 7, 3, 5, 7, 3, 5, 7]

   当使用*运算符将包含列表的列表重复并创建新列表时， 并不创建元素的复制，而是创建已有对象的引用。因此， 当修改其中一个值时，相应的引用也会被修改。

>>> x = [[None] * 2] * 3
>>> x
[[None, None], [None, None], [None, None]]
>>> x[0][0] = 5
>>> x
[[5, None], [5, None], [5, None]]
>>> x = [[1,2,3]] * 3
>>> x[0][0] = 10
>>> x
[[10, 2, 3], [10, 2, 3], [10, 2, 3]]

列表元素的删除

     1.使用del命令删除列表中的指定位置上的元素。

>>> a_list = [3,5,7,9,11]
>>> del a_list[1]
>>> a_list
[3, 7, 9, 11]

     2.使用列表的pop()方法删除并返回指定（默认为最后一 个）位置上的元素，如果给定的索引超出了列表的范围则抛 出异常。

>>> a_list = list((3,5,7,9,11))
>>> a_list.pop()
11
>>> a_list
[3, 5, 7, 9]
>>> a_list.pop(1)
5
>>> a_list
[3, 7, 9]

      3.使用列表对象的remove()方法删除首次出现的指定元 素，如果列表中不存在要删除的元素，则抛出异常

 

>>> a_list = [3,5,7,9,7,11]
>>> a_list.remove(7)
>>> a_list
[3, 5, 9, 7, 11]

   remove()方法的注意事项：

   下面的代码成功地删除了列表中的重复 元素，执行结果是完全正确的。

>>> x = [1,2,1,2,1,2,1,2,1]
>>> for i in x:
if i == 1:
x.remove(i)
>>> x
[2, 2, 2, 2]

   然而，上面这段代码的逻辑是错误的。同样的代码，仅仅 是所处理的数据发生了一点变化，然而当循环结束后却发 现并没有把所有的“1”都删除，只是删除了一部分。

>>> x = [1,2,1,2,1,1,1]
>>> for i in x:
if i == 1:
x.remove(i)
>>> x
[2, 2, 1]

       两组数据的本质区别在于，第一组数据中没有连续的“1”， 而第二组数据中存在连续的“1”。出现这个问题的原因是 列表的自动内存管理功能。

     在删除列表元素时，Python会自动对列表内存进行收缩并 移动列表元素以保证所有元素之间没有空隙，增加列表元 素时也会自动扩展内存并对元素进行移动以保证元素之间 没有空隙。每当插入或删除一个元素之后，该元素位置后 面所有元素的索引就都改变了。

  正确的代码：

>>> x = [1,2,1,2,1,1,1]
>>> for i in x[::]: #切片
if i == 1:
x.remove(i)
#或者
>>> x = [1,2,1,2,1,1,1]
>>> for i in range(len(x)-1,-1,-1):#从后向前
if x[i]==1:
del x[i]

使用列表对象的index()方法获取指定元素首次出现的下标， 若列表对象中不存在指定元素，则抛出异常。

>>> aList
[3, 4, 5, 5.5, 7, 9, 11, 13, 15, 17]
>>> aList.index(7)
4
>>> aList.index(100)
Traceback (most recent call last):
File "<pyshell#36>", line 1, in <module>
aList.index(100)
ValueError: 100 is not in list

 使用列表对象的count()方法统计指定元素在列表对象中出 现的次数

>>> aList
[3, 4, 5, 5.5, 7, 9, 11, 13, 15, 17]
>>> aList.count(7)
1
>>> aList.count(0)
0
>>> aList.count(8)
0

        如果需要判断列表中是否存在指定的值，可以使用count() 方法，如果存在则返回大于0的数，如果返回0则表示不存 在。或者，使用更加简洁的“in”关键字来判断一个值是 否存在于列表中，返回结果为“True”或“False”。

>>> aList
[3, 4, 5, 5.5, 7, 9, 11, 13, 15, 17]
>>> 3 in aList
True
>>> 18 in aList
False
>>> bList = [[1], [2], [3]]
>>> 3 in bList
False
>>> 3 not in bList
True
>>> [3] in bList
True

切片操作

       切片是Python序列的重要操作之一，适用于列表、元组、字符 串、range对象等类型。

       切片使用2个冒号分隔的3个数字来完成，第一个数字表示切片 开始位置（默认为0），第二个数字表示切片截止（但不包含） 位置（默认为列表长度），第三个数字表示切片的步长（默认 为1），当步长省略时可以顺便省略最后一个冒号。可以使用切 片来截取列表中的任何部分，得到一个新列表，也可以通过切 片来修改和删除列表中部分元素，甚至可以通过切片操作为列 表对象增加元素。

       切片操作不会因为下标越界而抛出异常，而是简单地在列表尾 部截断或者返回一个空列表，代码具有更强的健壮性。

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::] #返回包含所有元素的新列表
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::-1] #逆序的所有元素
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
>>> aList[::2] #偶数位置，隔一个取一个
[3, 5, 7, 11, 15]
>>> aList[1::2] #奇数位置，隔一个取一个
[4, 6, 9, 13, 17]
>>> aList[3::] #从下标3开始的所有元素
[6, 7, 9, 11, 13, 15, 17]
>>> aList[3:6] #下标在[3, 6)之间的所有元素
[6, 7, 9]
>>> aList[0:100:1] #前100个元素，自动截断
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[100:] #下标100之后的所有元素，自动截断
[]
>>> aList[100] #直接使用下标访问会发生越界
IndexError: list index out of rang

      可以使用切片来原地修改列表内容

>>> aList = [3, 5, 7]
>>> aList[len(aList):] = [9] #在尾部追加元素
>>> aList
[3, 5, 7, 9]
>>> aList[:3] = [1, 2, 3] #替换前3个元素
>>> aList
[1, 2, 3, 9]
>>> aList[:3] = [] #删除前3个元素
>>> aList
[9]
>>> aList = list(range(10))
>>> aList
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> aList[::2] = [0]*5 #替换偶数位置上的元素
>>> aList
[0, 1, 0, 3, 0, 5, 0, 7, 0, 9]
>>> aList[::2] = [0]*3 #切片不连续，两个元素个数必须一样多
ValueError: attempt to assign sequence of size 3 to extended slice of size 5

    使用del与切片结合来删除列表元素

>>> aList = [3,5,7,9,11]
>>> del aList[:3] #删除前3个元素
>>> aList
[9, 11]
>>> aList = [3,5,7,9,11]
>>> del aList[::2] #删除偶数位置上的元素
>>> aList
[5, 9]

列表推导式

    列表推导式使用非常简洁的方式来快速生成满足特定需求 的列表，代码具有非常强的可读性。

>>> aList = [x*x for x in range(10)]
#相当于
>>> aList = []
>>> for x in range(10):
aList.append(x*x)

 过滤不符合条件的元素

#过滤不符合条件的元素
>>> aList = [-1,-4,6,7.5,-2.3,9,-11]
>>> [i for i in aList if i>0]
[6, 7.5, 9]

         eg:已知有一个包含一些同学成绩的字典，计算成绩的最高分、 最低分、平均分，并查找所有最高分同学。

>>> scores = {"Zhang San": 45, "Li Si": 78, "Wang Wu": 40, "Zhou Liu": 96, "Zhao 
Qi": 65, "Sun Ba": 90, "Zheng Jiu": 78, "Wu Shi": 99, "Dong Shiyi": 60}
>>> highest = max(scores.values())
>>> lowest = min(scores.values())
>>> average = sum(scores.values())*1.0/len(scores)
>>> highest, lowest, average
99 40 72.33333333333333
>>> highestPerson = [name for name, score in scores.items() if score == highest]
>>> highestPerson
['Wu Shi']