Python列表详解

基本概念：

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号“[]”内的逗号分隔值出现。
列表的数据项不需要具有相同的类型

注意：只有字符串是用单引号或双引号引起来的，列表中的数字，等其他非字符串元素不需用，也不能用单引号或双引号引起来。如下所示：
list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。
列表中的值的分割也可以用到变量 [头下标 : 尾下标]，就可以截取相应的列表。（注意顾头不顾尾）

类型转换

但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表

res=list('hello')
print(res)

res=list({'k1':111,'k2':222,'k3':3333})
print(res)

 

添加元素到列表

将新的元素追加到列表末尾(使用append()函数)

例如：
已有列表list元素如下：
list=['jesse','786', '2.23', 'john', '70.2']
现在需要在末尾加上zhangsan这个元素


##代码
list=['jesse','786', '2.23', 'john', '70.2']
list.append('zhangsan')
print(list)
##运行结果
['jesse', '786', '2.23', 'john', '70.2', 'zhangsan']

将新的元素从列表的任意位置插入（insert函数）

例如：
已有列表list元素如下：
list=['jesse','786', '2.23', 'john', '70.2']
现在需要将zhangsan这个元素插入在元素’jesse’后面一个（也就是1的位置）
#代码
list=['jesse','786', '2.23', 'john', '70.2']
list.insert(1,'zhangsan')  
print(list)
#执行结果
['jesse', 'zhangsan', '786', '2.23', 'john', '70.2']

//解释：
list.insert(1,'zhangsan') #在list列表中1的位置插入zhangsan这个元素，原先在1位置的元素自动向后移动一位
1表示想要在1位置插入
zhangsan是要插入的新的元素

现在根据上面再在zhangsan元素的后面一位插入yuan这个元素
分析一下，zhangsan这个元素现在在1的位置其后一位就是2，那我们就插在2位置上

//代码
list=['jesse','786', '2.23', 'john', '70.2']
list.insert(1,'zhangsan')
list.insert(2,'yuan')
print(list)
//运行结果
['jesse', 'zhangsan', 'yuan', '786', '2.23', 'john', '70.2']

删除列表中的元素

例如：
已有列表list元素如下：
list=['jesse','786', '2.23', 'john', '70.2']
现在要将1位置的‘786’元素删除

方法一：（用remove函数根据元素值删除）

格式：
列表名.remove(‘要删除的列表值’)
//代码
list=['jesse','786', '2.23', 'john', '70.2']
list.remove('786')
print(list)
//执行结果
['jesse', '2.23', 'john', '70.2']

方法二：（根据元素位置删除）

#使用del

格式：
del 列表名[要删元素所在位置]

//代码（‘786’元素所在位置为1）
list=['jesse','786', '2.23', 'john', '70.2']
del list[1]
print(list)
//执行结果
['jesse', '2.23', 'john', '70.2']

#用pop方法

pop()方法用于移除列表中的一个元素（默认最后一个元素也就是-1位置）
格式：
list.pop(要删除的列表元素位置)

//代码
list=['jesse','786', '2.23', 'john', '70.2']
list.pop(1)
print(list)

//执行结果
['jesse', '2.23', 'john', '70.2']

修改/更新列表中的元素

例如：
已有列表list元素如下：
list=['jesse','786', '2.23', 'john', '70.2']
现在要将1位置的‘786’元素修改为zhangsan这个元素
格式：
列表名[要修改的位置]=’要修改的值’

//代码
list=['jesse','786', '2.23', 'john', '70.2']
list[1]='zhangsan'
print(list)
//执行结果
['jesse', 'zhangsan', '2.23', 'john', '70.2']

访问/查询列表中的值

# 无论是取值操作还是赋值操作：索引不存在则报错

