python基础04——列表:list及元组:tuple

1 列表 list,有序可变序列

列表是Python内置可变序列之一，是包含若干元素的有序连续内存空间。

列表元素放在一对中括号中，每个元素用逗号隔开，每个元素类型可以不同，没有长度限制。
当列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有缝隙（自动内存管理）。

1.1 创建

1.1.1 使用[ ]创建

1.1.2 使用list创建

1.1.3 使用列表推导式创建

L1 =[i for i in range(10)]
L1
#out:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

1.2 查询

1.2.1 索引 L[0]

L1 = [1,2,3,4]
L1[2]
#out：3

若列表中嵌套列表，应先找到里层列表所在位置，然后再取位置上的数据

#想要把4取出来，使用L2[3] 取出列表[4,5],然后再按照索引取
L2 = [1,2,3,[4,5],6]
L2[3][0]
#out:4

1.2.2 切片:左闭右开 L1[0:6:2]

mylist[start:stop:step],切片包含start,不包含stop;其中,start,stop,step均为可选参数, 而且都可以为负数 列表的下标既可以用正数表示也可以用负数表示:

L1 = [1,2,3,4,5,6,7,8]
L1[0:6:2]
#out:[1, 3, 5]

1.2.3 L.count(): 计数

返回列表中指定元素的出现次数

1.2.4 len(): 长度

L = [1,2,2,3,3,4]
len(L)
#out:6

1.2.5 L.index(): 返回首次出现索引，如果没有出现则抛出异常

1.2.6 in 和 not in

1.3 修改

​ 通过元素的索引位置来修改元素
​ 切出来几个元素,重新赋值就要赋值几个元素

1.4 增加与删除

动的元素越少效率越高，append与insert相比，一般用的是append

1.4.1 增加

1.4.1.1 append:增加单个元素

将对象追加到列表的末尾，原地操作

list1 = [1,2,2,3,3,4]
list1.append(5) #返回值为空，原地操作
list1
#out:[1, 2, 2, 3, 3, 4, 5]

1.4.1.2 extend：列表拼接

list1 = [1,2,3]
list2 = [4,5,6]
list1.extend(list2)
list1
#out:[1, 2, 3, 4, 5, 6]

注意： extend中添加的应该是可迭代的内容，整数不可迭代，不能添加

1.4.1.3 insert:在指定位置前插入元素

insert(index,object)在指定位置index前插入元素object

list1 = [1,2,3] #元素放在 连续 内存空间中
list1.insert(1,True) #返回值为空，在指定位置插元素时，需要将其他元素往后挪动，腾开位置
list1
#out: [1, True, 2, 3]

1.4.1.4 +:拼接

L1 = [4,5,6]
L2 = [7,8,9]
L1 + L2
#out:[4, 5, 6, 7, 8, 9]

1.4.1.5 *:复制

L1 = [4,5,6]
L1 * 3
#out:[4, 5, 6, 4, 5, 6, 4, 5, 6]

1.4.2 删除

1.4.2.1 L.remove():删除首次出现的元素

list1 = [1,2,3,2,4]
list1.remove(2)
list1
#Out: [1, 3, 2, 4]

1.4.2.2 L.pop(): 按位置删

pop相当于取出+删除，pop会返回要删除的位置上的元素并且删除。

list1 = [1,2,3,4,5]
list1.pop(2)
#Out: 3

1.4.2.3 L.clear 清空列表

list1.clear()
list1
#Out: []

1.4.2.4 del:用于list列表操作，删除一个或连续几个元素

list1 = [1,True,2,3,4,5,'a',1,2,3,4,5]
del list1[0]
list1
#Out: [True,2,3,4,5,'a',1,2,3,4,5]

list1 = [1,True,2,3,4,5,'a',1,2,3,4,5]
del list1[2:4]
list1
#Out: [1,True,4,5,'a',1,2,3,4,5]

1.5 排序

1.5.1 升序 L.sort()

