Python之列表

列表:有序的可变的元素集合,列表是最常见的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]

 
 
 
 
 
 
 
 


原文地址:https://www.cnblogs.com/cxq0017/p/9394103.html