//代码
list = ['jesse', 786, 2.23, 'john', 70.2]
tinylist = [123, 'john']
print(list)                        # 输出完整列表
print(list[0])                    # 输出列表的第一个元素
print(list[-1])                    # 输出列表的最后一个元素
print(list[1:3])    # 输出第二个至第三个的元素(虽然写的是[1:3]；但是顾头不顾尾，只能从第2个取到第3个，第4个最后一位取不到；只能取到其前一位)
print(list[2:])                    # 输出从第三个开始至列表末尾的所有元素
print(list[:3])                    #输出从第一个开始至第三个元素（原因顾首不顾尾）
print(list[-4:-1])                #输出从倒数第四个到倒数第二个（因为顾头不顾尾所以只取到倒数第二个而不是倒数第一个）
print(list[-2:])                    输出从倒数第二个至列表末尾的所有元素
print(tinylist*2)                # 输出列表两次
print(list+tinylist)                # 打印组合的列表         
print(len(list))                 #打印列表长度
以上实例输出结果：
['jesse', 786, 2.23, 'jhon', 70.2]
Jesse
70.2
[786, 2.23]
[2.23, 'john', 70.2]
['jesse', 786, 2.23]
[786, 2.23, 'john']
['john', 70.2]
[123, 'jhon', 123, 'jhon']
['jesse', 786, 2.23, 'jhon', 70.2, 123, 'jhon']
5

切片操作

list = ['jesse', 786, 2.23, 'john', 70.2]  #从0开始数依次元素为list[0]=jesse、list[1]=786、list[2]=2.23、list[3]=john、list[4]=70.2
print(list[1:3])    # 输出第二个至第三个的元素(虽然写的是[1:3]；但是顾头不顾尾，只能从第2个取到第3个，第4个最后一位取不到；只能取到其前一位)
print(list[0])                    # 输出列表的第一个元素
print(list[-1])                    # 输出列表的最后一个元素

步长切片

list = ['jesse', 786, 2.23, 'john', 70.2]
print(list[0:-1:2])               #输出从第一个到倒数第二个并且步长为2；跳着切（因为顾头不顾尾所以只取到倒数第二个而不是倒数第一个）
# //0和-1可以省略
print(list[::2])                    #['jesse', 2.23, 70.2]
print(list[-1::-1])                #[70.2, 'john', 2.23, 786, 'jesse']

# //print结果
['jesse', 2.23]
['jesse', 2.23, 70.2]
[70.2, 'john', 2.23, 786, 'jesse']

根据元素查出元素在列表所在位置（用index方法）

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

已有列表list元素如下：
list=['jesse','786', '2.23', 'john', '70.2']
假如现在已经知道列表中有john这个元素，查出其在表中所在位置
//代码
list=['jesse','786', '2.23', 'john', '70.2']
print(list.index('786'))
//执行结果
3

统计列表中相同元素的个数（count函数）

count() 方法用于统计某个元素在列表中出现的次数。
count()方法语法：
list.count(列表中需要统计的对象)

已有列表list元素如下：
list=['jesse','zhangsan','zhangsan','786', '2.23', 'john', '70.2']
//统计其中zhangsan这个元素重复的有几个

//代码
list=['jesse','zhangsan','zhangsan','786', '2.23', 'john', '70.2']
print(list.count('zhangsan'))
//运行结果
2

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：

 Python列表截取与拼接

Python的列表截取与字符串操作类型，如下所示：
L=['Google', 'Runoob', 'Taobao']
操作：

>>>L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>
列表还支持拼接操作：
>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>

 嵌套列表

使用嵌套列表即在列表里创建其它列表，例如：
>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

解压赋值（字典也可以用）：（只能取开头和结尾）

//代码
salaries=[33,22,11,55,44]
a,b,c,*abc=salaries   #取前三个值
print(a,b,c,abc)
//执行结果
33 22 11 [55, 44]

//代码
salaries=[33,22,11,55,44]
*_,a,b,c=salaries  #取后三个值
print(a,b,c)
//执行结果
11 55 44

//代码
salaries=[33,22,11,55,44]
a,b,c,*_,m=salaries  #取前三个值和最后一个值
print(a,b,c,m)
//执行结果
33 22 11 44

列表生成式：（使代码更简洁）

//列表生成式
a=[ i*2 for i in range(10)]
print(a)
执行结果
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

//相当于
//代码
a=[]
for i in range(10):
    a.append(i*2)
print(a)

Python列表函数&方法

1、len(list)函数:列表元素个数

