铁乐学Python_day07_集合and浅谈深浅copy

1、【List补充】

在循环一个列表时，最好不要使用元素和索引进行删除操作，一旦删除，索引会随之改变，容易出错。

如果想不出错，可以采用倒着删除的方法，因为倒着删除进行的话，只是后面元素的位置发生了变化(位移），但不影响前面元素的排列位置。

元组在只有一个元素时，需要加个逗号来防止岐义。

将列表中索引为奇数的元素进行删除，有三种方法（思路）:

第一种是最简单的del加切片:

例：

li = ['老男孩', 'python', 'alex', 'wusir', 'egon', 'ritian', '女神']

del li[1::2]

print(li)和步长操作；

结果：['老男孩', 'alex', 'egon', '女神']

第二种是先挑选出索引为偶数的元素（因为反过来说要保留的是它们），

加进一个新列表，再将新列表赋值给旧列表；

li = ['老男孩', 'python', 'alex', 'wusir', 'egon', 'ritian', '女神']

l1 =[]

for i in range(len(li)):

    if i % 2 == 0:

        l1.append(li[i])

li = l1

print(li)

结果：['老男孩', 'alex', 'egon', '女神']

第三种是通过for循环，通过range索引范围找出奇数位置的元素来进行单个单个的del，但是要注意的是要将范围倒过来进行操作，如下：

li = [11, 22, 33, 44, 55]

for i in range(len(li)-1, -1, -1):

    if i % 2 == 1:

        del li[i]

print(li)

结果：[11, 33, 55]

注意不要使用index查找元素来确定索引的方式，因为一旦列表中有多个同名的元素存在时，index就会导致错误，和你预想中的效果不一样，index查找返回的是第一个找到的元素的索引位置。

2、【dict补充】

题：删除以下字典中，键包含k的键值对。

dic = {'k1':'value1', 'k2':'value2', 'name':'wusir'}

假如我们试图for遍历键直接去删除的话：

dic = {'k1':'value1', 'k2':'value2', 'name':'wusir'}

for i in dic:

    print(i)

    if 'k' in i:

        del dic[i]

print(dic)

会出现如下报错：

Traceback (most recent call last):

k1

  File "E:/Python/day07/temp.py", line 20, in <module>

    for i in dic:

RuntimeError: dictionary changed size during iteration

这是因为，

在循环（迭代）字典时，是不能进行改变字典大小的操作的（增加或删除此字典的键值对）。

故可行的是先将所有键取出放在一个列表中，再循环这个列表来进行删除。

li =[]

for i in dic:

    if 'k' in i:

        li.append(i)

for k in li:

    del dic[k]

print(dic)

{'name': 'wusir'}

以上代码其实还可以优化成不用先行创建空列表，而是直接list转换查询到的所有键的dict.keys()容器成列表，如下：

dic = {'k1':'value1', 'k2':'value2', 'name':'wusir'}

lis =list(dic.keys())

for key in lis:

	if 'k' in key:

		del dic[key]

print(dic)

另，数据转换补充

tuple <---> list

List(tuple)

tuple(list)

3、【集合set】

从事数据开发的可能常用到它

集合的样子，如：set = {11, 22, 33}

集合：

数据类型：里面的元素不重复，无序（意味着没有索引，不能改，可以增删查），它里面的元素是可hash的，但集合本身是不可哈希的，不能作为字典的key。

作用：

1、去重。

（面试必有一道去重题，不提算法的情况下，直接转换成集合）

2、数据关系的测试。（两个集合之间的交并集等）

li = [11,11,22,22,55,55,66,66,33,33,33,44]

li = list(set(li))

print(li)

增加：

set.add()

hum = {'枪兵', '弓箭手', '狮鹫', '剑士'}

hum.add('僧侣')

print(hum)

{'枪兵', '弓箭手', '僧侣', '狮鹫', '剑士'}

set.update(迭代增加)

hum = {'枪兵', '弓箭手', '狮鹫', '剑士'}

soldires = ['骑士', '天使', '僧侣']

hum.update(soldires)

print(hum)

{'剑士', '僧侣', '骑士', '狮鹫', '天使', '枪兵', '弓箭手'}

删除：

set.remove()按照元素去删除，删除不存在的元素会引发异常

hum = {'枪兵', '弓箭手', '狮鹫', '剑士'}

hum.remove('枪兵')

print(hum)

{'狮鹫', '弓箭手', '剑士'}

set.discard()删除集合指定的元素，删除不存在的元素不会引发报错（它什么都不做）

set.pop()随机删除（因为无序），有返回值，返回被删除的值

hum = {'枪兵', '弓箭手', '狮鹫', '剑士'}

print(hum.pop())

print(hum)

剑士

{'狮鹫', '弓箭手', '枪兵'}

set.clear()  清空集合【空集合表现为set()】

hum = {'枪兵', '弓箭手', '狮鹫', '剑士'}

hum.clear()

print(hum)

set()

del set 删除整个集合

查：

for遍历去查询所有元素

for i in set：

		print(i)

# 求交集 （求两个集合中都有的元素）

set1 & set2

set1.intersection(set2)

例：

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

print(set1 & set2)   # 显示{1, 4, 5}

print(set1.intersection(set2))  # 显示{1, 4, 5}

# 反交集 （反过来返回两个集合中交集除外的元素）

set1 ^ set2

set1.symmetric_difference(set2)

例：

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

print(set1 ^ set2)    # 显示{2, 3, 6, 7}

print(set1.symmetric_difference(set2)) # 显示{2, 3, 6, 7}

# 计算交集并更新成交集操作

intersection_update

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

set1.intersection_update(set2)

print(set1)

{1, 4, 5}

set1集合变成了交集的元素。

# 并集 （合并，相同的被覆盖）

set1 | set2 （且去重）

set1.union(set2)

例：

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

print(set1 | set2)

print(set1.union(set2))

# 显示：

{1, 2, 3, 4, 5, 6, 7}

{1, 2, 3, 4, 5, 6, 7}

# 并集计算并更新成并集

set1.update(set2)

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

set1.update(set2)

print(set1, set2)

{1, 2, 3, 4, 5, 6, 7} {1, 4, 5, 6, 7}

可以看到只有前者被替换成了并集。

# 差集 （前者减去后者中有的前者元素，所剩的集合）

set1 - set2

set2 - set1

set1.difference(set2)

例：

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

print(set1 - set2) #显示{2, 3}

print(set2 - set1) #显示{6, 7}

# 差集更新

set1.difference_update(set2)

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

set1.difference_update(set2)

print(set1, set2)

{2, 3} {1, 4, 5, 6, 7}

set1被替换成set1和set2的差集了。也就是它不但计算两者的差集，同时还将差集结果替换前者集合。

# 对称差集，计算两两之间的差集，返回的是合起来的差集结果集合

symmetric_difference()

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

print(set1.symmetric_difference(set2))

{2, 3, 6, 7}

# 子集 (返回bool值）

set1.issubset(set2)

set1 < set2

例：

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

print(set1 < set2)     # 返回False

set3 = {33, 35, 38}

set4 = {21, 22, 33, 35, 38}

print(set3.issubset(set4))

# 返回True，set3是set4的子集，换言之，set4中的元素中包含有set3的所有元素。

# 超集

set2.issuperset(set1)

set2 > set1

例：

set3 = {33, 35, 38}

set4 = {21, 22, 33, 35, 38}

print(set3.issuperset(set4)) # False

print(set4 > set3)  # True

# frozenset （冰冻集合）

冰冻集合是一种特殊的集合类型,也是集合(集合是列表的话,冰冻集合就是元组)

(将集合变成字典键，不可变类型的集合）

frozenset（set）

set3 = {33, 35, 38}

set4 = {21, 22, 33, 35, 38}

print(frozenset(set3), type(frozenset(set3)))

dic = {frozenset(set4):'test'} #转化成字典键值

print(dic)

print(set3, type(set3))

frozenset({33, 35, 38}) <class 'frozenset'>

{frozenset({38, 33, 35, 21, 22}): 'test'}

{33, 35, 38} <class 'set'>

基本的集合推导式

>>> var ={'centos', 'openSUSE', 'Ubuntu', 'reahat'}

>>> result = {'*'+i+'*' for i in var}

>>> print(result)

{'*centos*', '*openSUSE*', '*Ubuntu*', '*reahat*'}

带条件判断的集合推导式

>>> result = {i for i in var if i !='centos'}

>>> print(result)

{'Ubuntu', 'openSUSE', 'reahat'}

多循环集合推导式

>>> colors = {'red', 'blue', 'pink'}

>>> sizes = {36, 37, 38, 39}

>>> result = {c + str(s) for c in colors for s in sizes}

>>> print(result)

{'pink37', 'red38', 'pink39', 'pink36', 'red37', 'blue39', 'blue38', 'blue37', 'blue36', 'pink38', 'red39', 'red36'}

# isdisjoint() 检测2个集合是否不存在交集  存在交集则返回False

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 1}

set3 = {8, 9, 10}

print(set1.isdisjoint(set2))

print(set2.isdisjoint(set3))

False

True

4、【深浅copy】浅谈

# copy 不再是指向同一个内存空间，而是在内存中又开辟了新的另一个内存空间

l1 = [1, 2, 3]

l2 = l1.copy()

l1.append(4)

print(l1, l2)

#copy，对于浅copy来说，第一层创建的是新的内存地址，从第二层开始以及更深层来说，它们用的是同一个（会保持一致性）。

#对于切片来说，它也是一种浅copy

l1 = [1, 2, [1, 2, 3], 4]

l2 = l1.copy()

l1[2].append(5)

print (l1, l2)

# deep.copy 深copy

# 改变任意一个的任何元素，不管多少层嵌套（几维），它都是新开辟了内存空间，独立存在的。

improt copy

l1 = [1, 2, [1, 2, 3], 4]

l2 = copy.deepcopy(l1)

#创建了一个一模一样，但内存空间完全没有关系的，

l1[2].append(5)

print(l1, l2)

print(id(l1[2]),id(l2[2])

Python中对象的赋值都是传递了对象引用（同一内存地址）;

使用copy.copy()进行对象的浅拷贝，它复制了对象，但对于对象中的嵌套（多维）元素，依然使用原始的引用;

使用copy.deepcopy()进行深拷贝,可以做到复制一个容器（有嵌套）对象，

使它里面的所有元素（包含元素的子元素）都是开辟新的内存空间;

对于非容器类型（如数字、字符串、和其他'原子'类型的对象）没有被拷贝一说,

因为对原字符串的操作都会生成新的字符串;

如果元祖变量只包含原子类型对象，则不能深拷贝。

5、编码的补充

s = 'tiele'

s1 = s.encode('utf-8')      unicode ---> utf-8 转码

s2 = s1.decode('utf-8')     utf-8 --->unicode  解码

gbk ----> utf-8

两者不能直接进行转换， 都需要借助unicode

s = 'tiele'

s1 = s.encode('gbk')

s2 = s1.decode('gbk')

s3 = s2.encode('utf-8')

或

s2 = s1.decode('gbk').encode('utf-8')

end

巴特西