列表：有序的可变的元素集合，列表是最常见的Python数据类型，它可以作为一个方括号内的逗号分隔出现。
列表的数据项不需要具有相同的类型。
创建一个列表，只要把逗号分隔的不同数据项使用方括号括起来即可，如下所示：
list1 = ['Google', 'baidu', 1997, 2000]
list2 = [1, 2, 3, 4, 5]
list3 = ["a", "b", "c", "d"]
与字符串的索引一样，列表索引从0开始，列表可以进行截取、组合等
列表的定义方式2：
# 1)列表生成式
# range(stop) [0, 1, 2...,stop-1]
# range(start, stop[,step]) [start, start + step, start + 2*step..., < stop]
# step默认值是1
nums = range(100)
# 为了防止生成的列表没有被使用，python3做了一些改变，不会立即生成列表
# 生成1~100之间的所有奇数
nums = range(1, 100, 2)
# 2)列表推导式 从一个list推导出另外一个list
1 # 原始方式::
2 nums = [1, 2, 3, 4, 5]
3 resultList = []
4
5 for num in nums:
6 resultNum = num**2
7 resultList.append(resultNum)
8
9 print("resultList:: ", resultList)
输出结果：resultList:: [1, 4, 9, 16, 25]
# 列表推导式::
# 语法:: [表达式 for 变量 in 列表]
# [表达式 for 变量 in 列表 if条件]
1 # for循环里面得出的num值取幂次方
2 resultList = [num**2 for num in nums]
3 print(resultList)
4
5 resultList = [num**2 for num in nums if num % 2 != 0]
6 print(resultList)
输出结果：
[1, 4, 9, 16, 25]
[1, 9, 25]
列表增加的常用操作
1：append（）
# append() 方法用于在列表末尾添加新的对象。
# append() 方法用于在列表末尾添加新的对象。
# list.append(obj)
# 参数::
# obj -- 添加到列表末尾的对象。
# 返回值::
# 该方法无返回值，但是会修改原来的列表。
1 list1 = ["Google", "Jd", "TaoBao"]
2 list1.append("baidu")
3 print("更新后的列表:: ", list1)
输出结果：更新后的列表:: ['Google', 'Jd', 'TaoBao', 'baidu']
1 AList = []
2 num = [2]
3 AList.append(num)
4 print("id(num) == id(AList[0]):: ", id(num) == id(AList[0]))
5 print("num的值没有发生变化的时候:: ", id(num), id(AList[0]), AList)
输出结果：
id(num) == id(AList[0]):: True
num的值没有发生变化的时候:: 37290792 37290792 [[2]]
# 如上例所示，当 num 发生变化时(前提是 id(num) 不发生变化），
# Alist 的内容随之会发生变化。往往会带来意想不到的后果，想避免这种情况，可以采用深拷贝解决：
1 num.append(5)
2 print("当num的值发生变化的时候::", id(num), id(AList[0]), AList)
输出结果为：
当num的值发生变化的时候:: 37290792 37290792 [[2, 5]]
# 可见当num发生变化的时候，AList也发生了变化，这有可能不是我们想要的结果
2：insert（）
# insert() 函数用于将指定对象插入列表的指定位置
# insert()方法语法：
# list.insert(index, obj)
# 参数::
# index -- 对象obj需要插入的索引位置。
# obj -- 要插入列表中的对象。
# 返回值::
# 该方法没有返回值，但会在列表指定位置插入对象。
1 List1 = ['Google', 'Runoob', 'Taobao']
2 List1.insert(1, 'Baidu')
3 print("insert插入后的列表结果:: ", List1)
输出结果：
insert插入后的列表结果:: ['Google', 'Baidu', 'Runoob', 'Taobao']
3：extend（）
# extend() 函数用于在列表末尾一次性追加另一个序列中的多个值
# extend()方法语法：
# list.extend(seq)
# 参数::
# seq -- 元素列表。
# 返回值::
# 该方法没有返回值，但会在已存在的列表中添加新的列表内容。
1 List1 = ['Google', 'Runoob', 'Taobao']
2 List2 = range(5)
3 List1.extend(List2)
4 print("扩展后的列表:: ", List1)
输出结果：
扩展后的列表:: ['Google', 'Runoob', 'Taobao', 0, 1, 2, 3, 4]
# extend与append的区别
AList = ['w', 'i', 's', 't'] AList.extend(['q', 'y']) print("AList扩展之后的结果:: ", AList) BList = ['w', 'i', 's', 't'] BList.append(['q', 'y']) print("BList扩展之后的结果:: ", BList)
输出结果：
AList扩展之后的结果:: ['w', 'i', 's', 't', 'q', 'y']
BList扩展之后的结果:: ['w', 'i', 's', 't', ['q', 'y']]
# extend 与 append 方法的相似之处在于都是将新接收到参数放置到已有列表的后面。而 extend 方法只能接收 list，且把这个 list
# 中的每个元素添加到原 list 中。
# 而 append 方法可以接收任意数据类型的参数，并且简单地追加到 list 尾部。
4：乘法运算
1 # ['Hi!'] * 4 = ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 重复 2 List1 = ['Hello'] 3 print("List1的乘法运算:: ", List1*4)
输出结果：
List1的乘法运算:: ['Hello', 'Hello', 'Hello', 'Hello']
5：加法运算
1 # 加法运算 2 # [1, 2, 3] + [4, 5, 6] = [1, 2, 3, 4, 5, 6] 组合 3 AList = ['a', 'b', 'c'] 4 BList = ['d', 'e', 'f', 'g'] 5 print("AList + BList:: ", AList + BList)
输出结果：
AList + BList:: ['a', 'b', 'c', 'd', 'e', 'f', 'g']
列表的删除常用操作：
1：del
# del语句 可以删除一个指定的元素(对象)
# 语法::
# del 指定元素
# 注意：
# 可以删除整个列表
# 删除一个变量
# 也可以删除某个元素
1 List1 = ['Google', 'Baidu', 1997, 2000] 2 print("原始列表:: ", List1) 3 4 del List1[1] 5 print("删除第二个元素:: ", List1) 6 # 可以这样直接删除一个变量 7 num = 888 8 del num 9 # 删除整个列表 10 del List1
输出结果：
原始列表:: ['Google', 'Baidu', 1997, 2000]
删除第二个元素:: ['Google', 1997, 2000]
2:pop()
# pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
# pop()方法语法：
# list.pop([index=-1]])
# 参数::
# index -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。
# 返回值::
# 该方法返回从列表中移除的元素对象。
1 List1 = ['Google', 'Baidu', 'Taobao'] 2 List1.pop() 3 print("列表现在为:: ", List1) 4 List1.pop(1) 5 print("列表现在为:: ", List1) 6 7 # 可以通过以下方法打印pop()函数来显示返回值 8 List1 = ['Google', 'Baidu', 'Taobao'] 9 ListPop = List1.pop(1) 10 print("删除的项为:: ", ListPop) 11 print("列表现在为:: ", List1)
输出结果：
列表现在为:: ['Google', 'Baidu']
列表现在为:: ['Google']
删除的项为:: Baidu
列表现在为:: ['Google', 'Taobao']
3：remove（）
# remove() 函数用于移除列表中某个值的第一个匹配项。
# remove()方法语法：
# list.remove(obj)
# 参数::
# obj -- 列表中要移除的对象
# 返回值::
# 该方法没有返回值但是会移除两种中的某个值的第一个匹配项。
1 List1 = ['Google', 'Baidu', 'Taobao'] 2 List1.remove('Baidu') 3 print("现在的列表为:: ", List1) 4 List1.remove('Google') 5 print("列表现在为:: ", List1)
输出结果：
现在的列表为:: ['Google', 'Taobao']
列表现在为:: ['Taobao']
# 注意，如果要删除的元素列表里面不存在，程序会报错，所以在删除元素的时候，最好判定以下
# 这个元素是否存在于这个列表里面
# 另外注意循环内删除列表元素所带来的坑
1 nums = [1, 2, 2, 3, 4, 2, 5, 2] 2 # 删除列表里面所有为2的元素 3 for num in nums: 4 if num == 2: 5 nums.remove(num) 6 7 print("删除所有2的元素的列表为:: ", nums)
输出结果：删除所有2的元素的列表为:: [1, 3, 4, 5, 2]
此时我们发现我们并没有删除完所有为2的元素
那么用什么方式避免这种问题呢？两种方式：
1）：
1 while 2 in nums: 2 nums.remove(2) 3 4 print(nums)
2）
1 # 列表推导式 2 nums = [i for i in nums if not(i == 2)] 3 print(nums)
更新修改列表中的值
1）：查询操作index()
# index() 函数用于从列表中找出某个值第一个匹配项的索引位置。
# index()方法语法：
# list.index(obj)
# 参数::
# obj -- 查找的对象。
# 返回值::
# 该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。
1 List1 = ['Google', 'Baidu', 'Taobao'] 2 print("Baidu的索引值:: ", List1.index('Baidu')) 3 print("Taobao的索引值:: ", List1.index('Taobao'))
输出结果：
Baidu的索引值:: 1
Taobao的索引值:: 2
2）count（）
# count() 方法用于统计某个元素在列表中出现的次数。
# count()方法语法：
# list.count(obj)
# 参数::
# obj -- 列表中统计的对象。
# 返回值::
# 返回元素在列表中出现的次数。
1 AList = [123, 'Google', 'Taobao', 'Baidu', 123, 456] 2 print("123元素的个数:: ", AList.count(123)) 3 print("456元素的个数:: ", AList.count(456))
输出结果：
123元素的个数:: 2
456元素的个数:: 1
3）获取多个元素
items[start:end:step]
1 AList = [123, 'Google', 'Taobao', 'Baidu', 123, 456] 2 pic = AList[::] 3 print("切片:: ", pic) 4 5 pic = AList[1:4:2] 6 print("pic:: ", pic)
输出结果：
切片:: [123, 'Google', 'Taobao', 'Baidu', 123, 456]
pic:: ['Google', 'Baidu']
列表的遍历操作
1）方式1 根据元素进行遍历
for item in list
1 values = ["a", "b", "a", "c"] 2 3 currentIndex = 0 4 for v in values: 5 print(v) 6 print("列表元素对应的索引值::", values.index(v, currentIndex)) 7 currentIndex += 1
输出结果：
a
列表元素对应的索引值:: 0
b
列表元素对应的索引值:: 1
a
列表元素对应的索引值:: 2
c
列表元素对应的索引值:: 3
2）方式2 根据索引进行遍历
for index in range(len(list)):
1 values = ['google', 'baidu', 'sogou', 'baidu'] 2 3 for index in range(len(values)): 4 print("index索引对应的值:: ", index, values[index])
输出结果：
index索引对应的值:: 0 google
index索引对应的值:: 1 baidu
index索引对应的值:: 2 sogou
index索引对应的值:: 3 baidu
3）方式3 创建对应的枚举对象，遍历枚举对象
枚举对象概念：通过枚举函数，生成一个新的对象
枚举对象作用：用于将一个可遍历的数据对象(如列表、元组或字符串)组合一个索引序列。同时列出数据下标和数据
语法：enumerate(sequence, [start=0]) sequence:一个序列，迭代器或其他支持迭代对象
start:下标起始位置
values = ['a', 'b', 'c', 'd', 'e', 'f']
# 1:先根据列表，创建一个枚举对象
enumerate(values)
# 想要打印出来结果可以这样写
# print(list(enumerate(values)))
（结果为：[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e'), (5, 'f')]）
# 遍历整个枚举对象
# 你可以这样遍历
# for tupValues in enumerate(values):
# print(tupValues[0])
# print(tupValues[1])
1 nums = (0, 'baidu') 2 idx, value = nums 3 print(idx) 4 print(value)
输出结果为：
0
baidu
# 所以我们也可以这样遍历枚举对象
# for tupValues in enumerate(values):
# idx, value = tupValues
# print(idx)
# print(value)
1 for idx, value in enumerate(values): 2 print(idx, "::", value)
输出结果为：
0 :: a
1 :: b
2 :: c
3 :: d
4 :: e
5 :: f
迭代器介绍
# 什么是迭代
# 是访问集合元素的一种方式 按照某种顺序逐个访问集合中的每一项
# 什么是可迭代对象
# 能够被迭代的对象，称之为可迭代对象 判定依据：能作用于for in
# 判定方法:import collections
# isinstance(obj, collections.Iterable)
# 判定一个对象是不是可迭代对象
1 import collections 2 nums = [1, 2, 3] 3 print(isinstance(nums, collections.Iterable))
输出结果：True
# 迭代器:是可以记录遍历位置的对象 从第一个元素开始，往后通过next()函数,进行遍历，只能往后，不能往前
# 判定依据：能作用于next()函数
# 判定方法：import collections
# isinstance(obj, collections.Iterator)
# 注意:迭代器也是可迭代对象，所以也可以作用于for in
1 nums = [1, 2, 3] 2 result = isinstance(nums, collections.Iterator) 3 print("是否是个迭代器:: ", result) 4 # 说明nums是个可迭代对象，单不是一个迭代器 5 6 # 生成一个可迭代器 7 iteratorNum = iter(nums) 8 print(iteratorNum)
输出结果：
是否是个迭代器:: False
<list_iterator object at 0x020D5390>
# 为什么会产生迭代器
# 1:使用迭代器不要求事先准备好整个迭代过程中的所有元素。迭代器仅仅在迭代到某个元素时才计算该元素，
# 而在这之前或之后元素可以不存在或者被销毁。因此迭代器适合遍历一些数量巨大甚至无限的序列。
# 2:提供了一个统一的访问集合的接口， 可以把所有的可迭代对象，转换成迭代器进行使用
1 values = ['baidu', 'google', 'sogou'] 2 # 创建一个迭代器 3 it = iter(values) 4 5 # 遍历迭代器 6 while True: 7 try: 8 x = next(it) 9 print(x) 10 except StopIteration: 11 break 12 13 # 注意:如果取出完毕，再继续取得话，则会报错 StopIteration
输出结果：
baidu
google
sogou
# 迭代器一般不能多次迭代
1 # 例如下面 2 nums = [1, 2, 3, 4] 3 it1 = iter(nums) 4 5 for v in it1: 6 print(v) 7 8 print("---------------------") 9 for v in it1: 10 print(v) 11 # 可以看出第二次访问迭代器的时候没有任何数据了
输出结果：
1
2
3
4
---------------------
列表的判定操作
# 元素 in 列表
# 元素 not in 列表
1 values = [1, 2, 3, 4, 5] 2 print(6 in values) 3 print(6 not in values)
输出结果：
False
True
# cmp() 方法用于比较两个列表的元素。
# cmp()方法语法：
# cmp(list1, list2)
# 参数:
# list1 -- 比较的列表。
# list2 -- 比较的列表。
# 返回值:
# 如果比较的元素是同类型的,则比较其值,返回结果。
# 如果两个元素不是同一种类型,则检查它们是否是数字。
# 如果是数字,执行必要的数字强制类型转换,然后比较。
# 如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")
# 否则,通过类型名字的字母顺序进行比较。
# 如果有一个列表首先到达末尾,则另一个长一点的列表"大"。
# 如果我们用尽了两个列表的元素而且所 有元素都是相等的,那么结果就是个平局,就是说返回一个 0
# Python 3.X 的版本中已经没有 cmp 函数，如果你需要实现比较功能，需要引入 operator 模块，适合任何对象,
# Python3.x 可以直接使用> < == 来比较两个列表的大小
1 List1 = ['a', 'b', 'c'] 2 List2 = ['a', 'd'] 3 4 print cmp(List1, List2) 5 6 list3, list4 = [456, 'xyz'], [123, 'abc'] 7 8 print cmp(list3, list4) 9 10 11 list5 = [1, 2, 3] 12 list6 = [1, 2, 3] 13 14 print cmp(list5, list6)
输出结果：
-1
1
0
1 List1 = [456, 'abc'] 2 List2 = [123, 'abd'] 3 4 result = List1 > List2 5 print("List1 > List2:: ", result) 6 7 List3 = [1, 2, 3] 8 List4 = [1, 2, 3] 9 result = List3 == List4 10 print("List3 == List4:: ", result)
输出结果：
List1 > List2:: True
List3 == List4:: True
列表的排序操作
# 方式1 内建函数 可以对所有可迭代对象进行排序
# sorted() 函数对所有可迭代的对象进行排序操作。
# sorted 语法：
# sorted(iterable[, cmp[, key[, reverse]]])
# 参数说明:
# iterable -- 可迭代对象
# cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
1 a = [5, 7, 6, 3, 4, 1, 2] 2 b = sorted(a) 3 # 可以保留原列表 4 print("a列表信息:: ", a) 5 print("b列表信息:: ", b)
输出结果：
a列表信息:: [5, 7, 6, 3, 4, 1, 2]
b列表信息:: [1, 2, 3, 4, 5, 6, 7]
# sorted()的高级用法。
# 有时候，我们要处理的数据内的元素不是一维的，而是二维的甚至是多维的，那要怎么进行排序呢？
# 这时候sorted()的key参数就派上用场了，key参数可传入一个自定义函数。
1 List = [('b', 1), ('a', 2), ('c', 4), ('d', 3), ('e', 5)] 2 def getKey(x): 3 return x[1] 4 5 result = sorted(List, key=getKey, reverse=True) 6 print(result)
输出结果：
[('e', 5), ('c', 4), ('d', 3), ('a', 2), ('b', 1)]
# 方式2 列表对象方法
# sorted()和sort()的主要区别在于，list.sort()是对已经存在的列表进行操作，进而可以改变进行操作的列表
# 而内建函数sorted()返回的是一个新的list,而不是在原来的基础上进行操作的。
# 另一点区别就是：sorted()对所有可迭代对象排序，而sort只能操作列表
1 L = [1, 3, 2, 5, 7, 4] 2 result = L.sort() 3 print("原来的L信息::", L) 4 print("result接收到的结果:: ", result) 5 6 l = [('xq', 18), ('xq2', 16), ('xq1', 17), ('xq3', 15)] 7 l.sort() 8 print("l排序后的结果:: ", l) 9 10 def getKey1(x): 11 return x[1] 12 13 l.sort(key=getKey1) 14 print("根据key值排序的结果:: ", l)
输出结果：
原来的L信息:: [1, 2, 3, 4, 5, 7]
result接收到的结果:: None
l排序后的结果:: [('xq', 18), ('xq1', 17), ('xq2', 16), ('xq3', 15)]
根据key值排序的结果:: [('xq3', 15), ('xq2', 16), ('xq1', 17), ('xq', 18)]
列表的乱序和反转
# 可以随机打印一个列表
# 导入random模块
# import random
# random.shuffle(list)
1 import random 2 3 l = [1, 2, 3, 4, 5] 4 res = random.shuffle(l) 5 print(l, res) 6 # 由此我们可以看到random.shuffle()是直接改变原有列表
输出结果：
[2, 5, 1, 3, 4] None
# 列表反转
# list.reverse()
# 切片反转
# l[::-1]
1 l = [1, 2, 3, 4, 5] 2 res = l.reverse() 3 print("列表的反转:: ", res, l) 4 5 res = l[::-1] 6 print("切片反转:: ", res, l)
输出结果：
列表的反转:: None [5, 4, 3, 2, 1]
切片反转:: [1, 2, 3, 4, 5] [5, 4, 3, 2, 1]