集合及深浅拷贝

• for循环对于可变类型和不可变类型的一些特点

在对不可变类型进行循环时，会重新创建一个新的不可变类型副本，在循环中改变原不可变类型不会改变循环。

s = '12345'
for i in s:  # 并不会陷入死循环循环完原字符串后退出循环
    s = s + 's'
    print(i)
print(s)

在对列表进行循环时，不会重新创建原列表的副本，而是实时改变循环的对象

li = [1, 2, 3, 4, 5, 6]
for i in li:  # 会陷入死循环，一直在对不断变长的列表进行循环。
    li.append(i+6)
    print(i)
print(li)

在对字典进行循环时，如果改变了字典的大小会直接报错。

dic = {'a':1, 'b':2, 'c':3}
for i in dic:  # 会直接报错，对字典对象进行循环时，禁止改变字典的大小              
    dic.pop(i)
    print(i)

在对集合对象进行循环时与对字典对象循环时相同，不能改变集合的大小

se = {1, 2, 3}
for i in se:  # 会直接报错，对集合对象进行循环时，禁止改变集合的大小
    se.add(i+3)
    print(i)

对元组进行定义时如果要定义只有一个元素的元组，要在末尾添加‘，’否则（）会被认为是运算符。

tu = ()  # 能成功定义空元组，不会报错
print(tu,type(tu))

tu = (1)  # ()被认为是运算符,(1)被视为1
print(tu,type(tu))

tu = (1,)  # 能成功定义一个只有一个元素的元组
print(tu,type(tu))

定义集合对象时，如果要定义空的集合，要在用set({})否则会被认为是空的字典

se = {}  # 被视为空字典，而不被认为是空集合
print(se,type(se))

se = set({})  # 能成功定义一个空集合
print(se,type(se))

• 集合的定义

集合是一种无序可变的数据类型，但是集合要求它的元素全部是不可变的数据类型

集合会自动去除重复的元素。

se = {1,2,3,4,1,1,1}  # 会自动去除重复的元素1，只保留一个
print(se)

• 集合的增操作

add(value)在集合中增加value.

se = {1,2,3,4}
se.add(5)
print(se)

update(iterable values)在集合中逐个增加可迭代变量中的元素

se = {1,2,3,4}
se.update([5, 6, 7])
print(se)

• 集合删除操作

pop()随机删除集合中的一个元素，并返回该元素

se = {1,2,3,4}
se.pop()
print(se)

remove(value)按照值删除指定元素

se = {1,2,3,4}
se.remove(4)
print(se)

clear()清空集合中的元素

se = {1,2,3,4}
se.clear()
print(se)

del 删除整个集合

se = {1,2,3,4}
del se

• 集合的查操作

集合由于没有顺序，也没有键值，所以只能通过for循环遍历查找集合中的元素

se = {'cc','aadas', 'book', 'cjpi', 'dads'}
for i in se:
    print(i)

• 集合的一些运算操作

集合的一些基本运算，如交，并，反交，差在python中都有相应的方式支持

集合的交运算

se1 = {1,2,3,4,5}
se2 = {4,5,6,7,8}
se3 = se1 & se2
print(se3)  # 输出{4,5}
se3 = se1.intersection(se2)
print(se3)  # 输出{4,5}

集合的并运算

se1 = {1,2,3,4,5}
se2 = {4,5,6,7,8}
se3 = se1 | se2
print(se3)  # 输出{1, 2, 3, 4, 5, 6, 7, 8}
se3 = se1.union(se2)
print(se3)  # 输出{1, 2, 3, 4, 5, 6, 7, 8}

集合的反交运算

se1 = {1,2,3,4,5}
se2 = {4,5,6,7,8}
se3 = se1 ^ se2
print(se3)  # 输出{1, 2, 3, 6, 7, 8}
se3 = se1.symmetric_difference(se2)
print(se3)  # 输出{1, 2, 3, 6, 7, 8}

集合的差运算

se1 = {1,2,3,4,5}
se2 = {4,5,6,7,8}
se3 = se1 - se2
print(se3)  # 输出{1, 2, 3}
se3 = se2.difference(se1)
print(se3)  # 输出{8, 6, 7}

