2018.3.10学习笔记（集合、深浅拷贝）

集合set()

#!/usr/bin/env python
# -*- coding:utf-8 -*-

#创建一个字典，往里边添加东西
print('创建一个字典，往里边添加东西')
dic = {}
dic['k'] = 555
print(dic)

#创建一个集合，往里边添加东西
# doc = {}
# doc.add(5)
# print(doc)#报错，原因是doc = {}默认是创建字典类型
print('创建一个集合，往里边添加东西')
doc = set()#所以创建空集合要这么写
doc.add(5)
print(doc)
doc = {1,2}#创建非空集合则可以偷懒
doc.add(5)
print(doc)

#添加多个元素update()
print('添加多个元素update()')
doc = set()
doc.update([123,456,789])
print(doc)

#清空clear()
print('清空clear()')
doc.clear()
print(doc)

#查找doc中存在，docc不存在的集合difference()
print('查找doc中存在，docc不存在的集合difference()')
doc = {123,234,345,456}
docc = {345,456,567,678}
rut = doc.difference(docc)
print(doc)#可以看到只做查找，不对对象doc做操作
print(rut)#查找的结果可以赋值给一个新的对象
rut = doc.difference_update(docc)
print(doc)#查找结果替换原对象，即删除doc和docc共有值
print(rut)#返回空值

#移除指定元素，不存在不报错discard()
print('移除指定元素，不存在不报错discard()')
doc.discard(777)#doc.remove(777)#remove()也可以移除，但是如果元素不存在，会报错
rut = doc.pop()#由于{}是无序的，所以删除的元素不确定，且pop()是可以有结果的
print(doc)
print(rut)#pop()的结果，是删除的元素本身，而不是集合

#取交集，和上边的difference()用法类似,取对称交集symmetric_difference(),取并集union()
print('取交集，和上边的difference()用法类似,取对称交集symmetric_difference(),取并集union()')
doc = {123,234,345,456}
docc = {345,456,567,678}
rut = doc.intersection(docc)
print(doc)
print(rut)
rut = doc.intersection_update(docc)
print(doc)
print(rut)
doc = {123,234,345,456}
docc = {345,456,567,678}
rut = doc.symmetric_difference(docc)
print(rut)
rut = doc.union(docc)
print(rut)

#判断是否有交集
print('判断是否有交集')
doc = {123,234,456}
docc = {123}
rut = doc.isdisjoint(docc)
print(rut)#注意：有交集是False,无交集是True

#判断是否是子集合
print('判断是否是子集合')
rut = doc.issubset(docc)
print(rut)

#判断是否是父集合
print('判断是否是父集合')
rut = doc.issuperset(docc)
print(rut)

作业：

数据更新
old_dict = {
    '数据1':'结果1',
    '数据2':'结果2',
    '数据3':'结果3',
}

new_dict = {
    '数据1':'结果4',
    '数据4':'结果2',
    '数据5':'结果3',
}

old_dict = {
    '数据1':'结果1',
    '数据2':'结果2',
    '数据3':'结果3',
}

new_dict = {
    '数据1':'结果4',
    '数据4':'结果2',
    '数据5':'结果3',
}
old_keys = old_dict.keys()
old_set = set(old_keys)
# lowB做法
# old_set = set()
# for old in old_dict:
#     old_set.add(old)
print(old_set)
#print(type(old_set))
new_keys = new_dict.keys()
new_set = set(new_keys)
print(new_set)

un_update = old_set.difference(new_set)
print(un_update)


add_update = new_set.difference(old_set)
print(add_update)


new_update = old_set.intersection(new_set)
print(new_update)


set = add_update.union(un_update)
up_set = new_set.union(set)
print(up_set)

for i in up_set:
    if i in new_update:
        old_dict[i] = new_dict[i]
    elif i in add_update:
        old_dict[i] = new_dict[i]#是不是和new_update那个一样，所以，然并卵，只要把new更新到old就可以了，写这么多只是练习set()
    else:
        pass
print(old_dict)

# 常规写法
# old_keys = old_dict.keys()
# old_set = set(old_keys)
#
# new_keys = new_dict.keys()
# new_set = set(new_keys)
#
# up_set = old_set.union(new_set)
#
# for i in up_set:
#     if i in new_set:
#         old_dict[i] = new_dict[i]
#     else:
#         pass
# print(old_dict)

赋值、浅拷贝、深拷贝

 赋值

a = ['world',{'oh':'my god'}]
b = a#赋值
a[0] = 'hello'
print(a)
print(b)
a[1]['hehe'] = 'hehe'
print(a)
print(b)

 浅拷贝

import copy
a = ['world',{'oh':'my god'}]
b = a[:]#浅拷贝，等同于b = copy.copy(a)
a[0] = 'hello'
print(a)
print(b)
a[1]['hehe'] = 'hehe'
print(a)
print(b)

 深拷贝

import copy
a = ['world',{'oh':'my god'}]
b = copy.deepcopy(a)#深拷贝
a[0] = 'hello'
print(a)
print(b)
a[1]['hehe'] = 'hehe'
print(a)
print(b)

函数的动态参数

#!/usr/bin/env python
# -*- coding:utf-8 -*-

def hanshu1(*args):#一个*号接收的是一个元组
    print(args,type(args))
def hanshu2(**kwargs):#两个*号接收的是一个字典
    print(kwargs,type(kwargs))
def hanshu3(p,*args,**kwargs):#万能参数
    print(p,args,kwargs)
    print(p)
    print(args)
    print(kwargs)

hanshu1(123,456,[123,456],{1:123,2:456})
hanshu2(k1=123,k2=456)
hanshu3(1,'asd','diu',ab='ab')#测试'diu'不能写在ab='ab'后面

#给动态参数传入列表、元组、字典
def hanshu(*args,**kwargs):#万能参数
    print(args)
    print(kwargs)

li = ['a','b','c']
hanshu(li)
hanshu(*li)

lo = {'k':'ok'}
#hanshu(lo)报错，因为没有这种形式，参数传字典是以k='ok'这种形式
hanshu(**lo)