-------------------------纯手打总结，转载请注明出处，爱您~
列表、字典、集合是可变序列；元组和字符串是不可变序列。
列表、元组、字符串是有序序列；字典、集合是无序序列；
* python提供的序列类型在所有程序设计语言中是最丰富，最灵活。也是功能最强大的。
* python中常用的序列结构有列表、元组、字典、字符串、集合以及range等等。
* 除字典和集合之外，列表、元组、字符串等序列均支持双向索引，第一个元素下标为0，第二个元素下标为1，以此类推；最后一个元素下标为-1，倒数第二个元素下标为-2，以此类推。
3.1列表
* 列表是python中内置可变序列，是一个元素的有序集合，定界符为"[]",元素逗号分隔开。
* 当列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有缝隙。
* 在python中，一个列表中的数据类型可以各不相同，可以同时分别为整数、实数、字符串等基本类型，甚至是列表、元素、字典、集合以及其他自定义类型的对象。例如：[10,20,30,40]
['spam',2.0,5,[10,20]]
[['file1',200,7],['file2',260,9]]
* 列表方法
append和extend的区别：
l
3.1.1列表创建与删除
* 使用“=”直接将一个列表赋值给变量即可创建列表对象，例如：>>> a_list=['a','b','mpilgrim','z','example']
>>> print(a_list)
['a', 'b', 'mpilgrim', 'z', 'example']
>>> a_list=[]
>>> print(a_list)
[]
>>> # 上面的a_list=[] 是创建了一个空列表
* 或者，使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表。例如：>>> a_list=list((3,5,7,9,11))
>>> print(a_list)
[3, 5, 7, 9, 11] #将元组转换为列表
>>> list(range(1,10,2))
[1, 3, 5, 7, 9] #将range对象转换为列表
>>> list('hello world')
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] #将字符串转换为列表
>>> x=list() #创建空列表
>>> print(x)
[]
* range()接收三个参数，第一个参数表示起始值(默认为0)，第二个参数表示终止值(结果中不包括这个值)，第三个参数表示步长(默认为1).
* 当不再使用列表时，使用del命令删除整个列表，如果列表对象所指向的值不再有其他对象指向，python将同时删除该值。>>> del a
>>> a
Traceback (most recent call last):
File "", line 1, in
a
NameError: name 'a' is not defined
* 正如上面的代码所展示的一样，删除列表对象a之后，该对象就不存在了，再次访问时将抛出异常"NameError"提示访问的对象名不存在。
3.1.2列表元素的增加
(1)可以使用"+"运算符来实现将元素添加到列表中的功能。这并不是真的为列表添加元素，而是创建一个新列表，并将原列表中的元素和新元素依次复制到新列表的内存空间。由于涉及大量元素的复制，该操作速度较慢。>>> aList=[3,4,5]
>>> aList=aList+[7]
>>> print(aList)
[3, 4, 5, 7]
(2)使用列表对象的append()方法，原地修改列表，是真正意义上的在列表尾部添加元素，速度较快，也是推荐使用的方法。>>> aList.append(9)
>>> print(aList)
[3, 4, 5, 7, 9]
为了比较"+"和append()这两种方法的速度差异，请看以下代码：？
可以看出，append()方法比使用"+"运算快约70倍，相差两个数量级。
(3)使用列表对象的extend()方法可以将另一个迭代对象的所有元素添加至该列表对象尾部。extend()方法属于原地操作，不改变其内存首地址。>>> a=[1,2,4] #创建一个名字为a的列表
>>> id(a)
1903874579400
>>> a.extend([7,8,9]) #把新的列表里面的所有元素添加到名字为a的列表尾部，a的地址不变
>>> id(a)
1903874579400
>>> a.extend((15,17)) #把新的元组里面的所有元素添加到名字为a的列表尾部 ，a的地址不变
>>> id(a)
1903874579400
>>> print(a)
[1, 2, 4, 7, 8, 9, 15, 17]
(4)使用列表对象的insert()方法将元素添加至列表的指定位置，原地操作，不改变其内存首地址。>>> print(a)
[1, 2, 4, 7, 8, 9, 15, 17]
>>> a.insert(3,6)
>>> print(a)
[1, 2, 4, 6, 7, 8, 9, 15, 17]
* 列表的insert()方法会涉及到插入位置之后所有元素的移动，还会影响处理速度，类似的还有后面的remove()方法以及使用pop()函数弹出列表非尾部元素和使用del删除列表非尾部元素的情况。
(5)使用乘法来扩展列表对象。>>> aList=[3,5,7]
>>> aList=aList*3
>>> print(aList)
[3, 5, 7, 3, 5, 7, 3, 5, 7]
>>>aList*=2#相当于 aList=aList*2
>>> print(aList)
[3, 5, 7, 3, 5, 7, 3, 5, 7, 3, 5, 7, 3, 5, 7, 3, 5, 7]
3.1.3 列表元素的删除
(1)使用del命令删除列表中的指定位置上的元素或整个列表。>>> a_list=[3,5,7,9,11]
>>> del a_list[1]
>>> print(a_list)
[3, 7, 9, 11]
>>> del a_list
>>> print(a_list)
Traceback (most recent call last):
File "", line 1, in
print(a_list)
NameError: name 'a_list' is not defined
(2)使用列表的pop()方法删除并返回指定(默认为最后一个)位置上的元素，如果给定的索引超出了列表的范围则抛出异常。>>> a_list=list((3,5,7,9,11))
>>> a_list.pop() #pop方法默认删除最后一个元素并返回删除的最后一个元素的值
11
>>> print(a_list)
[3, 5, 7, 9]
>>> a_list.pop(1)
5 #pop方法删除第二个元素并返回删除的第二个元素的值
>>> print(a_list)
[3, 7, 9]
(3)使用列表对象的remove()方法删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常。>>> a_list=[3,5,7,9,7,11] #创建名称为a_list的列表
>>> a_list.remove(7) #删除列表中第一次出现的元素：7
>>> print(a_list)
[3, 5, 9, 7, 11]
>>> a_list.clear(3) #clear只能清空列表中的全部元素，不能清除指定元素
Traceback (most recent call last):
File "", line 1, in
a_list.clear(3)
TypeError: clear() takes no arguments (1 given)
>>> a_list.clear()
>>> print(a_list)
[] #使用clear方法清空列表中的内容，列表对象并没有被删除
3.1.4 列表元素访问与计数
(1)使用下标直接访问列表元素>>> aList=[3,4,5,5.5,7,9,11,13,15,17]
>>> print(aList[3]) #输出下标为3的元素的值
5.5
* 如果指定下标不存在，则抛出异常>>> print(aList[15])
Traceback (most recent call last):
File "", line 1, in
print(aList[15])
IndexError: list index out of range
(2) 使用列表对象的index方法获取指定元素首次出现的下标>>> aList=[3,4,5,5.5,7,9,11,13,15,17]
>>> print(aList.index(7))
4 #使用列表对象的index方法得出元素7的索引
* 若列表对象中不存在指定元素，则抛出异常>>> print(aList.index(100))
Traceback (most recent call last):
File "", line 1, in
print(aList.index(100))
ValueError: 100 is not in list
(3) 使用列表对象的count方法统计指定元素在列表对象中出现的次数>>> aList=[3,4,5,5.5,7,9,11,13,15,17]
>>> print(aList.count(7))
1 #计算数字7在列表中出现的次数
>>> print(aList.count(0))
0 #计算数字0在列表中出现的次数
>>> print(aList.count(8))
0 #计算数字0在列表中出现的次数
3.1.5 列表元素排序
* 列表对象的sort()方法用于按照指定的规则对所有元素进行排序；
*reverse()方法用于将列表所有元素逆序或翻转。>>> x=list(range(11)) #包含11个整数的列表
>>> import random
>>> random.shuffle(x)
>>> print(x) #用random模块的shuffle方法把列表x中的元素随机乱序
[5, 1, 10, 9, 4, 6, 8, 3, 0, 7, 2]
>>> x.sort() #用列表对象的sort方法按照默认规则排序
>>> print(x)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> x.sort(key=lambda item:len(str(item)),reverse=True) #按转换成字符串以后的长度，降序排列
>>> print(x) ？？不理解。 ppt里面的答案是[10, 6, 0, 1, 7, 4, 3, 2, 8, 5, 9]
[10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x.reverse() #把所有元素翻转或逆序 >>> print(x)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 10]
3.1.6 切片操作 重点看！
* 切片是Python序列的重要操作之一，适用于列表、元组、字符串、range对象等类型。
* 切片使用2个冒号分隔的3个数字来完成，第一个数字表示切片开始位置(默认为0)，第二个数字表示切片截止(但不包含)位置(默认为列表长度)，第三个数字表示切片的步长(默认为1)，当步长省略时可以顺便省略最后一个冒号。
* 可以使用切片来截取列表中的任何部分，得到一个新列表，也可以通过切片来修改和删除列表中部分元素，甚至可以通过切片操作为列表对象增加元素。
* 与使用下标访问列表元素的方法不同，切片操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表，代码具有更强的健壮性。
(1)可以使用切片访问列表内容：>>> aList=[3,4,5,6,7,9,11,13,15,17]
>>> aList[::] #开始位置为0，结束位置为10，切片的步长为1，即按照
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17] 顺序排序。
>>> aList[::-1] #开始位置为0，结束位置为10，切片的步长为-1，即
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3] 倒叙排序。
>>> aList[::2] #开始位置为0，结束位置为10，切片的步长为2，即
[3, 5, 7, 11, 15] 每两个元素之间相差2。
>>> aList[1::2] #开始位置为1，结束位置为10，切片的步长为2，即
[4, 6, 9, 13, 17] 每两个元素之间相差2。
>>> aList[3::] #开始位置为3，结束位置为10，切片的步长为1，即按
[6, 7, 9, 11, 13, 15, 17] 照顺序从位置3开始排序。
>>> aList[3:6] #开始位置为3，结束位置为6，切片的步长为1，即按
[6, 7, 9] 照顺序从位置3开始排序。
>>> aList[3:6:1] #开始位置为3，结束位置为6，切片的步长为1，即
[6, 7, 9] 按照顺序从位置3开始排序。
>>> aList[0:100:1] #开始位置为0，结束位置为100，切片的步长为1，
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17] 即按照顺序排序，越界也不抛出异常。
>>> aList[100:] #开始位置为100，没有元素，越界不抛出异常
[]
(2)可以使用切片来原地修改列表内容：(不理解！！)>>> aList=[3,5,7]
>>> aList[len(aList):] #把列表的长度作为开始位置进行访问，访问到空列表
[]
>>> aList[len(aList):]=[9] #在列表长度的位置添加元素9，相当于把原来的空元素修改为9
>>> print(aList)
[3, 5, 7, 9]
>>> aList[:3]=[1,2,3]
>>> aList
[1, 2, 3, 9]
>>> aList[:3]=[]
>>> print(aList)
[9]
(3)使用del与切片结合来删除列表元素：>>> aList=[3,5,7,9,11]
>>> del aList[:3]
>>> print(aList)
[9, 11]
3.1.7 列表排序
(1)使用内置函数sorted对列表进行排序并返回新列表：>>> aList=[9,7,6,5,4,3,17,15,13,11]
>>> sorted(aList) #正序排列
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> sorted(aList,reverse=True) #逆序排列
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
>>> print(aList) #使用sorted函数排序返回的是新列表，原有列表顺 [9, 7, 6, 5, 4, 3, 17, 15, 13, 11] 序不变。
* 列表对象的sort方法进行原地排序，即直接改变列表的顺序。
(2)使用列表对象的reverse方法将元素原地逆序：>>> aList=[3,4,5,6,7,9,11,13,15,17]
>>> aList.reverse()
>>> print(aList)
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
(3)使用内置函数reversed方法对列表元素进行逆序排列并返回迭代对象：>>> aList=[3,4,5,6,7,9,11,13,15,17]
>>> newList=reversed(aList)
>>> print(newList)
>>> list(newList)
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
>>> for i in newList:
print(i)
#无输出内容，迭代对象已遍历结束，需要重新创建迭代对象
>>> newList=reversed(aList)
>>> for i in newList:
print(i)
17
15
13
11
9
7
6
5
4
3 #列表对象的reverse方法将元素原地逆序。
3.1.8序列的常用内置函数
* len(列表)：返回列表中的元素个数，同样适用于元组、字典、字符串等等。
* max(列表)、min(列表)：返回列表中的最大或最小元素，同样适用于元组、range。
* sum(列表)：对数值型列表的元素进行求和运算。对非数值型列表运算则出错，同样适用于元组、range。
* zip(列表1，列表2,...):将多个列表对应位置元素组合为元组，并返回包含这些元组的列表。>>> aList=[1,2,3]
>>> bList=[4,5,6]
>>> cList=[7,8,9]
>>> dList=zip(aList,bList,cList)
>>> print(dList)
>>> list(dList)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
* enumerate()函数枚举列表元素，返回枚举对象，其每个元素为包含下标和值的元组。该函数对元组、字符串同样有效。>>> dList=[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> for item in enumerate(dList):
print(item)
(0, (1, 4, 7))
(1, (2, 5, 8))
(2, (3, 6, 9))
3.1.9列表推导式
* 列表推导式，也称列表解析式。
* 使用非常简洁的方式对列表或其他可迭代对象的元素进行遍历，过滤与再次计算，快速生成满足特定需求的新列表，代码简洁具有很强的可读性。例如：>>> aList=[x*x for x in range(10)]
相当于>>> aList=[]
>>> for x in range(10):
aList.append(x*x)
>>> x=3
>>> print(x)
3
>>> print(aList)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
* 使用列表推导式实现嵌套列表的平铺：>>> vec=[[1,2,3],[4,5,6],[7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
* 过滤不符合条件的元素：>>> aList=[-1,-4,6,7.5,-3.3,9,-11]
>>> [i for i in aList if i>0]
[6, 7.5, 9]
* 列出当前文件夹下所有Python源文件：>>> [filename for filename in os.listdir('.')if filename.endswith('.py')]
-------------------------纯手打总结，转载请注明出处，爱您~
8万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
