简介

python中一个变量可以存储一个元素，而列表则可以存储N个元素，相当于N个元素的集合。列表相当java中的数组，不同的是，列表可以存储不同类型的值。

列表创建有两种：

# 第一种
lst1 = ['我爱','java78.com',520]

# 第二种
lst2 = list(['我爱','java78.com',520])

举个例子看下：

# 第一种创建方式
lst1 = ['i love','java78.com',520]
# 第二种创建
lst2 =list(['i love','java78.com',521])
# 
lst3 =list(lst1)
# 打印第一种方式以及列表第一个元素的id
print(lst1,id(lst1),id(lst1[0]))
# 打印第二种方式以及列表第一个元素的id
print(lst2,id(lst2),id(lst2[0]))
# 打印lst3以及列表第一个元素的id
print(lst3,id(lst3),id(lst3[0]))

输出结果：

['i love', 'java78.com', 520] 49426760 49669696
['i love', 'java78.com', 521] 49540648 49669696
['i love', 'java78.com', 520] 49540776 49669696

可以看到，创建的列表id是不一样的，但是发现列表首个元素值一样，id也是一致的。以上面例子说下列表(list)大概的内存结构图，我们画出来瞅一下

列表特点

• 列表元素是有序的，顺序排序
• 索引映射唯一数据
• 可以存储重复数据
• 可以存储不同类型数据
• 动态分配和回收内存

正向索引是从0 到 N-1，反向索引从 -N 到 -1。如果使用的索引不在 -N 到 N-1 区间内，则会抛出IndexError错误。

# 索引
lst1 = ['i','love','java78.com',520]
# 获取正向索引 2
print('获取正向索引2 : ', lst1[2])
# 获取反向索引 -2
print('获取反向索引-2 : ', lst1[-2])
# 获取不存在索引，抛出 IndexError: list index out of range
print('获取不存在索引 : ', lst1[12])

输出如下：

IndexError: list index out of range
获取正向索引2 :  java78.com
获取反向索引-2 :  java78.com

列表常用方法&操作

获取索引 index()

• 如果列表中存在相同元素，只会返回相同元素的第一个元素的索引。
• 获取索引的元素不存在列表中，会抛出ValueError的错误。
• 还可以指定索引区间内查找，设置 start 和 stop 起始索引值

# index 索引
lst1 = ['i','love','java78.com','and','love','python','too']
# 相同元素只返回第一个元素索引， 为 1
print('获取love的索引', lst1.index('love'))
# 从索引 1- 4 之前获取 java78.com
print('索引 1- 4 之前获取java78.com',lst1.index('java78.com',1,4))
# 不存在元素，抛出错误  ValueError: 'www.java78.com' is not in list
print('获取列表不存在的元素索引',lst1.index('www.java78.com'))

输出如下:

ValueError: 'www.java78.com' is not in list
获取love的索引 1
索引 1- 4 之前获取java78.com 2

截取

列表截取的结果，是原列表的片段拷贝。通常截取方式是lst[start:stop] ,这样截取默认步长是 1。

# 截取
lst=[10,20,30,40,50,60,70,80]
# 截取索引 1-6 片段，步长为1 start=1 stop=6 step=1
lst1 = lst[1:6:1]
print('索引 1-6 片段，步长为1', lst1, id(lst1))
# 默认步长，获取索引 1-6 片段 start=1 stop=6
lst2 = lst[1:6]
print('默认步长，获取索引 1-6 片段', lst2,id(lst2))
# start=1 stop=6 step=2
print('步长为2，获取索引 1-6 片段', lst[1:6:2])
# stop=6 step=2  start采用默认
print('stop=6 step=2  start采用默认', lst[:6:2])
# start=1 step=2  stop采用默认
print('start=1 step=2  stop采用默认', lst[1::2])

# step 步长为负数， 反向获取
# 原列表
print('原列表',lst)
# start=： stop=： step=-1
print('start=： stop=： step=-1', lst[::-1])
# start=7 stop=: step=-1
print('start=7 stop=: step=-1', lst[7::-1])
# start=6 stop=0 step=-2
print('start=6 stop=0 step=-2', lst[6:0:-2])

输出结果如下：

索引 1-6 片段，步长为1 [20, 30, 40, 50, 60] 12136968
默认步长，获取索引 1-6 片段 [20, 30, 40, 50, 60] 12249640
步长为2，获取索引 1-6 片段 [20, 40, 60]
stop=6 step=2  start采用默认 [10, 30, 50]
start=1 step=2  stop采用默认 [20, 40, 60, 80]
原列表 [10, 20, 30, 40, 50, 60, 70, 80]
start=： stop=： step=-1 [80, 70, 60, 50, 40, 30, 20, 10]
start=7 stop=: step=-1 [80, 70, 60, 50, 40, 30, 20, 10]
start=6 stop=0 step=-2 [70, 50, 30]

判断

判断元素是否存在列表中。通常使用in 、 not in ,前面说运算符时说过。

# in  &  not in
print('java' in 'java78.com') # True
print('java23' not in 'java78.com') # True
lst = ['i love','java78.com','但是','他爱','python', 520]
print('java78 in lst','java78' in lst)
print('python in lst','python' in lst)
print('python520 in lst','python520' in lst)
print('78 not in lst','78' not in lst)
print('java78 not in lst','java78' not in lst)
print('520 not in lst',520 not in lst)

输出结果如下：

True
True
java78 in lst False
python in lst True
python520 in lst False
78 not in lst True
java78 not in lst True
520 not in lst False