//描述
len() 方法返回列表元素个数。
//语法
len()方法语法：
len(list)
//参数
list -- 要计算元素个数的列表。
//返回值
返回列表元素个数。
//实例
以下实例展示了 len()函数的使用方法：
#!/usr/bin/python3
list1 = ['Google', 'Runoob', 'Taobao']
print (len(list1))
list2=list(range(5)) # 创建一个 0-4 的列表
print (len(list2))
以上实例输出结果如下：
3
5
也可以用list下的len方法：
代码：
print(list1.__len__())
输出结果：
3

2、max(list)：返回列表元素最大值

//描述
max() 方法返回列表元素中的最大值。

//语法
max()方法语法：
max(list)
//参数
list -- 要返回最大值的列表。
返回值
返回列表元素中的最大值。
//实例

以下实例展示了 max()函数的使用方法：
#!/usr/bin/python3
list1, list2 = ['Google', 'Runoob', 'Taobao'], [456, 700, 200]
print ("list1 最大元素值 : ", max(list1))
print ("list2 最大元素值 : ", max(list2))
以上实例输出结果如下：
list1 最大元素值 :  Taobao 
list2 最大元素值 :  700

当列表中的个元素都是字符串的时候，max 函数的比较原理：
//代码
list1 = ['我','爱','python']
list2 = [100, 200, 300]
print( 'list1的最大值:', max(list1) )
print( 'list2的最大值:', max(list2) )

print( id(list1[0]) )
print( id(list1[1]) )
print( id(list1[2]) )

print('我' > '爱')
print('爱' > 'python')
print('我' > 'python')
输出结果为：
list1的最大值: 爱
list2的最大值: 300

95966224
100598176
95751008

False
True
True
可以看出列表中元素为字符串的时候，max 函数的比较是根据 id 的大小来判断的。

3、min(list)：返回列表元素最小值

//描述
min() 方法返回列表元素中的最小值。
//语法
min()方法语法：
min(list)
//参数
list -- 要返回最小值的列表。
返回值
返回列表元素中的最小值。
//实例
以下实例展示了 min()函数的使用方法：
#!/usr/bin/python3
list1, list2 = ['Google', 'Runoob', 'Taobao'], [456, 700, 200]
print ("list1 最小元素值 : ", min(list1))
print ("list2 最小元素值 : ", min(list2))
以上实例输出结果如下：
list1 最小元素值 :  Google
list2 最小元素值 :  200

和max(list)函数一样比较是根据 id 的大小来判断

4、list(seq)：类型转换

//描述
list() 方法用于将元组或字符串转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
//语法
list()方法语法：
list( seq )
//参数
list -- 要转换为列表的元组或字符串。
返回值
返回列表。
//实例
以下实例展示了 list()函数的使用方法：
#!/usr/bin/python3
aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print ("列表元素 : ", list1)

str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)
list3=list(range(5))
print ("列表元素 : ", list3)

以上实例输出结果如下：
列表元素 :  [123, 'Google', 'Runoob', 'Taobao']
列表元素 :  ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
列表元素 :  [0, 1, 2, 3, 4]

Python包含以下方法：

list.append(obj) 在列表末尾添加新的对象

//描述
append() 方法用于在列表末尾添加新的对象。
//语法
append()方法语法：
list.append(obj)
//参数
obj -- 添加到列表末尾的对象。
//返回值
该方法无返回值，但是会修改原来的列表。
//实例
以下实例展示了 append()函数的使用方法：
#!/usr/bin/python3
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)
以上实例输出结果如下：
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

list.count(obj) 统计某个元素在列表中出现的次数

//描述
count() 方法用于统计某个元素在列表中出现的次数。
//语法
count()方法语法：
list.count(obj)
//参数
obj -- 列表中统计的对象。
返回值
返回元素在列表中出现的次数。
//实例
以下实例展示了 count()函数的使用方法：
#!/usr/bin/python3
aList = [123, 'Google', 'Runoob', 'Taobao', 123]
print ("123 元素个数 : ", aList.count(123))
print ("Runoob 元素个数 : ", aList.count('Runoob'))
//以上实例输出结果如下：
123 元素个数 :  2
Runoob 元素个数 :  1

list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

//描述
extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
//语法
extend()方法语法：
list.extend(seq)
//参数
seq -- 元素列表。
返回值
该方法没有返回值，但会在已存在的列表中添加新的列表内容。
//实例
以下实例展示了 extend()函数的使用方法：
#!/usr/bin/python3

