Python中 str/list/dict/set/tuple 的增删改查

写在前面

这里汇总一些常用变量的增删改查基本操作，主要包括字符型(str)变量，列表(list), 字典(dict)， 集合(set)，元组(tuple)，也会涉及到collection内置模块中的一些集合类。

字符(str)

str - 增
直接使用+连接字符

a = 'str'
a += 'AAA'  # a变量末尾增加'AAA'字符，相当于 a = a + 'AAA'
print(a)  # 结果为'strAAA'
a = 'BBB' + a  # a 变量前加'BBB'字符
print(a)  # 结果为 'BBBstrAAA'

str - 删
借助list切片，重新得到新字符：

b = 'TestStr'
b = b[:2] + b[3:]  # 去掉第3个字符"s", 这里使用的是类似list的切片
print(b)  # b的结果为’TetStr‘
# b[:i-1] + b[i:]  # 去掉第i个字符

若不知道索引位置，知道要去掉的字符，可借助replace属性：

br = b.replace('t', '\n')  # 用换行符(str中没有的字符)替换
brd = ''.join(br.split('\n'))  # 再用'\n'把br拆分成列表，之后用空字符把该列表合并
print(brd)  # 结果为‘TesSr’

注意这里replace不替换原来的字符，而是返回替换后的字符。

str - 改
这里就直接用replace直接替换所有指定字符（也可以限制替换次数）。

c = 'TEST'
ct = c.replace('T', 't')  # 把大写'T'换成小写，也可使用c.replace('T', 't', 1) 只替换一次
print(ct)  # ’tESt‘
# 若是指定位置的替换，则需要借助切片（类似删除操作），再用"+"合并
cte = c[:2] + 't' + c[3:]  # 这里我把第3个字符改成't'
print(cte)  # 'TEtT'

str - 查

d = 'Test'
print(d[1])  #  得到'e', 完全与列表相同，输入索引即可
d[2] = 'S'  # 错误

注：这里虽然可以用索引获取指定位置字符，却不能替换指定位置字符。

str - 遍历
通过遍历字符，进行更改/删除操作

ss = 'abcfecde'  # 小写b替换成大写, 并删除所有字母'f', 删除第三个位置上的字母('c')
i = 0
tmp_s = ''
for s in ss:
	i += 1
	if s == 'b':
		tmp_s += 'B'  # 替换成大写
	elif s == 'f':
		tmp_s += ''  # 删除'f'
	elif i == 3:
		tmp_s += ''  # 删除第三个位置上的字母
	else:
		tmp_s += s
print(tmp_s)  # 'aBecde'

---

扩展： 以上只是关于字符的基本操作，字符还有很多其他属性：

一些自己常用的属性：
- startswith, endswith; # 判断首尾字符
- isupper, islower, upper, lower; # 判断字符大小写，或者转换成大写或者小写
- strip; lstrip; rstrip; # 去除首尾的空白字符(空格,TAB,换行)，只去首或只去尾
- split; # 按某字符串把str拆分成列表(list)
- replace; # 把str中某字符(串)替换成其他字符(串)
- join; # 用str把字符/列表连接起来

---

列表(list)

list - 增
列表的增加方式，在指定位置添加（insert)；在列表末尾之后添加：添加元素(appnd)；添加列表(extend)。

l1 = [2, 3]
l1.append(’a‘)  # 直接在原列表l1的末尾添加元素，无返回值
print(l1)  # [2, 3, 'a']
l1.append(['c', 'd']) 
print(l1)  # [2, 3, 'a', ['c', 'd']]
l1.extend(['c1', 'd1'])  # 一次在列表末尾添加多个元素
print(l1)  # [2, 3, 'a', ['c', 'd'], 'c1', 'd1']

l1.insert(0, 1)  # 在开始位置增加一个元素1
# 若增加多个元素，考虑使用reverse和extend
l1.reverse()  # 把l1反向，此时l1: ['d1', 'c1', ['c', 'd'], 'a', 3, 2]
l1.extend(['d2', 'c2'])  # 注意这时候添加的list的元素顺序，下面一步再次反向
l1.reverse()  
print(l1)  # ['c2', 'd2', 2, 3, 'a', ['c', 'd'], 'c1', 'd1']

注：list添加元素是在原来变量基础上直接更改，也就是list是可变对象.
关于list增加元素，还可以python内置模块collections中的deque（与list类似），这是廖雪峰python网站中对deque的说明：

• 使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。
• deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈。
• deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。

from collections import deque
lst = [1, 2, 3, 4]
dq = deque(lst)
dq.append('5')  # 与list相同，在末尾(右边)添加元素
dq.appendleft('0')  # 在左边添加一个元素
print(dq)  # deque(['0', 1, 2, 3, 4, '5'])
dq.popleft()  # 从左边删除，并返回删除元素：'0'（pop从右边删除一个元素并返回）
print(dq)  # deque([1, 2, 3, 4, '5'])

