（python）列表

前言

python不同于c语言的数列，python的列表可以装载不同类型的数据

比如：a=[1,2,3,4,5,"上山打老虎"]

但他同样可以通过下标访问列表中的每一个元素，比如a[0](python的列表同样从0开始)，特别地，列表名[-1]  表示的是列表中的最后一个元素。

（python的列表与c语言的差别：1、数据类型；2、索引；3、切片；4、一些更符合python风格语法的函数）

列表切片

切片：直接选取列表中的多个元素再组成一个列表。

基本语法：列表名[start:stop:step]

a=[1,2,3,4,5,"上山打老虎"]
a[0:3]  #[1,2,3]
a[3:6]  #[4,5,'上山打老虎']
a[:3]  #与第二行结果一样
a[3:]  #与第三行结果一样
a[::2]  #[1,3,5]
a[::-2] #['上山打老虎'，4，2]

说明：当step>0时，若start（或stop）没书写，默认为头（或尾）；step<0则相反。

左闭右开！！

索引：以 a = [ 1,2,3,4,5,6] 为例,正索引和负索引如下：

值	1	2	3	4	5	6
正索引	0	1	2	3	4	5
负索引	-6	-5	-4	-3	-2	-1

增、删

使用函数

append（） 在末尾添加一个元素；

extend（） 在末尾添加一组可迭代对象（可以为一个列表，也可以为几个（或一个）元素）

alphabets=['a','b','c']
alphabets.append('d')
alphabets.extend('e','f','g')
#也可以写成 alphabets.extend(['e','f','g'])

insert(索引,元素)         在任意位置添加元素，该位置原来元素往后靠。

alphabets.insert(len(s),'h')

 remove(元素)        删除指定元素的第一个

alphabets.remove('g')

remove函数的注意事项：

1、当多个重复元素存在时，只删除索引最小的（从左往右数）。

2、当指定元素不存在时，会报错。

pop(索引)        用于删除指定索引的元素

alphabets.pop(1)  #删除了b这个元素

clear（）        删除全部元素，但还保有列表

alphabet.clear()

del 列表        用于直接删除整个列表（删除后列表已不再）

num=[1,2,3]
del num
print(num)  #此时会报错，因为列表已被删除

使用切片

s=[1,2,3,4]
s[len(s):]=[5]  #添加一个
s[len(s):]=[6,7,8] #添加多个
#需要注意的是，不管是一个还是多个，都需要用中括号括起来。
s[6:6]=[66]  #相当于在insert(6,66)
s[5:6]=[]   #删除6这个元素
s[1:3]=[]    #删除2，3这两个元素

总结：对于切片：列表[a,b,c]，

a！=b表示具有一个或者一串具体元素的列表 ；

a=b 表示一个添加状态

改 

替换单个元素

直接使用索引+赋值的方式替换即可。

heros=['蜘蛛侠','灭霸','钢铁侠','雷神']
heros[1]='绿巨人’

替换多个元素

使用切片：（可直接删除n个元素，添加m个元素）

alphabets=['a','b','c','d']
alphabets[2:]=['e','f','g']
print(alphabets)  #结果为['a','b','e','f','g']

补充：切片作左值表示原列表的某部分，作右值则会进行copy操作。

列表中的一些函数 

1、

reverse()函数：将列表的元素颠倒

比如：[2,4,6,1]----->[1,6,4,2]

2、

 sort函数：对原列表进行排序（注意区别于sorted函数）

代码原型：sort(key=None,reverse=False)，（等号右侧是默认值）

        若是数字列表，则从小到大排序；若是字符列表，则使用每个元素的第一个字符的ASCII码进行从小到大排序。

alphabets=['A', 'a', 'b', 'c', 'w', 'we', 'y']
alphabets.sort()
#结果为['A', 'a', 'b', 'c', 'w', 'we', 'y']

3、count函数：查找列表中某个指定元素的个数。

代码原型：count（item）

num=[1,4,6,2,3,1,4,1]
num.count(1)    #返回3

 4、index（元素）：查找某元素在列表出现第一个的位置(索引)

num=[1,4,6,2,3,1,4,1]
num.index(6)    #返回2

5、copy函数：拷贝一份列表

A=[1,2,3,4]
B=A.copy()

6、len(列表)：返回列表元素个数（列表长度）

num=[1,4,6,2,3,1,4,1]
len(num)    #返回8

列表的加乘

a=[1,2,3]
b=[4,5,6]
a+b   #返回[1,2,3,4,5,6]
a*3    #返回[1,2,3,1,2,3,1,2,3]

 嵌套列表

类似于c语言的二维数组

举例：a=[[1,2,3],[4,5,6],[7,8,9]]

a=[[1,2,3],[4,5,6],[7,8,9]]
for i in a
    for each in i
        print(each,end=' ')
    print()#遍历所有元素
#结果为
1 2 3
4 5 6
7 8 9

访问嵌套列表需要使用到两次下标索引，a[0][0] 

嵌套列表

创建列表/

正确示范：

第一种：一般式

A=[0]*3
for i in range(3)
    A[i]=[0]*3

第二种：推导式

A=[[0]*3 for i in range(3)]

错误示范：

A=[[0]*3]*3

因为第二种方法会导致错误，原因在于：

对于python来说，类似于[[]]*3这样的内嵌列表的乘法只是对内嵌的列表进行了引用（或者说是对地址*3），而非真正重新开辟内存空间（拷贝）

注意：列表变量本身只是一个引用（地址）。

对于以下问题，同样是地址一样的问题

A=[1,2,3]
B=A

此时，A与B指向同一个内存空间。

拓展：判断两个变量是否指向同一个内存空间，可以使用函数is

A is B
#返回True，说明是同一个内存空间的。

所以要实现列表的"赋值"（浅拷贝），有两种方法：

第一，需要使用到copy函数。

第二，使用切片。还记得切片的定义吗？（在列表中挑选几个元素再组成列表）

但如果遇到的是嵌套列表，浅拷贝就会出错（因为嵌套列表实际上存储的只是地址罢了）

所以需要使用到深拷贝：

深拷贝

要实现深拷贝，需要使用copy模块。

import copy
A=[[1,2],[3,4][5,6]]
B=copy.deepcopy(A)

使用deepcopy，B与A不再是同一内存。

deepcopy不管有多少层嵌套都可以实现深拷贝。

列表推导式

用于创建，改变列表。

一般代码原型：列表=[expression for target in iterable]

A=[i for i in range(4)]
#创建了A=[0,1,2,3]
A=[i*2 for i in A]
#改变列表A=[0,2,4,6]
B=[[1,2,3],[4,5,6],[7,8,9]]
C=[k[1] for k in B]
#将B的每一行第二个元素提取出来

实际上，对于改变列表，其本质是另外创建一个列表，并将新列表地址赋予变量。

条件推导式：列表=[expression for target in iterable if condition]

多层嵌套推倒时：列表=[expression for target in iterable for target in iterable......]

A=[[1,2,3][4,5,6][7,8,9]]
A=[a for b in A for a in b]
#A=[1,2,3,4,5,6,7,8,9]
#实现降维

多层嵌套+条件 推导式：

列表=[expression for target in iterable if condition for target in iterable if condition......]