升序
注意：中文排序看的是unicode编码

list1 = ['中国','美国','法国'] #中文排序看unicode编码
list1.sort()
list1
#out： ['中国', '法国', '美国']

1.5.2 降序 L.sort(reverse= True)

1.5.3 reverse 对原列表元素进行逆置

list1 = [1,2,3,2,4]
list1.reverse() #原地排序
list1
#out： [4, 2, 3, 2, 1]

list1 = [1,2,3,2,4]
list2 = list(reversed(list1)) #reversed 新生成
list2
#out: [4, 2, 3, 2, 1]

1.6内置函数

1.6.1 max 最大、min 最小

list1 = [1,2,3,2,4]
max(list1)
#out: 4

列表中既有字符串又有数字，是不能进行比较的

1.6.2 sum: 求和

list1 = [1,2,3,2,-1]
sum(list1)
#out: 7

1.6.3 zip：zip对象，将列表元素一一关联

list1 = [1,2,3]
list2 = ['中国','美国','法国']
list(zip(list1,list2))
#out: [(1, '中国'), (2, '美国'), (3, '法国')]

1.6.4 enumerate：枚举对象，将索引和值关联

list2 = ['中国','美国','法国']
list(enumerate(list2))
#out: [(0, '中国'), (1, '美国'), (2, '法国')]

1.7 列表推导式

• 实现嵌套列表的平铺

L =[[1,2,3],[4,5,6]]
L1 = [j  for i in L for j in i]# 二维列表的平铺
L1
#out: [1, 2, 3, 4, 5, 6]

• 实现多序元素的任意组合

#生成所有的个位和十位不一样的两位数
[i*10+j for i in range(1,10) for j in range(10) if i !=j ]

• 实现向量的运算

L1 = [4,5,6]
L2 = [7,8,9]

[L1[i]+ L2[i] for i in range(3)]
#out: [11, 13, 15]

1.8 深拷贝和浅拷贝

1.8.1 浅拷贝,嵌套列表受影响 L.copy()

1.8.2 深拷贝copy.deepcopy(L)

2 元组 tuple,有序不可变序列

2.1 创建

一种不可变的有序容器,其中的元素有位置上的先后顺序,标志性符号是圆括号和逗号( , )

2.2 适用场景

• 元组比列表操作速度要快，适合遍历。
• 如果数据只可以查，不需要被修改，要“保护起来”，那么可以适用元组。
• 由于不可变属性，在很多方法和操作中只能用元组作为结构的一部分，比如字典中的key。（没有嵌套列表的元组才可以）

2.3 查询

2.3.1 索引 t[0],获取单个

tp1 = (1,2,3,4)
tp1 [2]
#out：3

2.3.2 切片:左闭右开

2.3.3 t.count(): 计数

返回元组中指定元素的出现次数

tp1 = (1,2,3,4,5,4)
tp1.count(4)
#out: 2

2.3.4 len(): 长度

tp2 = (1,2,2,3,3,4)
len(tp2)
#out:6

2.3.5 t.index(): 返回首次出现索引，如果没有出现则抛出异常

2.3.6 in 和 not in

2.4 元组不支持原地修改

元组是不可变序列，不支持原地修改和删除
元组中嵌套列表，该列表可以修改

2.5 运算符：+/ *

1. tp1+tp2

tp1 = (1,2,3)
tp2 = (7,8,9)
tp1 + tp2
#out: (1, 2, 3, 7, 8, 9)

2. tp1*n

tp1 = (1,2,3,list('abc'))
tp1*3
#out: (1, 2, 3, ['a', 'b', 'c'], 1, 2, 3, ['a', 'b', 'c'], 1, 2, 3, ['a', 'b', 'c'])

2.6 生成器表达式

生成器表达式存在的意义：
生成器表达式：可迭代对象，保存的是生成数据的方法，会使得代码的效率更高。
列表推导式：保存的是数据本身（占用空间较多）