list1 = ['Google', 'Runoob', 'Taobao']
list2=list(range(5)) # 创建 0-4 的列表
list1.extend(list2)  # 扩展列表
print ("扩展后的列表：", list1)
//以上实例输出结果如下：
扩展后的列表： ['Google', 'Runoob', 'Taobao', 0, 1, 2, 3, 4]
extend 与 append 的区别
>>> A = ['q', 'w', 'e', 'r']
>>> A.extend(['t', 'y'])
>>> A
['q', 'w', 'e', 'r', 't', 'y']
>>>len(A)

>>> B = ['q', 'w', 'e', 'r']
>>> B.append(['t', 'y'])
>>> B
['q', 'w', 'e', 'r', ['t', 'y']]
>>>len(B)
extend 与 append 方法的相似之处在于都是将新接收到参数放置到已有列表的后面。而 extend 方法只能接收 list，且把这个 list 中的每个元素添加到原 list 中。
而 append 方法可以接收任意数据类型的参数，并且简单地追加到 list 尾部。
>>> a = [11,22,33]
>>> a.extend([44])
>>> a
[11,22,33,44]
>>> a.extend('55')
>>> a
[11,22,33,44,'5','5']    #因为extend只接收list，所以将其拆分

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

//描述
index() 函数用于从列表中找出某个值第一个匹配项的索引位置。
//语法
index()方法语法：
list.index(obj)
//参数
obj -- 查找的对象。
返回值
该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。
//实例
以下实例展示了 index()函数的使用方法：
#!/usr/bin/python3
list1 = ['Google', 'Runoob', 'Taobao']
print ('Runoob 索引值为', list1.index('Runoob'))
print ('Taobao 索引值为', list1.index('Taobao'))
//以上实例输出结果如下：
Runoob 索引值为 1
Taobao 索引值为 2

list.insert(index, obj) 将对象插入列表

//描述
insert() 函数用于将指定对象插入列表的指定位置。

//语法
insert()方法语法：

list.insert(index, obj)
//参数
index -- 对象obj需要插入的索引位置。
obj -- 要插入列表中的对象。
//返回值
该方法没有返回值，但会在列表指定位置插入对象。
//实例
以下实例展示了 insert()函数的使用方法：
#!/usr/bin/python3
list1 = ['Google', 'Runoob', 'Taobao']
list1.insert(1, 'Baidu')
print ('列表插入元素后为 : ', list1)
以上实例输出结果如下：
列表插入元素后为 :  ['Google', 'Baidu', 'Runoob', 'Taobao']

list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

//描述
pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
//语法
pop()方法语法：
list.pop([index=-1])
//参数
index -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。
//返回值
该方法返回从列表中移除的元素对象。
//实例
以下实例展示了 pop()函数的使用方法：
#!/usr/bin/python3
list1 = ['Google', 'Runoob', 'Taobao']
list1.pop()
print ("列表现在为 : ", list1)
list1.pop(1)
print ("列表现在为 : ", list1)
以上实例输出结果如下：
列表现在为 :  ['Google', 'Runoob']
列表现在为 :  ['Google']

list.remove(obj) 移除列表中某个值的第一个匹配项

//描述
remove() 函数用于移除列表中某个值的第一个匹配项。
//语法
remove()方法语法：
list.remove(obj)
//参数
obj -- 列表中要移除的对象。
//返回值
该方法没有返回值但是会移除两种中的某个值的第一个匹配项。
//实例
以下实例展示了 remove()函数的使用方法：
#!/usr/bin/python3
list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.remove('Taobao')
print ("列表现在为 : ", list1)
list1.remove('Baidu')
print ("列表现在为 : ", list1)
以上实例输出结果如下：
列表现在为 :  ['Google', 'Runoob', 'Baidu']
列表现在为 :  ['Google', 'Runoob']

list.reverse() 反转列表中元素

//描述
reverse() 函数用于反向列表中元素。
//语法
reverse()方法语法：
list.reverse()
//参数
NALL。
//返回值
该方法没有返回值，但是会对列表的元素进行反向排序。
//实例
以下实例展示了 reverse()函数的使用方法：
#!/usr/bin/python3
list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.reverse()
print ("列表反转后: ", list1)
以上实例输出结果如下：

