python之列表、元组、集合手册

Content

•  列表操作
• 元组操作
• 集合操作

列表操作 

 列表是python中一种可变可修改的数据类型，其可以存储所有的数据类型的信息。   ---- [ ]   中括号  

• 列表的创建

　　列表有两种创建方式：   

L = [1, 3, 4, 'Hello', True, print('3')]      # 通过 [] 的方式创建列表
L = []     # 也支持直接生成一个空的列表

s = 'hello world'
L1 = list(s)     # 也可以通过list关键字创建列表，只不过这样生成的列表L1 中的字符串被分割， 如下图第二行所示
6 

 列表中如果包含 print('3')这样的内容，运行后会直接打印出3; 如果print(L)，打印出的结果该位置显示的是None。

•  列表的索引与修改

L = [1, 2, 3, 5, 'bob']
L[0:3]  # 取前3个值
L[:]  # 取所有的值
L[-1] # 取最后一个值

修改直接通过索引值进行赋值，即可完成修改。

• 列表的复制

L = [1, 2, 3, 5]
print(L)
print(L*2)  # 该操作时列表的复制，并不能使L中的每一个元素都乘以2   运行结果如下图所示

•  列表的方法总结

　　列表共有11种方法，可以分为8大类型：

'''列表方法汇总'''
# 创建列表
L = [1, 2, 3, 5]

# 1. 添加元素
L.append(3)   # 会在末尾添加元素3， 这种添加方式只能添加一个元素, 1
L.append([4, 3])  # 当然也可以添加以列表为一个元素的操作，但该元素即为列表中套列表的形式
## 列表的合并
L.extend([4, 3])   # 该操作会在末尾添加多个值, 但不会是列表套列表的形式， 而是一种列表合并的操作2
L = L+[5, 6]      # 通过加号+也可以实现列表的合并，但一般不这么用，一般就是使用extend方法
## 在某个位置新增
L.insert(3, 6)    # 在索引3 增添元素6   3

# 2. 统计列表中某元素的个数
a = L.count(3)  # 4

# 3. 获取某区段内某元素的下表(第一次出现)
index1 = L.index(3)  # 默认为列表内所有元素  5
index2 = L.index(3, 2, -1)   # 按起始位置 到终止为止查找第一次出现该字符的索引。  如果在该区段没有该字符，会报错，因此使用该操作时，最好使用异常处理

# 4. 清空列表内容,使列表变为[]
# L.clear()   # 将L清空了，但变量名还在  []  6

# 5. 列表翻转
L.reverse()     # 7
Lx = L[::-1]
# 6. 列表赋值  该赋值L发生变化时，赋值的并不会发生变化
pickL = L.copy()    # 浅复制   8
L.extend([1, 2, 3, 4, 5])

# 7. 列表元素的删除
L.pop(4)  # 按索引删除列表  9
L.remove(4)  # 按元素删除  删除第一个该元素 10

# 8. 列表元素的排序
L.sort(reverse=True)  # 可以按照某些关键字排序，也可以对其进行倒排，顺排   reverse=true 表示逆序排列  11
L.sort()   # 默认为顺序排列
L1 = sorted(L, reverse=True)   # sort 方法并不会影响L本身，需要赋值新变量 也叫临时排序

L2 = ['This', 'is', 'a', 'BOy']
L3 = [i.lower() for i in L2]
L3.sort(key=len) # 使用某些关键字排序  此处是按照字符的长度排序

P.S.  列表的.copy是浅复制。 python中也有自带的copy模块，其中包含：

• 浅复制： 复制体发生变化时，本体也会发生改变；同样，本体发生变化时，复制体也会发生变化。  本体和复制体属于命运共同体。   但是，对于列表自带的方法修改时，二者并不会发生相关联的变化
• 深赋值：复制体和本体是相互独立的，各自的变化不会影响另一方。

import copy
x = [[1,2,3],[4,3,5],[12,4,5]]
y = [[1,2,3],[4,6,5],[12,4,6]]

# result = x.copy()
# result1 = copy.copy(x)
result2 = copy.deepcopy(x)

for i in range(len(x)):
    for j in range(len(x[0])):
        # result[i][j] = x[i][j] + y[i][j]
        # result1[i][j] = x[i][j] + y[i][j]
        result2[i][j] = x[i][j] + y[i][j]


# print(result)
# print(result1)
print(result2)

print(x)
print(y)

• 列表的常用技巧

1. enumerate的用法

L = ['存款准备金', '基准利率', '加息', '降准']
dic = dict((v, i)for v, i in enumerate(L))  # 生成了一个带编号的字典
print(dic)

for i, v in enumerate(L):
    print(i, v)

　　2. zip的用法

L1 = [1, 2, 3, 4, 5]
L2 = [4, 3, 2, 1]
Lx = zip(L1, L2)  # 组合以后生成的迭代器   (1,4)(2,3)(3,2)(4,1)  返回的是一个元组
for i in Lx:
    print(i)

 

　　3. 列表的单个字符转字符串列表

a = [''.join(['h', 'e', 'l', 'l', 'o'])]
print(a)

元组操作

 元组是一种只读型列表，意味着其一旦创建便不能再修改，因此也就少了很多修改的方法。  ()圆括号

　　一共只用2种方法：统计     索引查询

a = ()  # 只读列表，一旦创建，不能修改  除非重新命名   因此也就只有两种方法
a = ('a', 'b')
index1 = a.index('a')
num = a.count('a')

集合操作

 集合是一种无序的数据类型，在集合中，没有重复的元素，这是集合的特性。

a = set('boooooy')
a.remove('o')  # 元素中没有该元素   会报错
print(a)
a.pop()  # 因为无序，所以此处不能按照索引删除，只能删除最后一个   
a.discard('p')  # 元素中没有该元素  不会报错
a.update('ig')   # update上去的还是会分割
# a.clear()
b = a.copy()
a.add('MOM')   # add添加的是一个整体
c = a.difference(b)   # 寻找a里有而b里没有的元素  取差集
# d = a.difference_update(b)
e = a.intersection(b)    # 取交集
# f = a.intersection_update()
g = a.isdisjoint(b)     # 判断两个集合是否独立 没有交集  返回布尔变量
h = a.issubset(b)   # 判断a是不是b的子集  返回布尔变量
i = a.issuperset(b)  # 判断a是不是b的父集  返回布尔变量
j = a.symmetric_difference(b)  # 各自互相没有的元素提取出来，返回的也是集合类型
k = a.union(b)   # 取并集   | 也可以用该云算
print(type(a))
print(a)
print(b)
print(c)
# print(d)
print(e)
# print('f:',f)
print(g)
print(h)
print(i)
print(type(j))
print(k)