子集判断与超集判断

se1 = {1,2,3,4,5}
se2 = {1,2,3}
se3 = {6}
print(se1 > se2)  # 判断集合1是否为集合2的超集   输出结果为True
print(se1 > se3)  # 判断集合1是否为集合3的超集   输出结果为False
print(se1 < se2)  # 判断集合1是否为集合2的子集  输出结果为False
print(se2 < se1)  # 判断集合2是否为集合1的子集  输出结果为True

普通集合本身是一种可变得数据类型，可以使用frozenset将集合转化为不可变集合

se1 = {1,2,3,4,5}
se2 = frozenset(se1)
print(se1,type(se1))  # 输出结果为{1, 2, 3, 4, 5} <class 'set'>
print(se2,type(se2))  #输出结果为frozenset({1, 2, 3, 4, 5}) <class 'frozenset'>

•  利用集合与列表之间的转化为去除列表中重复的数据
  

可以将列表转化为集合，再将集合转化回列表，这样就能去除列表中重复的元素

li = [2,3,4,4,5,4,5,2,1,2,6,1]
se = set(li)  # 将列表转化为集合
li = list(se)  # 将集合转化回列表
print(li)  # 输出结果为去除重复元素的列表

• 枚举函数enumerate()的应用

使用enumerate()对于可迭代变量会创建一个类似于索引与值相对应的元组所组成的列表、

li = ['大傻子','二愣子','三猴子']
for i in enumerate(li):
    print(i)
"""结果为  
        (0, '大傻子')
        (1, '二愣子')
        (2, '三猴子')
"""
for id,name in enumerate(li):
    print(id,name)
"""结果为  
        0 大傻子
        1 二愣子
        2 三猴子
"""
for id, name in enumerate(li,100):  # 设置起始索引
    print(id, name)
"""结果为  
        100 大傻子
        101 二愣子
        102 三猴子
"""

•  深浅拷贝copy与deepcopy

对于赋值符只是将原变量所指向的数据地址传给被赋值变量，当利用新变量对数据进行更改时，也会影响到原来的变量所对应的数据。（准确的说他们对应同样的数据）

li1 = [1,2,3,4]
li2 = li1
print(li1 is li2)  # 输出结果为True
li2.append(5)
print(li1,li2)  # 输出结果为[1, 2, 3, 4, 5] [1, 2, 3, 4, 5]两个变量对应的列表都被更改了

对于当使用copy函数进行赋值的时候，会重新创建一个空间储存变量，但是变量中的元素任然共用一个地址

li1 = [[1,2,3],2,3,4]
li2 = li1.copy()
print(li1 is li2)  # 输出结果为False
li2.append(5)
print(li1,li2)  # 输出结果为[[1, 2, 3], 2, 3, 4] [[1, 2, 3], 2, 3, 4, 5]只有列表2被更改了

print(li1[0] is li2[0])  # 输出结果为True，列表1与列表2的元素任然公用一个地址
li2[0].append(6)  # 列表1于列表2中的子数据均被更改
print(li1,li2)  # 输出结果为[[1, 2, 3, 6], 2, 3, 4] [[1, 2, 3, 6], 2, 3, 4, 5]

当时用deepcopy函数对变量赋值的时候，无论是变量本身还是其子元素都会重新开辟空间储存数据，互补影响

使用deepcopy需要导入copy模块

import copy
li1 = [[1,2,3],2,3,4]
li2 = copy.deepcopy(li1)
print(li1 is li2)  # 输出结果为False
li2.append(5)
print(li1,li2)  # 输出结果为[[1, 2, 3], 2, 3, 4] [[1, 2, 3], 2, 3, 4, 5]只有列表2被更改了

print(li1[0] is li2[0])  # 输出结果为False，列表1与列表2子元素不共用一个空间
li2[0].append(6)  # 只有列表2中的子数据被更改了
print(li1,li2)  # 输出结果为[[1, 2, 3], 2, 3, 4] [[1, 2, 3, 6], 2, 3, 4, 5]