列表反转后:  ['Baidu', 'Taobao', 'Runoob', 'Google']

list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序

列表中sort方法
描述
sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

语法
sort()方法语法：

list.sort(*, key=None, reverse=Fales),取消了python2中的关键字参数cmp
参数
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
返回值
该方法没有返回值，但是会对列表的对象进行排序。

实例
以下实例展示了 sort() 函数的使用方法：
实例
#!/usr/bin/python
aList = ['Google', 'Runoob', 'Taobao', 'Facebook'] 
aList.sort()
print ( "List : ", aList)
以上实例输出结果如下：
List :  ['Facebook', 'Google', 'Runoob', 'Taobao']
以下实例降序输出列表：（默认升序）
实例
#!/usr/bin/python
# -*- coding: UTF-8 -*- 
# 列表
vowels = ['e', 'a', 'u', 'o', 'i']
# 降序
vowels.sort(reverse=True)
# 输出结果
print ( '降序输出:', vowels )
以上实例输出结果如下：
降序输出: ['u', 'o', 'i', 'e', 'a']
以下实例演示了通过指定列表中的元素排序来输出列表：

实例
#!/usr/bin/python
# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序
random.sort(key=takeSecond)
# 输出类别
print ('排序列表：', random)
以上实例输出结果如下：
排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]

list.clear() 清空列表

//描述
clear() 函数用于清空列表，类似于 del a[:]。
//语法
clear()方法语法：
list.clear()
//参数
无。
//返回值
该方法没有返回值。
//实例
以下实例展示了 clear()函数的使用方法：
#!/usr/bin/python3
list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.clear()
print ("列表清空后 : ", list1)
以上实例输出结果如下：
列表清空后 :  []

list.copy() 复制列表

/描述
copy() 函数用于复制列表，类似于 a[:]。
//语法
copy()方法语法：
list.copy()
//参数
无。
//返回值
返回复制后的新列表。
//实例
以下实例展示了 copy()函数的使用方法：
#!/usr/bin/python3
list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list2 = list1.copy()
print ("list2 列表: ", list2)
以上实例输出结果如下：
list2 列表:  ['Google', 'Runoob', 'Taobao', 'Baidu']


//注意：copy()这个方法浅复制的时候，如果列表里面套列表，只复制第一层列表；浅copy列表list中嵌套的列表时，只是拷贝了一份列表的内存地址
//代码
list=['jesse','zhangsan',['786', '2.23']]
list1=list.copy()
print(list)
print(list1)
list[0]='jc'
list[2][0]='yuanyuan'       #我改list，按理说list1是没修改的，结果也改了
print(list)
print(list1)
//执行结果
['jesse', 'zhangsan', ['786', '2.23']]
['jesse', 'zhangsan', ['786', '2.23']]
['jc', 'zhangsan', ['yuanyuan', '2.23']]
['jesse', 'zhangsan', ['yuanyuan', '2.23']]

//如果想真正的深入copy一下用copy.deepcopy(list)
//代码
import copy
list=['jesse','zhangsan',['786', '2.23']]
list1=copy.deepcopy(list)
print(list)
print(list1)
list[0]='jc'
list[2][0]='yuanyuan'
print(list)
print(list1)
//执行结果
['jesse', 'zhangsan', ['786', '2.23']]
['jesse', 'zhangsan', ['786', '2.23']]
['jc', 'zhangsan', ['yuanyuan', '2.23']]
['jesse', 'zhangsan', ['786', '2.23']]

使用for循环遍历列表中的元素

//代码
list = ['jesse', 786, 2.23, 'john', 70.2]
for i in range(len(list)):
print("list列表中第%s个元素为:" % i,list[i])
//执行结果
list列表中第0个元素为: jesse
list列表中第1个元素为: 786
list列表中第2个元素为: 2.23
list列表中第3个元素为: john
list列表中第4个元素为: 70.2

补充：链

from itertools import chain


def f1(x):
    return x + 1


func1_list = [f1, lambda x: x + 10]


def f2(x):
    return x - 1


new_func_list = chain([f2], func1_list)

for func in new_func_list:
    print(func)

"""
<function f2 at 0x10a724310>
<function f1 at 0x10a561430>
<function <lambda> at 0x10a6c1670>
"""