列表

列表使用方括号括起来的[]，每个元素以逗号分隔；

可以储存不同的数据类型

特点

是一个有序的可以重复的可变类型

创建

创建空列表

li = [] print(type(li)) <class 'list'>

创建多元列表

li = [1, 2, 3, "abcd", "City", "College", ["I", "love", "python"]]

强转

sr = "abcd" li = list(sr) print((li,type(li)))

（1）拼接

li1 = ["I"] li2 = ["love",'python'] print(li1+li2)

（2）重复

print(li2*3)

（3）索引（偏移）[],切片[:],[::]

li = ["c", "i", "t", "y", "City", "College", "Zhejiang"] print(len(li)) print(li[0], li[-7]) print(li[:5]) print(li[::-1]) print(li[5][2]) 7 c c ['c', 'i', 't', 'y', 'City'] ['Zhejiang', 'College', 'City', 'y', 't', 'i', 'c'] l

（4）列表的常见操作

增删改查

增

append()

li = ["City", "College"] li1 = ["a", "b", "c"] li.append(li1) print(li) ['City', 'College', ['a', 'b', 'c']]

extend()

li = ["City", "College"] li1 = ["a", "b", "c"] li.extend(li1) print(li) ['City', 'College', 'a', 'b', 'c']

insert(),按照索引添加

li = ["City", "College"] li1 = ["a", "b", "c"] li.extend(li1) print(li) li.insert(1,li1) print(li)

2.删

pop()

如果不指定索引，默认删除最后一个元素删除指定索引对应的元素 li = ["a","b","c","d","e"] print(li.pop()) print(li) e ['a', 'b', 'c', 'd'] li = ["a","b","c","d","e"] print(li.pop(2)) print(li) c ['a', 'b', 'd', 'e']

remove()

删除第一次遇到的指定元素 li = ["a", "b", "c", "d", "e", "city", "e"] print(li.remove("e")) print(li) None ['a', 'b', 'c', 'd', 'city', 'e']

del

li = ["a", "b", "c", "d", "e", "city", "e"] del li[5] print(li)

clear()

li = ["a", "b", "c", "d", "e", "city", "e"] li.clear() print(li) []

3.查

索引，切片

遍历

（1）元素遍历

li = ["a", "b", "c"] for i in li: print(i) a b c

(2)索引遍历

li = ["a", "b", "c"] for i in range(len(li)): print(li[i]) a b c

（3）枚举遍历

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

li = ["a", "b", "c"] for i in enumerate(li): print(i) (0, 'a') (1, 'b') (2, 'c') li = ["a", "b", "c"] for i in enumerate(li,1): print(i) (1, 'a') (2, 'b') (3, 'c') li = ["a", "b", "c"] for index, value in enumerate(li, 1): print(index, value) 1 a 2 b 3 c li = ["a", "b", "c"] for index, value in enumerate(li[:2], 1): print(index, value) 1 a 2 b

堆和栈，用列表实现

其他操作

计数，count（），查找元素出现的次数

反转，reverse（）必须同一种数据类型

li = list("abcd") print(li) li.reverse() print(li) ['a', 'b', 'c', 'd'] ['d', 'c', 'b', 'a']

排序，sort（）

按照ASCII码排序

li = list("abcd") print(li) li.reverse() print(li) li.sort(reverse=True) print(li) ['a', 'b', 'c', 'd'] ['d', 'c', 'b', 'a'] ['d', 'c', 'b', 'a'] li1 = ["a", "b", "c", "d"] li2 = ["c", "d", "e", "f"] # 输出，两个表的交集 for i in li1: for j in li2: if i == j: print(i) c d

input（）函数实现往空列表中添加元素，但输入“q“的时候，结束输入，并返回列表

li = [] while True: x = input() if x == "q": break li.append(x) print(li)

随机生成30个0-10的随机整数，并统计每个数出现的个数，

返回结果的形式为[[0,3],[1,4],…,[10,5]]

import random li = [] for i in range(0, 11): li.append([i]) li[i].append(0) for i in range(0, 30): a = random.randint(0, 10) for j in range(0, 11): if a == j: li[j][1] += 1 print(li) import random #li.count（x）是计算列表中x的个数 rand_int = [] result_li = [] for i in range(30): rand_int.append(random.randint(0, 10)) print(rand_int) sum = 0 for i in range(0, 11): result_li.append([i, rand_int.count(i)]) sum += rand_int.count(i) print(result_li) print(sum)

赋值与深浅拷贝

赋值

赋值是对对象的引用

la = [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] lb = la print(la) print(lb) print(id(la), id(lb)) print(la is lb) la[5] = "aaa" print(la) print(lb) [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] 4326256584 4326256584 True [1, 2, 3, 4, 5, 'aaa', ['b1', 'b2']] [1, 2, 3, 4, 5, 'aaa', ['b1', 'b2']]

深浅拷贝

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

三种实现方法：

切片方法[:]工厂函数list(li)copy模块内的copy函数。 la = [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] lb = la lb2 = la[:] print(id(la), id(lb2)) import copy lb_cpoy = copy.copy(la) print(id(la), id(lb_cpoy)) la.append('test')#添加原子类型，不会影响lb_cpoy print(la) print(lb_cpoy) 4326256584 4328216136 4326256584 4328467720 [1, 2, 3, 4, 5, 'a', ['b1', 'b2'], 'test'] [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] import copy lb_cpoy = copy.copy(la) print(id(la), id(lb_cpoy)) la.append('test') la[5] = "aaa"#不变 la[6][0]="bbb"#会变 print(la) print(lb_cpoy) 4326256584 4328216136 4326256584 4328467912 [1, 2, 3, 4, 5, 'aaa', ['bbb', 'b2'], 'test'] [1, 2, 3, 4, 5, 'a', ['bbb', 'b2']]

深拷贝

import copy la = [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] lb_deepcopy = copy.deepcopy(la) print(la, id(la)) print(lb_deepcopy, id(lb_deepcopy)) la[5] = ["aaa"] la[6][1] = ["aaa"] print(la) print(lb_deepcopy) [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] 4328466568 [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] 4337123272 [1, 2, 3, 4, 5, ['aaa'], ['b1', ['aaa']]] [1, 2, 3, 4, 5, 'a', ['b1', 'b2']]

对象的引用

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

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

列表解析式

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

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

x = "城市学院" print([ord(x) for x in x]) 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]) [['Tom', 'Python'], ['Tom', 'Java'], ['Tom', 'C'], ['Tom', 'C++'], ['Jack', 'Python'], ['Jack', 'Java'], ['Jack', 'C'], ['Jack', 'C++'], ['Lucy', 'Python'], ['Lucy', 'Java'], ['Lucy', 'C'], ['Lucy', 'C++']] [['Tom', 'Python'], ['Tom', 'Java'], ['Tom', 'C'], ['Tom', 'C++'], ['Jack', 'Python'], ['Jack', 'Java'], ['Jack', 'C'], ['Jack', 'C++'], ['Lucy', 'Python'], ['Lucy', 'Java'], ['Lucy', 'C'], ['Lucy', 'C++']]

格式：

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

实现原理：

迭代[可迭代对象]中的每一个元素每迭代一次的结果赋值给对应的迭代元素，再通过表达式运算得到一个新的值最后所有通过表达式计算的值以一个列表的形式返回

三目运算符

y = 12 x = y + 1 if y > 10 else y - 1 print(x)

带过滤功能格式

[exp for iter_val in iter if if_condyion]