Python之列表与元组

Python列表与元组

列表列表的增列表的删除列表的遍历其他操作赋值与深浅拷贝列表解析式列表生成式 元组通过索引值查找对应的元素查找元素的索引值注意:不能够增,删,改。拼接重复判断元素是否存在内置函数(最大值最小值)元组的遍历

列表

列表使用方括号[]，每个元素以逗号分隔；可以存储不同的数据类型数据。

#(1) 拼接 li1 = ["I"] li2 = ["love", "python"] print(li1 + li2) #(2)重复 print(li2 * 3) ## ['I', 'love', 'python'] ['love', 'python', 'love', 'python', 'love', 'python'] #(3)索引，切片 list1 = ['Google', 'Runoob', 1997, 2000]; list2 = [1, 2, 3, 4, 5, 6, 7 ]; print ("list1[0]: ", list1[0]) print ("list2[1:5]: ", list2[1:5]) ## list1[0]: Google list2[1:5]: [2, 3, 4, 5]

列表的增

append()

extend()

insert(index, obj)

index – 对象obj需要插入的索引位置。

obj – 要插入列表中的对象。

list1 = ['Google', 'Runoob', 'Taobao'] list1.insert(1, 'Baidu') print ('列表插入元素后为 : ', list1) ## 列表插入元素后为 : ['Google', 'Baidu', 'Runoob', 'Taobao']

demo:

li = ["city", "college"] li1 = ['Google', 'Runoob', 'Taobao'] li.extend(li1) print(li) #['city', 'college', 'Google', 'Runoob', 'Taobao'] li.append(li1) print(li) #['city', 'college', ['Google', 'Runoob', 'Taobao']] li.insert(1, li1) print(li) #['city', ['Google', 'Runoob', 'Taobao'], 'college']

列表的删除

pop()

list.pop([index=-1])# 默认最后一个 li1 = ['Google', 'Runoob', 'Taobao'] print(li1.pop()) print(li1) ## Taobao ['Google', 'Runoob']

remove(obj)

obj – 列表中要移除的对象

li1 = ['Google', 'Runoob', 'Taobao','Runoob'] li1.remove("Runoob")# 只删除第一次遇到的元素 print(li1) ## ['Google', 'Taobao', 'Runoob']

del

li1 = ['Google', 'Runoob', 'Taobao','Runoob'] del li1[2] print(li1) ## ['Google', 'Runoob', 'Runoob']

clear()

li1 = ['Google', 'Runoob', 'Taobao', 'Runoob'] li1.clear() print(li1) ## []

列表的遍历

3种：

（1）元素遍历 >>> li = ["python", "Java", "C++"] >>> for i in li: ... print(i, end = " ") ... python Java C++ （2）索引遍历 >>> li = ["python", "Java", "C++"] >>> for i in range(len(li)): ... print(li[i], end = " ") ... python Java C++ （3）枚举遍历

枚举（enumerate），对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

>>> li = ['a', 'b', 'c', 'd'] >>> for i in enumerate(li，0): ... print(i) ... (0, 'a') (1, 'b') (2, 'c') (3, 'd') >>> li ['a', 'b', 'c', 'd'] >>> for index, name in enumerate(li, 1): ... print(index, name) ... 1 a 2 b 3 c 4 d >>> for index, name in enumerate(li, 10): ... print(index, name) ... 10 a 11 b 12 c 13 d >>>

其他操作

1.统计元素的次数：count() >>> names = ['a', 'b', 'c', 'd'] >>> names.append('d') >>> names.count('d') 2 2.反转：reverse() >>> names = ['a', 'b', 'c', 'd'] >>> names.reverse() >>> names ['d', 'c', 'b', 'a'] 3.排序：sort()按照ascii码来进行排序 >>> names = ['a', 'b', 'c', 'd'] >>> names.insert(3,'&&') >>> names ['a', 'b', 'c', '&&', 'd'] >>> names.sort() >>> names ['&&', 'a', 'b', 'c', 'd'] >>> names.sort(reverse=True) >>> names ['d', 'c', 'b', 'a', '&&'] >>> names[::-1] ['&&', 'a', 'b', 'c', 'd']

赋值与深浅拷贝

la = [1, 2, 3, 4, 5, 'a', ["b1", "b2"]] lb = la print(la is lb)# Ture la[5] = "b" print(la is lb)# Ture

深浅拷贝

浅拷贝会创建新对象，内容是原对象的引用。

三种实现方法：切片、工厂函数list(li)、copy模块内的copy函数

**浅拷贝相当于我们只拷贝了一层，修改外层元素，会修改引用，让它们指向另一个位置；修改嵌套列表的元素，列表地址没有发生变化，指向的还是同一个位置。

**深拷贝拷贝对象的所有元素，包括多层嵌套的元素。因此，是开辟了一个新的内存储存区，和数据源没有关系了。

##浅拷贝## import copy la = [1, 2, 3, 4, 5, 'a', ["b1", "b2"]] lb = copy.copy(la) print(la is lb)# False la.append('test') print(la) #[1, 2, 3, 4, 5, 'a', ['b1', 'b2'], 'test'] print(lb) #[1, 2, 3, 4, 5, 'a', ['b1', 'b2']] import copy la = [1, 2, 3, 4, 5, 'a', ["b1", "b2"]] lb = copy.copy(la) la[6][0] = 'bbb' print(la) print(lb) print(la is lb) ## [1, 2, 3, 4, 5, 'a', ['bbb', 'b2']] [1, 2, 3, 4, 5, 'a', ['bbb', 'b2']] False ##深拷贝## import copy la = [1, 2, 3, 4, 5, 'a', ["b1", "b2"]] lb = copy.deepcopy(la) print(la is lb) False import copy la = [1, 2, 3, 4, 5, 'a', ["b1", "b2"]] lb = copy.deepcopy(la) print(la is lb) la[5] = ["aaa"] print(la) print(lb) ## False [1, 2, 3, 4, 5, ['aaa'], ['b1', 'b2']] [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] import copy la = [1, 2, 3, 4, 5, 'a', ["b1", "b2"]] lb = copy.deepcopy(la) print(la is lb) la[6][1] = "aaa" print(la) print(lb) ## False [1, 2, 3, 4, 5, 'a', ['b1', 'aaa']] [1, 2, 3, 4, 5, 'a', ['b1', 'b2']]