下面截图是list(lst)和deque(dq)的所有属性，deque主要可实现左边的一些操作，而list中插入/索引/排序等操作dq中并没有。

list - 删
列表list两个属性pop, remove用于删除，其区别是一个是pop为指定索引删除（并返回删除字符），remove为指定元素删除（从末尾，一次删除一个）

>>> l2 = ['a', 'b', 'c', 'd', 'c', 'c', 'e']
>>> l2.pop(0)  # 指定索引，返回删除元素'a', l2: ['b', 'c', 'd', 'c', 'c', 'e']
'a'
>>> l2.pop()  # 无指定索引，默认删除最后一个元素，相当于l2.pop(-1)
'e'
>>> print(l2)
['b', 'c', 'd', 'c', 'c']
>>> l2.remove('c')  # 删除字符'c', 这时只删除最后一个字符'c'
>>> print(l2)
['b', 'c', 'd', 'c']

list - 改
由于list是可变对象，直接使用list的索引替换原来的值。

l3 = ['a', 'c']
l3[1] = 'A'  # 把第二个元素替换成'A'
print(l3)  # ['a', 'A']

list - 查
查找某个索引位置的元素，获取两个指定位置之间的元素，使用切片：

>>> l4 = [1, 3, 5, 7, 2, 4]
>>> print(l4[2])  # 第三个位置的元素 5
5
>>> print(l4[:3])  # 获取到索引为3之前的元素
[1, 3, 5]  # 返回前三个元素, 注意前三个
>>> print(l4[3:])  # 从索引3的元素开始
[7, 2, 4]  # 返回从第四个元素及之后元素，注意从第四个元素到最后
>>> print(l4[2:5])  # 返回索引2到索引5之间的元素，没有索引5元素
[5, 7, 2]  # 返回第三个元素到第5个元素
>>> print(l4[-2])  # 反向切片，最后一个元素索引为-1
2

list - 遍历
类似str变量的遍历，可以使用for循环，也可直接在列表中操作：

ll = [1, 2, 4]
ll_s1 = [i + 1 for i in ll]  # 每个元素进行改变
ll_s2 = [i + 1 for i in ll if i!=2]  # 只获取不等于2的值，并加1

字典(dict)

dict - 增
可直接使用dict[key]=value赋值，也可使用dict.update()更新字典，使用dict.copy()复制：

# 初始化一个字典
d = dict()
d['c'] = 1  # 通过key, value赋值增加元素
d['a'] = 3
print(d)  #  {'a': 3, 'c': 1}
d.update({'b':2, 'e': 4})  # 添加多个元素
dc = d.copy()  # 直接从其他字典copy

注意：使用dict.copy()是由于如果直接使用dc = d，那么在更改d1或dd1中任意一个，另一个都会随着改变。
这里虽然先赋值’c’，再赋值’a‘，但d1输出结果并没有顺序，如果像保持赋值时的先后顺序，可使用pyhon内置的集合模块collections中的OrderedDict

from collections import OrderedDict
od = OrderedDict()
od['c'] = 1
od['a'] = 3
print(od)  # OrderedDict([('c', 1), ('a', 3)])

collections模块中还有另一种类型字典： defaultdict，这个字典相当于初始化时候，定义value的类型，也可防止的获取字典时，如果key不存在会报错(KeyError)。

print(d1['b'])  # 这时会报错，找不到key

from collections import defaultdict
dd = defaultdict(list)  # 比如默认字典的Value值的类型是列表
dd['c'] = [1, 2]
dd['a'] = [2]
dd['b'].append(3)  # 这时可直接使用list的append属性往字典中添加元素
print(dd)  # defaultdict(list, {'a': [2], 'b': [3], 'c': [1, 2]})

dict的value是多个时，如果想使用defaultdict可以用lambda辅助：

# 来自文心一言
from collections import defaultdict  
  
# 初始化一个defaultdict，其默认值为一个包含两个0的元组  
dict_with_tuple = defaultdict(lambda: (0, 0))  
  
# 现在你可以像使用普通字典一样使用它  
dict_with_tuple['a'] += (1, 1)  # 'a' 的值现在是 (1, 1)  
dict_with_tuple['b'] = (2, 3)  # 'b' 的值被设置为 (2, 3)  
  
# 访问一个不存在的key时，它会返回默认值 (0, 0)  
print(dict_with_tuple['c'])  # 输出: (0, 0)  
  
# 如果你想更新一个key的某个元素的值，你需要分别处理  
dict_with_tuple['a'] = (dict_with_tuple['a'][0] + 1, dict_with_tuple['a'][1])  # 'a' 的值更新为 (2, 1)  
  
# 或者你可以使用一个简单的函数来更新特定元素的值  
def update_tuple_value(d, key, index, value):  
    current_value = d[key]  
    current_value = current_value[:index] + (value,) + current_value[index+1:]  
    d[key] = current_value  
  
# 使用上面的函数更新 'a' 的第二个元素的值  
update_tuple_value(dict_with_tuple, 'a', 1, 2)  # 'a' 的值更新为 (2, 2)

