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

原创文章，作者：奋斗，如若转载，请注明出处：https://blog.ytso.com/12772.html