一. set集合

空集合 a = set()

set集合内的元素必须可哈希(不可变), int, str, bool, tuple

set3 = {'1','alex',2,True,(1,2,[2,3,4])}                                     这会报错

set可去重, 用set(lst)去重. lst  = list(set(lst))

set内元素是无序的.

set集合有增删改查的操作

可以用frozenset()冻结集合, 使集合可哈希, 不可变.

s = {1,2,3}

增

s.add(元素)

s.update(元素)

删

item.s.pop(元素)

s.remove(元素)

s.clear(元素)

改

先删除后添加

查

for i in s:

print(i)

其他操作:

s1 = {1,2,3}

s2 = {3,4,5}

交集

print(s1 & s2)

print(s1.intersection(s2))                                {3}

并集

print(s1 | s2)

print(s1.union(s2))                                          {1,2,3,4,5}

差集

print(s1 - s2)

print(s1.difference(s2))                                   {1,2}

反交集

print(s1 ^ s2)

print(s1.symmetric_difference(s2))               {1,2,4,5}

子集

print(s1 < s2)   False

超集

print(s1 > s2)   False

frozenset

s = frozenset(["赵本⼭山", "刘能", "⽪皮⻓长⼭山", "⻓长跪"])

dic = {s:'123'}

print(dic)                                                              不添加frozenset会显示unhashedable type

dic = {frozenset({1,2,3}):1}

print(dic)                                                              不会报错

a = frozenset({1,1,1,1,1})

print(a)                                                                frozenset({1})

print(type(a))                                                       class 'frozenset'>

二. 深浅拷贝

a = [5,6,7,8]

lst1 = [1,2,3,4,a]

赋值

lst2 = lst1               没有创建新列表, 共用了一个列表

浅拷贝

lst2 = lst1[:]

lst2 = lst1.copy()      创建了一个新列表, 但是lst1的最后一个变量名为a的列表只复制了一个内存指向

深拷贝

import copy

lst2 = copy.deepcopy(lst1)                  创建了一个新列表, 复制了lst1的所有元素, 并将lst1中内存指向的元素也重新复制了一份

浅拷贝和深拷贝的区别:

浅拷贝时, 只是将列表中的元素拷贝到了第二个列表中, 第一个列表中的列表元素只是拷贝了指向这个列表的内存指向, 所以如果这个内存指向的列表发生变化时, 第一个列表和拷贝的第二个列表的这个元素都会发生变化.

深拷贝时, 会把这个列表中内存指向的列表也一起拷贝过来, 所以当改变内存指向的元素a时, lst1会改变, 而lst2不会改变. 深拷贝会复制所有层的内存指向的元素.

三, 其他

1.

lis = ['1','2','3']

a = "_".join(lis)

print(a)

lis的元素只能是字符串, 或者用join(字符串)等可迭代的类型

2.

列表和字典在循环的时候不能删除其中的元素.

列表的for循环中, 删除了其中一个元素, 后面的元素会往前面移一个索引, 下一个for i in lst: 时, 会跳到被弹出的元素的后面第二个元素.

字典的for循环中, 字典进行修改时, 会报错, 字典在循环时, 不能改变字典的大小.

可以用一个新建的列表或字典, 在循环中, 改变另一个新的字典或列表.

3.

b = [1,2]

a = dict.fromkeys("we", b)

b.append(3)

print(a)

输出{'w': [1, 2, 3], 'e': [1, 2, 3]}, a中值对应的b理解为对列表b的一个指向. 在print前面进行append时, 会改变b的元素. 所以输出时有b的添加上去的元素.