练习：打印出两个列表的交集

li1 = ["a", "b", "c", "d"] li2 = ["c", "d", "e", "f"] li3 = [] for i in li1: for j in li2: if i == j: li3.append(i) print(li3) ## ['c', 'd'] # input()函数实现往列表中添加元素，当输入”q“的时候。结束，并返回列表 list1 = [] while True: s = input("请输入：") if s == "q": break else: list1.append(s) print(list1) # 随机生成30个0-10的随机数，并统计每个出现的次数 import random list2 = [] list3 = [] for i in range(30): num1 = random.randint(0, 10) list2.append(num1) # print(list2) # print() list4 = [] for j in range(11): s = list2.count(j) list3 = [j, s] list4.append(list3) print(list4)

列表解析式

print([x for x in range(10)]) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] print([x for x in range(10) if x % 2 == 0]) #[0, 2, 4, 6, 8]

列表生成式

用来生成列表的特定的语法形式

格式：

[表达式 for 迭代对象 in 可迭代对象]

实现原理：

迭代[可迭代对象]中的每一个元素每迭代一次的结果赋值给对应的迭代元素，在通过表达式运算得到一个新的值最后所有通过表达式计算的值以一个列表的形式返回 sr = "城市学院" print([ord(x) for x in sr]) #[22478, 24066, 23398, 38498]

三目运算符：

y = 9 x = y + 1 if y > 10 else y - 1 print(x) # 8

带过滤功能格式：

[exp for iter_val in iter if if_condtion]

for嵌套：

name = ["tom", "jack", "lucy"] subject = ["python", "java", "c", "c++"] li = [] for i in name: for j in subject: li.append([i, j]) print(li) #相等于 print([[i, j] for i in name for j in subject])

元组

有序

可以重复

不可更改(列表可以改变)

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

##单元素元组创建，需要在单元素后面添加逗号 tp1 = ("abc") print(type(tp1))#<class 'str'> tp2 = ("abc",) print(type(tp2))#<class 'tuple'>

多元素创建，包含多种数据类型。

>>> tl = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18})

同字符串和列表，元组也可以进行拼接、重复、切片。

通过索引值查找对应的元素

>>> tl = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18}) >>> tl[4] {'name': 'Tom', 'age': 18} >>> tl[-1] {'name': 'Tom', 'age': 18} >>> tl[::-2] ({'name': 'Tom', 'age': 18}, ['h', 'u', 'n', 'a', 'n'], 1)

查找元素的索引值

>>> tl = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18}) >>> tl.index("hunan") 1 >>> tl.index("hunan", 1, 4) 1 >>>

注意:不能够增,删,改。

元组是不可变的数据类型:

>>> tl = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18}) >>> tl[0] = 0 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment

注意到tl里有个列表，那么这个列表中的元素是否可以更改？

>>> tl = (1, "hunan", ['h', 'u', 'n', 'a', 'n'], ('I', 'love', 'python'), {"name": "Tom", "age": 18}) >>> tl[2] ['h', 'u', 'n', 'a', 'n'] >>> tl[2][2] = 'N' >>> tl (1, 'hunan', ['h', 'u', 'N', 'a', 'n'], ('I', 'love', 'python'), {'name': 'Tom', 'age': 18}) >>>

拼接

>>> t1 = ('a', 'b', 'c') >>> t2 = ('d', 'e', 'f') >>> t1 + t2 ('a', 'b', 'c', 'd', 'e', 'f') >>>

重复

>>> t1 * 3 ('a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c') >>>

判断元素是否存在

>>> t1 = ('a', 'b', 'c') >>> 'a' in t1 True >>> 'a' not in t1 False >>>

内置函数(最大值最小值)

>>> t1 = ('a', 'b', 'c') >>> max(t1) 'c' >>> min(t1) 'a' >>>

元组的遍历

1）值遍历

tp = ('Python', 'Java', 'C++') for i in tp: print(i, end = " ") # Python Java C++

2）索引遍历

tp = ('Python', 'Java', 'C++') for i in range(len(tp)): print(tp[i], end = " ") # Python Java C++

3）索引-值，遍历

枚举（enumerate），对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

tp = ('Python', 'Java', 'C++') for index, value in enumerate(tp): print(index, ':', value) # 0 : Python # 1 : Java # 2 : C++ tp = ('Python', 'Java', 'C++') for index, value in enumerate(tp, 6): print(index, ':', value) 6 : Python 7 : Java 8 : C++

print(index + values)

二维元组

>>> tp = ((1, 2, 3), (4, 5, 6), (7, 8, 9)) >>> tp[1][1] 5

三维元组

>>> tp = (((1, 2, 3), (4, 5, 6), (7, 8, 9)), ... ((1, 2, 3), (4, "Hunan", 6), (7, 8, 9)), ... ((1, 2, 3), (4, 5, 6), (7, 8, 9))) >>> tp[1][1][1] 'Hunan' >>>