dict - 删
dict删除的属性有pop（删除指定key元素），clear（清空字典）：

d = {'a': 1, 'b': 2}
d.pop('a')  # 则删除字典key'a'及对应value
d.clear()  # 则直接情况字典的所有元素

dict - 改
若某个key1已有对应value，要更改value，则重新对key赋值即可。（dict为可变对象）

d = {'a': 1, 'b': 2}
d['a'] = 2  #  {'a': 2, 'b': 2}

dict - 查
字典的查询直接通过’key’获取对应value，只获取key使用dict.keys()，只获取values使用dict.values()

d = {'a': 1, 'b': 2}
print(d['b'])  # 2
print(d.keys())  # ['a', 'b']
print(d.values())  # [1, 2]

dict - 遍历
遍历dict是使用dict.items()：

d = {'a': 1, 'b': 2}
for k, v in d.items():
	# print(k, v) 
	d[k] = v + 1  # 每个value增加1

其他

dic1 = {'a': 1}
dic2 = {'b': 2}
dic_mg = dict(dic1, **dic2)  # 合并两个dict {'a': 1, 'b': 2}
sorted(dic_mg.items(),key = lambda x:x[1],reverse = True)  # 按字典的value排序

集合(set)

这个集合与中学的元素(数)的集合相同，集合中无重复的元素，所以可以使用set对list去重。

# 初始化
ll = [10, 3, 4, 'A', 100, 3, 4]
set_l = set(ll)  # 需要list作为输入
print(set_l)  # 重复元素被删除，并排序
# {3, 4, 10, 100, 'A'}

# 增
set_l.add('10')  # 增加一个元素
set_l.update(['B', 'C'])  # 类似dict的更新
print(set_l) # {3, 4, 10, 100, '10', 'A', 'B', 'C'}
set_l2 = set_l.copy()  # 通过copy生成一个新的set

# 删
set_l.pop()  # 删除末尾元素（这里没有索引）， 返回删除值'C'
set_l.remove(10)  # 删除指定元素
print(set_l)  # {3, 4, 100, '10', 'A', 'B'}
set_l.clear()  # 清空set_l

# 改
## 由于set为不可变对象，就是没法通过索引改写
## 如果要强行更改具体位置的元素，可考虑转换为list，更改之后再转换成set
set1 = set([2, 10, 100])
l1 = list(set1)
l1[0] = 1  # 需要明确索引
set1 = set(l1)
print(set1) # set([1, 10, 100])

# 查
## set会默认排序，也就不能按输入的顺序进行索引(eg: set_l[0] 会报错)
## 但可以换一种方式查询，使用intersection(交集)
set2 = set([2, 10, 100])
set2.intersection(set([100]))  # 查询是否有数值100， 返回集合{100}, 则说明有
set2.intersection(set([1]))  # 查询是否有数值1, 返回空集合set()，则说明没有

# 遍历整个集合
## 虽然不能单个查询元素，但可以遍历集合元素
for s in set2:
	print(s)

其实使用set的主要是对两个set求并/交/差集，是否为子集/超集等的操作：

# 两个集合
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])

# 并/交/差集
s1.union(s2)  # 返回s1与s2的并集: {1, 2, 3, 4}
s1.intersection(s2)  # 交集: {2, 3}
s1.difference(s2)  # 差集, 相当于 s1 - s2, 从s1去掉s2集合中的元素: {1}
s2.difference(s1)  # 差集, 相当于 s2 - s1, 从s2去掉s1集合中的元素: {4}
s1.symmetric_difference(s2)  # 相当于把两者的差集合并: {1, 4}

# 用交/差集更新当前集合
s1.intersection_update(set({1, 3, 5}))  # 与s1: {1, 2, 3}的交集代替s1
print(s1)  # {1, 3}
s2.symmetric_difference(set({1, 3}))  # 与s2: {2, 3, 4}的差集的合并
print(s2)  # {1, 2, 4}

元组(tuple)

由于tuple是不可变的，所以一开始赋值后，就不可再变更了，只能查询。
tuple - 查

t1 = (1, 2, 3)
print(t1[0])  # 1
l1 = (2, 5, 8)
tl = tuple(l1)  # 将列表转换为tuple
print(tl[1])  # 5

tuple - 增/删/改 初始化后不可变更，强制变更可先转换成list。

上面list/dict的增删改查中有提到，内置模块collections中有deque与list类似，defaultdict/OrderedDict与dict类似，对于tuple，collections也有与之相似的集合类 – namedtuple，就是给tuple元素命名的一个类，方便查询tuple的元素，而不使用索引，给个示例：

In [1]: from collections import namedtuple
In [2]: nt = namedtuple('student', ['name', 'age'])
In [3]: Student = namedtuple('Student', ['name', 'age'])
In [4]: stu1 = Student('Jack', '18')
In [5]: stu1.age  # 通过定义的tuple名称属性获取对应值
Out[5]: '18'
In [7]: stu1.name
Out[7]: 'Jack'

---