遍历

列表是可以迭代对象，通过 for in 循环就可以遍历列表

for item in lst:
   print(item)
#  列表遍历方式
# for 迭代变量  in 列表名：
#     操作代码块

增删改

增加：

• append(): 在列表末尾追加一个元素，列表append追加后，id（列表）不会变化，还是同一对象
• extend(): 在列表末尾至少追加一个元素，列表extend追加后，id（列表）不会变化，还是同一对象
• insert(): 在列表中任意位置增加一个元素，列表插入元素 id未发生变化，还是同一对象
• 截取方式：截取列表，再赋值新的列表，截取再重新赋值id依旧未变化

# 增加
lst = ['i love','java78.com']
print('追加前',id(lst))
# 追加
lst.append("who?")
print('追加后',lst,id(lst)) # 追加之后列表id未发生变化，还是同一列表
# 扩展
lst2=['hello','java78.com']
lst.extend(lst2)
print('扩展追加后',lst,id(lst)) # 扩展追加之后列表id未发生变化，还是同一列表
# 插入
# 指定索引位置插入数据
lst.insert(3,'it\'s me')
print('插入后',lst,id(lst)) # 列表插入元素 id未发生变化，还是同一列表
# 截取
lst[1:] = ['截取数据']
print('截取后',lst,id(lst))

输出：

追加前 44690024
追加后 ['i love', 'java78.com', 'who?'] 44690024
扩展追加后 ['i love', 'java78.com', 'who?', 'hello', 'java78.com'] 44690024
插入后 ['i love', 'java78.com', 'who?', "it's me", 'hello', 'java78.com'] 44690024
截取后 ['i love', '截取数据'] 44690024

删除：

# 删除
lst = ['i love','java78.com',10,520,'python','list','787878',123]
print('原始列表',lst,id(lst))
# remove
lst.remove('java78.com')
print('remove后',lst,id(lst))
# lst.remove('100') # remove不存在元素抛出错误 ValueError: list.remove(x): x not in list
# pop() 根据索引移除元素
lst.pop(1)
print('pop(1)',lst,id(lst))
# lst.pop(18) # pop 不存在索引抛出错误 IndexError: pop index out of range
lst.pop() # 不指定索引默认删除最后一个元素
print('pop()删除最后一个元素',lst,id(lst))
# 截取 赋值空列表，将会删除原来的值
lst[1:4] = []
print('lst[1:2] = [] - >',lst,id(lst))
# clear 清空列表
lst.clear()
print('clear 清空列表 - >',lst,id(lst))
# del 删除列表
del lst
print('del lst - >',lst,id(lst)) # 已经删除的列表，在打印它 抛出错误 NameError: name 'lst' is not defined

输出：

原始列表 ['i love', 'java78.com', 10, 520, 'python', 'list', '787878', 123] 57862696
remove后 ['i love', 10, 520, 'python', 'list', '787878', 123] 57862696
pop(1) ['i love', 520, 'python', 'list', '787878', 123] 57862696
pop()删除最后一个元素 ['i love', 520, 'python', 'list', '787878'] 57862696
lst[1:2] = [] - > ['i love', '787878'] 57862696
clear 清空列表 - > [] 57862696

修改：

# 修改
lst=[10,20,30,40]
print('修改前',lst,id(lst))
# 修改单个元素
lst[1]=1000
print('修改单个元素',lst,id(lst))
# 截取修改
lst[1:3]=[40,30,20,200]
print('截取修改',lst,id(lst))

输出：

修改前 [10, 20, 30, 40] 21817896
修改单个元素 [10, 1000, 30, 40] 21817896
截取修改 [10, 40, 30, 20, 200, 40] 21817896

排序

列表排序将会是常用操作，从大到小的排序或是其它的等等。常用的两种排序方式： sort() 方法 、 内置函数sorted()

# 排序
lst=[10,20,100,27,23,90,30,40]
print('排序前',lst,id(lst))
# sort()方法调用，默认升序
lst.sort()
print('升序排序',lst,id(lst)) # 升序后，列表id未变，还是同一列表
# 降序 reverse=True 来控制降序
lst.sort(reverse=True)
print('降序排序',lst,id(lst)) # 降序后，列表id未变，还是同一列表

# 内置函数sorted(),产生新的列表
lst1=sorted(lst)
print('内置函数sorted升序排序',lst1,id(lst1)) # 升序排序后，列表id变化，是新列表
# 内置函数sorted(), 降序 reverse=True
lst2=sorted(lst,reverse=True)
print('内置函数sorted降序排序',lst2,id(lst2))

输出：

排序前 [10, 20, 100, 27, 23, 90, 30, 40] 11594344
升序排序 [10, 20, 23, 27, 30, 40, 90, 100] 11594344
降序排序 [100, 90, 40, 30, 27, 23, 20, 10] 11594344
内置函数sorted升序排序 [10, 20, 23, 27, 30, 40, 90, 100] 11594280
内置函数sorted降序排序 [100, 90, 40, 30, 27, 23, 20, 10] 11481608

列表生成式

生成列表的公式，它的语法格式是：lst = [i*i for i in range(1,10)]

# 列表生成公式
lst = [i*i for i in range(1,10)]
print(lst)
# 使用列表生成公式需要一定格式，举例 2，4，6，8，10
lst2 = [i*2 for i in range(1,6)]
print(lst2)

输出：

[1, 4, 9, 16, 25, 36, 49, 64, 81]
[2, 4, 6, 8, 10]