Python 第三篇(下)：collections系列、集合(set)、单双队列、深浅copy、内置函数

 一、collections系列：

collections其实是python的标准库，也就是python的一个内置模块，因此使用之前导入一下collections模块即可，collections在python原有的数据类型str(字符串), int(数值), list(列表) tuple(元组), dict(字典)的基础之上增加一些其他的数据类型即方法，具体如下：

1、Counter(dict)：计数器，扩展的字典的方法，对指定数据的字串做统计出现的次数,结果是一个元组，如：

import  collections
li = ("asdasdsdasdahjlklknlknfd")
a = collections.Counter(li)
print(a)

执行结果:
Counter({'d': 5, 's': 4, 'a': 4, 'k': 3, 'l': 3, 'n': 2, 'j': 1, 'h': 1, 'f': 1})

2、most_common()：不加参数以列表里面加元组方式显示每个字符串出现多少次，加数字表示最少出现括号里面传递的数字次数，如：

import  collections
li = ("asdasdsdasdahjlklknlknfd")
a = collections.Counter(li)
print(a.most_common(2)) #显示出现次数最多的前2个
print(a.most_common(5)) #显示出现次数最多的前5个

执行结果：
[('d', 5), ('s', 4)]
[('d', 5), ('s', 4), ('a', 4), ('k', 3), ('l', 3)]

3、collections.items:以字典结果方式显示每个元素出现的次数生成一个迭代器，可以使用for循环遍历每个元素：，如下：

import  collections
li = ("asdasdsdasdahjlklknlknfd")
a = collections.Counter(li)
for k,v in a.items():  #相当是对collections.Counter的结果又做了二次操作
    print(k,v)

执行结果：
j 1
f 1
l 3
d 5
h 1
n 2
k 3
a 4
s 4

4、collections.elements:获取每个到每个元素并生成一个迭代器，可以使用for循环遍历每个元素：

import  collections
li = ("asdasdsdasdahjlklknlknfd")
a = collections.Counter(li)
for k in a.elements():
    print(k)

 5、collections.update：对同一个元素的出现次数进行增加更新:

import  collections
li = "nihao"  #原始字符串
a = collections.Counter(li)  #统计每个元素出现的次数
print(a) #打印元素 字符串每个元素出现的次数
a.update("hello") #更新字符串元素
print(a)  #打印更新后的元素出现次数

执行结果：
Counter({'o': 1, 'i': 1, 'h': 1, 'n': 1, 'a': 1}) #原始的字符串出现次数
Counter({'o': 2, 'l': 2, 'h': 2, 'i': 1, 'n': 1, 'a': 1, 'e': 1})  #更新后的字符串元素出现次数

5、subtract：对同一个元素做减处理，如下：

import  collections
li = "nihao"  #原始字符串
a = collections.Counter(li)  #统计每个元素出现的次数
print(a)
a.subtract("hello") #打印元素 字符串每个元素出现的次数
print(a)  #打印更新后的元素出现次数

执行结果：
Counter({'a': 1, 'h': 1, 'o': 1, 'i': 1, 'n': 1}) #更新之前每个元素的出现次数
Counter({'a': 1, 'i': 1, 'n': 1, 'o': 0, 'h': 0, 'e': -1, 'l': -2}) #更新之后的每个元素的出现次数，与update相反，是对原数据进行减操作，如果元素没有则会标记元素为-1，在减一次为-2，对这个元素update一次则增加为-1，如：
import  collections
li = "nihao"  #原始字符串
a = collections.Counter(li)  #统计每个元素出现的次数
print(a)
a.subtract("hello") #打印元素 字符串每个元素出现的次数
print(a)  #打印更新后的元素出现次数

a.update("llo")
print(a)

执行结果：
Counter({'a': 1, 'o': 1, 'h': 1, 'i': 1, 'n': 1})
Counter({'a': 1, 'n': 1, 'i': 1, 'o': 0, 'h': 0, 'e': -1, 'l': -2})
Counter({'a': 1, 'n': 1, 'o': 1, 'i': 1, 'h': 0, 'l': 0, 'e': -1}) #l的次数转正了

6、del:删除指定的元素：会删除元素和元素的计数值：

 1 import  collections
 2 li = "nihao"  #原始字符串
 3 a = collections.Counter(li)  #统计每个元素出现的次数
 4 print(a,"原字符串")
 5 a.subtract("heello") #打印元素 字符串每个元素出现的次数
 6 print(a,"做减操作的字符串")
 7 del a["l"]#打印元素 字符串每个元素出现的次数
 8 del a["e"]
 9 print(a,"使用del删除元素的字符串")  #打印更新后的元素出现次数
10 
11 执行结果：
12 Counter({'i': 1, 'o': 1, 'h': 1, 'n': 1, 'a': 1}) 原字符串
13 Counter({'i': 1, 'n': 1, 'a': 1, 'o': 0, 'h': 0, 'l': -2, 'e': -2}) 做减操作的字符串
14 Counter({'i': 1, 'n': 1, 'a': 1, 'o': 0, 'h': 0}) 使用del删除元素的字符串，删除后即使该元素的次数为-2也可以只接全部删除元素和元素的出现次数，即会会删除元素本身和其计数

 7、get：获取指定元素出现的次数：

import  collections
li = "nihaoiinn"  #原始字符串
a = collections.Counter(li)  #统计每个元素出现的次数
print(a.get("n"))  #获取指定元素的出现次数

执行结果：
3    #表示n在此字符创当中一共出现了3次

8.copy：是浅copy，浅copy只copy第一层，变量里面包含的列表或字典的id值和以前是不变的：

import  collections
li = "nihaoiinn[jack]"  #原始字符串
a = collections.Counter(li)  #统计每个元素出现的次数
b  = a.copy()
print(id(a),"id-->a的id")
print(id(b),"id-->b的id")

print(id(a[9]),"a的第九个元素的id")
print(id(b[9]),"b的第九个元素的id")

执行结果：
11335784 id-->a的id
11337064 id-->b的id
505605904 a的第九个元素的id
505605904 b的第九个元素的id

9、defaultdict：默认字典，在创建的时候指定该字典的默认数据格式，可以是列表、元组或列表等,如:

import  collections
dic1 = collections.defaultdict(list)
dic1["k1"].append(1)
print(dic1)

执行结果：
defaultdict(<class 'list'>, {'k1': [1]}) #默认的数据格式为list，即元素的默认格式为list，可以使用列表的所有操作方法对字典的值进行操作

10.OrderedDict：有序字典，默认创建的字典是无需的，可以使用OrderedDict创建字典，这样字典内部会对key进行排序显示，key的顺序将会固定保持不变，如下：

import  collections
d=collections.OrderedDict()
d['a']='111'
d['b']='222'
d['c']='333'
for k,v in d.items():
    print(k,v)

执行结果：
a 111
b 222
c 333  #可以看到时按照是按照顺序排列的，而且刷新以后的顺序也会保持不变

下面创建一个默认的字典：
d={}
d['a']='111'
d['b']='222'
d['c']='333'
for k,v in d.items():
    print(k,v)

执行结果：
c 333
a 111
b 222   #不是按照顺序排列的，而且每次刷新的顺序都不一致

有序字典的常用操作：

pop、删除指定的字典key，并返回被删除的value

 1 import  collections
 2 dic1 = collections.OrderedDict({'name':'jack','age':20,'job':'IT'}) 
 3 print(dic1)
 4 print(dic1.pop("age"))
 5 print(dic1)
 6 
 7 执行结果：
 8 OrderedDict([('name', 'jack'), ('job', 'IT'), ('age', 20)]) #删除之前的有序字典
 9 20  #被删除的value
10 OrderedDict([('name', 'jack'), ('job', 'IT')]) #删除之后的有序字典

keys：获取有序字典的全部key，方法和字典是一样的：

1 import  collections
2 dic1 = collections.OrderedDict({'name':'jack','age':20,'job':'IT'})  
3 print(dic1.keys())
4 
5 执行结果：
6 odict_keys(['name', 'age', 'job'])

values：获取有序字典所有的值，方法和字典是一样的：

1 import  collections
2 dic1 = collections.OrderedDict({'name':'jack','age':20,'job':'IT'}) 
3 print(dic1.values())

执行结果：
odict_values(['IT', 'jack', 20])  #所有的值

items：获取有序字典所有的键值对，方法和字典是一样的：

1 import  collections
2 dic1 = collections.OrderedDict({'name':'jack','age':20,'job':'IT'}) 
3 print(dic1.items())

执行结果;
odict_items([('name', 'jack'), ('job', 'IT'), ('age', 20)]) #所有的键值对

move_to_end：将指定的键值对移动到最后的位置：

import  collections
dic1 = collections.OrderedDict({'name':'jack','age':20,'job':'IT'}) 
dic1.move_to_end("name") #将name移动到最后的位置
#print(dic1.pop("age"))
print(dic1)

执行结果：
OrderedDict([('age', 20), ('job', 'IT'), ('name', 'jack')])  #顺序已经发生变化，name到最后了

clear：清空有序字典的所有键值对:

import  collections
dic1 = collections.OrderedDict({'name':'jack','age':20,'job':'IT'})
dic1.clear()
print(dic1)

执行结果：
OrderedDict()  #字典已经为空

11、namedtuple：可命名元组，可以给元组命名，在通过元素的名称获取到元素的值，也可以使用元素的下标获取到元素的值：

1 import  collections
2 Mytuple = collections.namedtuple("xy",['a','b'])  # collections.namedtuple表示对一个元素命名，本为名称是xy,名称必须有，其包含有两个元素a和b
3 list1 = Mytuple(10,20)  #实例化类，并传递两个参数进去
4 print(list1.a)  #打印结果
5 print(list1[0])
6 
7 #执行结果：
8 10   #10是a的值，即可以用元素的名称获取到元素的值
9 10 #通过下标获取到的元素的值

 12、queue.Queue：单向队列，先进先出，类似于弹夹，先放去的子弹先打出来，只能从左边进行操作：

put，get,qsize,full：插入数据,获取数据,查看队列长度，判断队列是否已经满了：

import  queue
d = queue.Queue(maxsize=3) #创建一个队列并指定最大长度为3个
d.put("a") #添加一个队列值
d.put("b") #添加一个队列值
d.put("c") #添加一个队列值
print(d.qsize()) #查看队列的当前长度
print(d.full()) #先判断队列是否已经满了
print(d.get()) #获取一个队列值
print(d.get()) #获取一个队列值
print(d.get()) #获取一个队列值
print(d.qsize()) #获取完队列值再次查看队列的长度
print(d.full()) #再次判断队列是否满了

执行结果：
3   #第一次已经显示队列是3个了
True  #第一次队列是满的
a
b
c #获取三个值
0  #此时队列里面已经再没有数据了
False  #之后队列就是空的了

empty：判断队列是否为空，是返回True，否返回False：

import  queue
d = queue.Queue(maxsize=3)
d.put("a")
d.put("b")
d.put("c")
print(d.qsize())
print(d.get())
print(d.get())
print(d.get())
print(d.qsize())
print(d.empty(),"#判断是会否为空")

执行结果：
3  #首次的队列长度
a
b 
c #获取三个值
0  #获取值之后的队列的长度为0
True #判断是会否为空，是返回True，否返回False

put_nowait：在队列可以插入的时候不阻塞插入数据数据，可以理解为不按排队顺序插队到最前面put数据：

get_nowait：在队队列有时间后不阻塞获取数据，可以理解为不按排队顺序插队到最前面get数据：

import  queue
d = queue.Queue(maxsize=3)
d.put_nowait("a")
d.put_nowait("b")
d.put_nowait("c") #每获取一次数据，队列的长度减1
print(d.qsize())
print(d.get_nowait())
print(d.get_nowait())
print(d.get_nowait())
print(d.qsize())
print(d.empty(),"#判断是会否为空")

执行结果：
3
a
b
c
0
True #判断是会否为空

 13、queue.deque：双向队列，可以左右两侧都进行操作的队列与单向队列最大的不同是可以从队列左右两侧都进行操作，

appendleft：添加元素到最左侧：

append：添加元素做最右侧，即末尾：

import  queue
d = queue.deque(["a,","b","c",'d'])
print(d)
d.append("jack")
d.appendleft("tom")
print(d)

执行结果：
deque(['a,', 'b', 'c', 'd'])  #添加之前的队列
deque(['tom', 'a,', 'b', 'c', 'd', 'jack'])  #添加之后的队列

count：统计队列中某个元素出现的次数，而不是某个字符串；

copy：是浅copy，只拷贝第一层，其内部包含的元素和列表的id是一样的

import  queue
d = queue.deque(["a,","b","tom","c",'d',"tom"])
print(d)
print(d.count("tom"),"tom出现了两次，表示队列中的元素可以重名即可以重复")

a = d.copy()
print(id(a),"a的id")
print(id(d),"d的id")
print((a[3]),"a的第三个元素")
print(id(a[3]),"a的第三个元素的id")
print(id(d[3]),"a的第三个元素的id")

执行结果：
deque(['a,', 'b', 'tom', 'c', 'd', 'tom']) 原队列内容
2 tom出现了两次，表示队列中的元素可以重名即可以重复
12208024 a的id
12207920 d的id
c a的第三个元素
4803472 a的第三个元素的id
4803472 a的第三个元素的id

 extend：对原队列进行右侧扩展，扩展的元素是是字符串，而append附加是元素，一个元素可以包含多个字符串，如果extend传递的一个包含多个字符串的元素，则会展开元素为多个字符串进行添加：

 extendleft：对原队列进行左侧侧扩展，其他同extend

import  queue
d = queue.deque(["a,","b","c",'d',"tom"])
print(d)
d.extend("jack")  #右侧扩展jack
d.extendleft("lyly") #左侧扩展lyly
print(d)

执行结果：
deque(['a,', 'b', 'c', 'd', 'tom'])  #扩展之前的队列
deque(['y', 'l', 'y', 'l', 'a,', 'b', 'c', 'd', 'tom', 'j', 'a', 'c', 'k']) #扩展之后的队列，扩展后会将元素拆开为多个字符串进行添加，与append大为不同

index：根据value获取其下标位：

insert：将元素插入到指定的下标位置：

import  queue
d = queue.deque(["a,","b","c",'d',"tom"])
print(d)
d.insert(1,"jack")
print(d.index("jack"))
print(d)

执行结果：
deque(['a,', 'b', 'c', 'd', 'tom'])  #insert之前的队列
1 #获取到的jack的下标位置
deque(['a,', 'jack', 'b', 'c', 'd', 'tom'])  #打印insert之后的队列结果

reverse:将整个队列顺序反转显示，即倒数第一个为第一个，倒数第二个为第二个，一次类推

rotate:将最后指定数量的几个元素放在最前的位置

import  queue
d = queue.deque(["a,","b","c",'d',"tom"])
print(d) #原队列顺序
d.reverse()  #将整个队列顺序反转显示，即倒数第一个为第一个，倒数第二个为第二个，一次类推
print(d) #反转整个队列之后的结果

a = queue.deque(["a,","b","c",'d',"tom"])  #将最后指定数量的几个元素放在最前的位置
print(a)  #原队列顺序
a.rotate(2)  #反转两个元素
print(a)  #反转2个元素之后的结果

pop:从右侧删除元素并返回被删除的元素

popleft:从左侧删除元素并返回被删除的元素

import  queue
d = queue.deque(["a,","b","c",'d',"tom"])
print(d) #原队列顺序
print(d.pop())  #删除右侧第一个元素
print(d) #删除左右侧第一个元素之后的结果

a = queue.deque(["a","b","c",'d',"tom"])
print(a)  #原队列顺序
print(a.popleft())  #删除最左侧的元素
print(a)  #删除最左侧第一个元素之后的结果

执行结果：
deque(['a,', 'b', 'c', 'd', 'tom'])
tom  #被删除的右侧元素
deque(['a,', 'b', 'c', 'd']) #删除右右侧第一个元素之后的结果
deque(['a', 'b', 'c', 'd', 'tom'])
a  #被删除的左侧元素
deque(['b', 'c', 'd', 'tom'])  #删除最左侧第一个元素之后的结果

remove：根据value删除元素

clear：清空整个队列

import  queue
d = queue.deque(["a,","b","c",'d',"tom"])
print(d," #原队列顺序")
print(d.remove("d"),"#删除指定的value d")
print(d,"#删除d之后的结果")

a = queue.deque(["a","b","c",'d',"tom"])
print(a," #原队列顺序")
print(a.clear(),"#清空队列")
print(a," #清空队列之后的结果")

执行结果：
deque(['a,', 'b', 'c', 'd', 'tom'])  #原队列顺序
None #删除指定的value d
deque(['a,', 'b', 'c', 'tom']) #删除d之后的结果
deque(['a', 'b', 'c', 'd', 'tom'])  #原队列顺序
None #清空队列
deque([])  #清空队列之后的结果

 

二：深浅copy：

copy：称为浅copy，默认的copy都是浅coyp，即没有特定使用深copy的操作，浅copy只copy第一层，即不copy内部的列表、字典或元组（假如有以上元素），可以用元素的id区分

deepcopy：深copy，会copy每一层的元素，包含copy内部的元组、字段或列表

假如copy对象都是字符串：

import  copy
#a = [123,"a","b","c",456,("tom",["it","18"]),{"jack":{"age":12}}]
a = "123456abcd"
b = copy.copy(a)
c = copy.deepcopy(a)
print(a)
print(b)
print(c) #每个变量的内容
print(id(a))
print(id(b))
print(id(c))  #每个变量的id
print(id(a[4]))
print(id(b[4]))
print(id(c[4]))  #每个变量的同一个元素的id值

执行结果：
123456abcd
123456abcd
123456abcd  #三个变量的值
7549552
7549552
7549552  #三个变量的id是相同的
7454368
7454368
7454368 #三个变量的同一个元素的id也是相同的

假如copy对象有列表并修改列表的值：

import  copy
a = [123,"a","b","c",456,["tom",["it","18"]],{"jack":{"age":12}}]
b = copy.copy(a) #b是浅copy的a的值，可以简写为b = a
c = copy.deepcopy(a) #c是深copy的a的值
print(a) #a的内容
print(b) #b的内容
print(c) #c的内容
#############查看第一层的元素的id
print(id(a))  #a的id
print(id(b)) #b的id
print(id(c))  #c的id
#############查看第二层的元素的id
print(c[5])  #获取一个元素
print(id(a[5])) #a的第5个元素的id值
print(id(b[5])) #b是浅copy，查看b的第5个元素的id值
print(id(c[5]))  #c是深copy，查看c的第5个元素的id值

#############查看第三层的元素id
print(c[5][0])  #第5个元素的是一个元组，获取到该元组的第一个元素是tom
print(id(a[5][0])) #查看元组中的元素的ID值
print(id(b[5][0])) #查看元组中的元素的ID值
print(id(c[5][0])) #查看元组中的元素的ID值


执行结果：
[123, 'a', 'b', 'c', 456, ['tom', ['it', '18']], {'jack': {'age': 12}}]  #a的内容
[123, 'a', 'b', 'c', 456, ['tom', ['it', '18']], {'jack': {'age': 12}}] #b的内容 
[123, 'a', 'b', 'c', 456, ['tom', ['it', '18']], {'jack': {'age': 12}}] #c的内容
14771656 #第一层原a的id
11150920 #第一层浅copy之后b的id，可以发现包含了列表之后和a的id也不一样了，上个例子如果只是字符串还是一样的
14772168  #第一层深copy之后c的id
('tom', ['it', '18']) #获取到第二层的元素
11060424 #a第二层的元素id
11060424 #b第二层的元素id
11079624 #c第二层的元素id
tom  #第三层的元素
11048360  #a的第三层的元素id
11048360 #b的第三层的元素id
11048360 #c的第三层的元素id  #可以发现最底层的元素id是一样的，最底层是把元素做了链接


#############修改copy源的第三层的元素的值，再看深浅copy的自底层的元素值：
a[5][1][0] = "CTO"  #此元素为修改之前为it
print(id(a[5][0])) #查看元组中的元素的ID值
print(id(b[5][0]))
print(id(c[5][0]))

执行结果：
14390696  #a修改第三层后的第三层元素的id
14390696  #修改后b也发生变化
14390696  #a也发生了变化，可见深copy之后最底层的元素是链接到了a的最底层之上，这样节省空间也免去了copy的步骤从而节约了时间


#############修改深copy之后的元素的值，查看a和b是否受影响：
print("###########")
c[5][1][0] = "CTO" #为指定元素重新赋值
print(c[5][1][0])  #打印修改后的元素的结果，验证是否修改成功
print(id(a[5][0])) #查看修改后a的此元素的值
print(id(b[5][0])) #查看修改后b的此元素的值，

执行结果：
CTO
12096936
12096936
12096936 #以上id都是一样的，可见修改深copy之后最底层的值，会影响到copy源本身和浅copy之后的值


#############修改浅copy之后的元素的值，查看a和b是否受影响：
b[5][1][0] = "CTO"
print(b[5][1][0])
print(id(a[5][0])) #查看元组中的元素的ID值
print(id(b[5][0]))
print(id(c[5][0]))

执行结果：
CTO
14325160
14325160
14325160  #三个元素的id是一样的，可见即使修改浅copy的底层元素的值也会影响到copy源本身和身copy的元素id值

假如copy对象是字典：

import  copy
a = {"CPU":[80],"MEM":[80],"Disk":[80],}
b = copy.copy(a)
c = copy.deepcopy(a)

print(a,"a原字典")
print(b,"b浅copy原字典")
print(c,"c深copy原字典")
print(id(a),"原字典的id")
print(id(b),"浅copy的id")
print(id(c),"深copy的id")


#############################修改copy源
a["CPU"][0] = 50 #对copy源的元素值做修改
#print(["CPU"][0])
print(id(a["CPU"][0]),"原字典的元素id")
print(id(b["CPU"][0]),"浅copy的元素id")
print(id(c["CPU"][0]),"深copy的元素id")
print(a["CPU"][0],"原元素")
print(b["CPU"][0],"浅copy元素值")
print(c["CPU"][0],"深copy元素值")

执行结果：
{'MEM': [80], 'Disk': [80], 'CPU': [80]} a原字典
{'MEM': [80], 'Disk': [80], 'CPU': [80]} b浅copy原字典
{'MEM': [80], 'Disk': [80], 'CPU': [80]} c深copy原字典
13825672 原字典的id
14370696 浅copy的id
14271368 深copy的id
493417808 原字典的元素id
493417808 浅copy的元素id
493418768 深copy的元素id
50 原元素
50 浅copy元素值，可见修改字典类型的copy源会影响其本身和浅copy的元素值，不会影响到深copy，这是因为浅copy只是copy了表面，内部是做的链接
80 深copy元素值，深copy对于字典是从第一层到最末一层完全copy的，没有使用链接


###########################修改浅copy的元素值
b["CPU"][0] = 50 #对浅拷贝之后的CPU的值做修改，b是浅copy
print(id(a["CPU"][0]),"原字典的元素id")
print(id(b["CPU"][0]),"浅copy的元素id")
print(id(c["CPU"][0]),"深copy的元素id")
print(a["CPU"][0],"原元素")
print(b["CPU"][0],"浅copy元素值")
print(c["CPU"][0],"深copy元素值")

执行结果：
{'MEM': [80], 'Disk': [80], 'CPU': [80]} a原字典
{'Disk': [80], 'CPU': [80], 'MEM': [80]} b浅copy原字典
{'Disk': [80], 'CPU': [80], 'MEM': [80]} c深copy原字典
6289032 原字典的id
11224968 浅copy的id
11125640 深copy的id
503051600 原字典的元素id
503051600 浅copy的元素id
503052560 深copy的元素id
50 原元素
50 浅copy元素值
80 深copy元素值，可见修改浅copy影响的范围和修改copy源本身的范围是一样的，只会影响copy源和浅copy，深copy不受其影响


#############################修改深copy的元素值
c["CPU"][0] = 50 #对深拷贝之后的CPU的值做修改，c是深copy
print(id(a["CPU"][0]),"原字典的元素id")
print(id(b["CPU"][0]),"浅copy的元素id")
print(id(c["CPU"][0]),"深copy的元素id")
print(a["CPU"][0],"原元素")
print(b["CPU"][0],"浅copy元素值")
print(c["CPU"][0],"深copy元素值")

执行结果：
{'Disk': [80], 'MEM': [80], 'CPU': [80]} a原字典
{'Disk': [80], 'MEM': [80], 'CPU': [80]} b浅copy原字典
{'Disk': [80], 'MEM': [80], 'CPU': [80]} c深copy原字典
13760136 原字典的id
14305160 浅copy的id
14205832 深copy的id
499448080 原字典的元素id
499448080 浅copy的元素id
499447120 深copy的元素id
80 原元素
80 浅copy元素值
50 深copy元素值，可见深copy只影响深copy本身，不影响copy源和浅copy，由此可以断定深copy对于字典是完全copy，包括key和value都是完全copy一份，copy完之后就和copy源没有任何关联了。

深浅copy总结：

1、假如copy源只是字符串，则深浅copy没有区别，只是copy后变量名称的id值不一样，其内部的元素的id值是一致的。

2、假如copy是列表组成，则会将内部的列表完全copy一份，其内部的元素的id会指向copy源的底层元素，假如对元素做了一份浅copy和深copy，则无论是修改了copy源的底层元素、浅copy的底层元素还是深copy的底层元素，都会影响到元素本身和其他copy的元素改变。

 3、假如copy源是字典，则深会对字典的key和value完全copy，浅copy依然是对内部的元素做链接到copy源，修改copy源和浅copy只会影响浅copy源和浅copy，不会影响到深copy，同样修改深copy也不会影响到以上浅copy和浅copy源本身。

 

三：yield 和return：

yield：是一个生成器，在函数里用于记住上一次的操作，下次在执行的时候从当前的位置继续执行，生成器生成的值需要用for循环才能访问到：

def func(arg):
    print(arg,"第一次")
    yield "a" #以实参作为返回值
    print(arg,"第二次")
    yield "b"
a = func("a")
for i in a:
    print(i)

执行结果：
a 第一次 
a  #第一次yield的值
a 第二次
b  #第二次yield的值

#在整个函数运行的时候，先进入到函数内部，执行 print(arg,"第一次")之后遇到yield "a"并执行后返回到for循环print（i），然后再从for循环跳转到函数内部执行print(arg,"第二次")和yield "b"，即在函数内部遇到yield会暂停函数内部运行，跳出后遇有调用的时候在从跳出的yield位置继续运行。

return：函数的返回值，遇到return的时候函数会停止继续运行，并以return的返回值赋值给函数本身，一个函数只能有一个return，多余的也不会执行，因为第一个return之后函数就停止运行了。

def func():
    name = "jack"
    return name
    age = 18
    return  age
print(func())  #打印函数的值，返回值会赋值给函数的名称调用

执行结果：
jack    #遇到return跳出后就停止运行函数，并就此终止函数，因此不会执行age的代码

 

四：集合（set）

set的元素是不能重复出现的，而且是无序排列的，如创建一个包含重复字串的集合：

set1 = set("abcdefgabc")
print(set1)

执行结果;
{'g', 'c', 'd', 'b', 'e', 'a', 'f'} #可见是无序排列并将元素拆分为单个字串，并将重复的abc只显示了单个

set的常用操作方法：

 add：向集合里面添加元素：

remove：删除指定的元素名，且没有返回值

 pop：随机删除集合的元素并返回被删除的值

set1 = set("abcbdefgabc")
set1.add("tom")
print(set1)
print(set1.remove("b"),"remove删除元素需指定要删除的元素名称，且没有返回")
print(set1)
print(set1.pop(),"pop删除元素无需参数，切会返回删除的元素")
print(set1)

执行结果：
{'g', 'e', 'd', 'b', 'a', 'tom', 'c', 'f'}  #添加tom以后的集合
None  #remove删除元素需指定要删除的元素名称，且没有返回，返回为None
{'g', 'e', 'd', 'a', 'tom', 'c', 'f'} #remove删除元素以后的集合
g  #pop删除元素无需参数，切会返回删除的元素，本次为g
{'e', 'd', 'a', 'tom', 'c', 'f'} #pop删除元素以后集合

clear：清空元素列表：

copy：浅copy为另一个集合:

update：更新现有的集合:

set1 = set("abcbdefgabc")
print(set1,"set1原来的集合效果")
set1.update("tom")
print(set1,"updatede的tom的效果")

print("##########################")
set2 = set1.copy()
print(id(set2))
print(id(set1))


print("##########################")
set3 = set("abcbdefgabc")
print(set3,"set3原来的集合效果")
set3.clear()
print(set3,"set3的clear的效果")

执行结果：
{'f', 'e', 'g', 'a', 'b', 'c', 'd'} set1原来的集合效果
{'o', 'f', 'e', 'g', 'a', 'b', 'c', 'd', 't', 'm'} updatede的tom的效果
##########################
14111688  #浅copy之前的set1的id
10215208  #浅copy之后的set3的id
##########################
{'f', 'e', 'g', 'a', 'b', 'c', 'd'} set3原来的集合效果
set() set3的clear的效果

difference：用两个集合作比较，删除传递的参数并生成一个新的集合，只返回非传递的集合里没有的元素，并生成一个新的序列，如：

set1 = set("abcd")
set2 = set("abc")
set3 = set1.difference(set2)
print(set3)

执行结果；
{'d'}  #返回set1有而set2没有的元素，本次为d

difference_update：删除原集合有并且传递的集合都有的值，这是在原集合直接操作的，删除完成以后查看原集合的值是否有变化:

set1 = set("abcd")
set2 = set("abce")
set1.difference_update(set2)
print(set1)

执行结果；
{'d'}  #删除完成之后set1就只有一个d了，因为abc和在set2里面也，被删除了

discard：丢弃一个指定的元素：

set1 = set("abcd")
set1.discard("c")  #丢弃c
print(set1)

执行结果：
{'a', 'd', 'b'}

intersection:交集运算，即取原集合和传递的集合共同都有的元素，并产生一个新的set集合：

set1 = set("abcd")
set2 = set("abce")
set3 = set1.intersection(set2)  #取set1和set2共同含有的元素并赋值给set3
print(set3)

执行结果：
{'c', 'a', 'b'} #abc是set1和set2共同含有的元素

intersection_update：交集运算，即取原集合和传递的集合共同都有的元素，并直接赋值给原集合：

set1 = set("abcd")
set2 = set("abce")
set1.intersection_update(set2)  #取set1和set2共同含有的值并赋值给set1
print(set1)

执行结果；
{'b', 'a', 'c'}  #set1的值已经成为abc了

isdisjoint：判断是否没有交集，即判断是否没有同样的元素，没有返回True,有返回False：

set1 = set("abcd")
set2 = set("qwer")
print(set1.isdisjoint("aoiu"))
print(set1.isdisjoint(set2))

执行结果：
False  #set1与aoiu有共同的元素a，所以返回False
True  #set1与set2没有共同的元素，所以返回True

issubset：判断是否子集，即原集合是否传递集合的子集：

set1 = set("abcd")
set2 = set("abcdefg")
print(set1.issubset(set2))
print(set1.issubset("abcdefg"))

执行结果：
True #set1是set2的子集
True #set1是字符串abcdefg的子集

issuperset：与issubset相反，判断是否父集：

set1 = set("abcd")
set2 = set("abcdefg")
print(set2.issuperset(set1))
print(set1.issuperset("abcdefg"))

执行结果：
True #set2是set1的父集
False #set1不是abcdefg的父集

symmetric_difference：取出来两个集合相互没有的元素，并将结果赋值给一个新的集合：

set1 = set("abcdiop")
set2 = set("abcdefg")  
set3 = set2.symmetric_difference(set1)  #取出来两个集合相互没有的元素并赋值给set3
print(set3)

取差集：
{'g', 'e', 'i', 'f', 'p', 'o'}  #取出来两个集合相互没有的元素

symmetric_difference_update：取出来两个集合相互没有的元素，并将结果赋值给原集合而不是赋值给一个新的集合：

set1 = set("abcdiop")
set2 = set("abcdefg")
set1.symmetric_difference_update(set2)  #取两个集合相互都没有的元素并就地赋值给原集合set1
print(set1)

执行结果；
{'p', 'e', 'g', 'f', 'o', 'i'}  #这就是set1的值，是取出两个集合相互没有的元素

union：去两个几个的并集，等于将两个集合的元素全部取出来并去重，最终每个元素只留一个：

set1 = set("abc")
set2 = set("abg")
set3 = set1.union(set2)
print(set3)

执行结果：
{'a', 'g', 'b', 'c'}   #结果是每个元素都有而且每个元素只有一个的新的集合

 有一个数据，需要通过集合的方式计算出需要更新、添加和删除的数据，最终要求是原来的没有新数据有就添加，原来有新的也有就更新，原来有新的没有删除，具体如下：

old_dict = {
    "#1":{ 'hostname':"c1", 'cpu_count': 2, 'mem_capicity': 80 },
    "#2":{ 'hostname':"c2", 'cpu_count': 2, 'mem_capicity': 80 },
    "#3":{ 'hostname':"c3", 'cpu_count': 2, 'mem_capicity': 80 },
}

new_dict = {
    "#1":{ 'hostname':"c2", 'cpu_count': 2, 'mem_capicity': 80 },
    "#3":{ 'hostname':"c3", 'cpu_count': 2, 'mem_capicity': 80 },
    "#4":{ 'hostname':"c4", 'cpu_count': 2, 'mem_capicity': 80 },
}

old = set(old_dict.keys())  #就的数据key
new = set(new_dict.keys())  #新的数据key

update_set = old.intersection(new)  #交集运算，取出old和new共同含有的元素，并赋值给update_set，共同都有的数据是要更新的数据
delete_set = old.difference(update_set)  #要删除的数据，用旧的数据删除要两边都有的数据，即得到要删除的数据
add_set = new.difference(update_set)  #要更新的数据，

for i in update_set:  #循环要更新的数据
    print("要更新的数据是%s" % i)
    old_dict[i] = new_dict.get(i)  #将新的数据赋值给旧的字典，
    print(old_dict,"更新数据的字典")


for i in delete_set:
    print("要删除的数据是%s" % i)
    old_dict.pop(i)  #删除指定的要删除的数据
    print(old_dict,"删除数据的字典")


for i in add_set:
    print("要添加的数据是%s" % i)
    old_dict[i] = new_dict.get(i)
    print(old_dict)

执行结果：
要更新的数据是#1
{'#1': {'cpu_count': 2, 'mem_capicity': 80, 'hostname': 'c2'}, '#3': {'cpu_count': 2, 'mem_capicity': 80, 'hostname': 'c3'}, '#2': {'cpu_count': 2, 'mem_capicity': 80, 'hostname': 'c2'}} 更新数据的字典
要更新的数据是#3
{'#1': {'cpu_count': 2, 'mem_capicity': 80, 'hostname': 'c2'}, '#3': {'cpu_count': 2, 'mem_capicity': 80, 'hostname': 'c3'}, '#2': {'cpu_count': 2, 'mem_capicity': 80, 'hostname': 'c2'}} 更新数据的字典
要删除的数据是#2
{'#1': {'cpu_count': 2, 'mem_capicity': 80, 'hostname': 'c2'}, '#3': {'cpu_count': 2, 'mem_capicity': 80, 'hostname': 'c3'}} 删除数据的字典
要添加的数据是#4
{'#1': {'cpu_count': 2, 'mem_capicity': 80, 'hostname': 'c2'}, '#3': {'cpu_count': 2, 'mem_capicity': 80, 'hostname': 'c3'}, '#4': {'cpu_count': 2, 'mem_capicity': 80, 'hostname': 'c4'}}

 

 五：模块变量：

__main__：判断是不是执行的主文件，当前文件为主执行文件的时候,其变量 __name__的名为__main__,如果有其他的模块或文件被调用到此文件，则其他的文件或模块的名称不会为__main__。

def func(arg):
    print("func1",arg)

if __name__ == "__main__":
    func(123)
    print(__name__) #当前文件为主执行文件的时候,其文件名为__main__,其他被调用的文件名

执行结果：
func1 123
__main__  #打印name的值

vars() ：当前模块的所有变量，file-当前文件的路径、doc-最开始的三个引号的注释

print(vars())

执行结果：
{'__doc__': '\nimport  collections\nobj = collections.Counter("asdasdasdasdtghtiotl")\nprint(obj)\n\n\n', '__package__': None, '__file__': '/Users/zhangshijie/PycharmProjects/S12-Python3/Day3/s1.py', '__spec__': None, '__cached__': None, '__name__': '__main__', '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1007a5be0>, '__builtins__': <module 'builtins' (built-in)>}

reload(os) #执行程序的时候，重新读取python的模块，用于对模块进行修改的情况

典型的python文件结构图：

 

六：内置函数：

python安装好之后会有很多内置函数模块已经配置好并且可以按需调用，

all：所有的值都不为false，则整个变量才True，可用于判断用户输入是否完整：

print(all([]),"#空的列表结果为True")
print(all(["a",""]),"有一个空值的列表结果为False")
print(all(["a",0]),"有一个值为0的列表结果为False")
print(all(()),"空元组结果为True")
print(all({}),"空的字典结果为True")
print(all([""]),"#列表有一个空的元素,结果为False")
print(all(["a","b",1,0]),"#要所有的元素都为真,结果才为True,而0等于假,所以结果为False")
print(all({"name":[]}),"value为空的字典也为True")
print(all({"name":0}),"value为0的字典也为True")

执行结果：
True #空的列表结果为True
False 有一个空值的列表结果为False
False 有一个值为0的列表结果为False
True 空元组结果为True
True 空的字典结果为True
False #列表有一个空的元素,结果为False
False #要所有的元素都为真,结果才为True,而0等于假,所以结果为False
True value为空的字典也为True
True value为0的字典也为True

abs（） #返回一个数值的绝对值

>>> abs(-9)
9

any：与all函数作用相反，如果任何迭代的一个元素为ture，或者为空，则返回false 

ascii： 转成ascii码 

bin：转一个整数得到一个二进制的字符串 

bool：转换一个值，得到一个bool类型 

bytearray：返回一个字节数据 

bytes： 根据一个编码转换成字节形式 

callable： 回调函数，如果返回false，则代表回调失败，如果为true，它也仍然可能失败 

chr：返回一个整形数字的Unicode形式，比如97返回a 

classmethod：为函数返回一个类方法 

compile：编译一个资源进入一个代码里或一个AST对象 

complex：创建一个复数的表达式 

delattr：移除一个对象的属性 

dict：创建一个词典结构(类似Map) 

dir：如果没有参数返回本文件的路径，如果有参数返回一个对象的属性列表 

divmod：两个整形数字做相除 

enumerate：可用于指定起始num的排序，如：

list1 = ["沙发","彩电","手机","Mac","汽车"]
for i in enumerate(list1,1):
    print(i)

执行结果：
(1, '沙发')
(2, '彩电')
(3, '手机')
(4, 'Mac')
(5, '汽车')

eval：执行一个表达式，或字符串作为运算 

exec：支持python代码的动态执行 

filter：在一个元组里面过滤出目标字符串 

float：字符串转成浮点类型 

format：格式化字符串 

frozenset：返回一个新的克隆对象 

getattr：获取对象的一个方法的结果，类似于x.foobar 

globals: 返回当前全局的字典表 

hasattr：判断是否有某个属性值，返回true代表有 

hash：取一个对象的hash值 

help：调用系统内置的帮助系统 

hex：转换一个整形数字，为小写的十六进制 

id： 返回一个对象的唯一标识值 

input：从控制台读取数据 

int，转换字符串为int型 

isinstance：判断一个对象是否为该类的一个实例 

issubclass：判断一个类是否为另一个类的子类 

iter： 返回一个可迭代的对象 

len： 返回一个字符串的长度 

list：打印一个集合对象 

locals：更细并返回一个词典的本地标志表 

map：返回一个可迭代的map函数 

max：返回集合里面最大的一个或多个值 

memoryview:返回一个python对象的内部数据 

min：返回集合里面最小的一个或多个值 

next：返回集合里面的下一项数值 

object：返回一个新的对象，是所有的类的父类 

oct：返回一个整形为八进制类型 

open： 打开一个系统文件 

ord：得到一个字符串或unicode类型的ascii数值 

pow：返回的数字n次方值 

print：打印输出语句 

property：返回一个属性值 

range：产生一个数字序列 

repr：返回一个字符串可打印对象 

reversed：反转一个集合 

round：返回一个四舍五入的浮点数 

set：返回一个新的set对象 

setattr：设置一个新的属性值 

slice：返回一个集合的区间集合 

sorted：对一个集合进行排序 

staticmethod：声明返回一个静态方法 

str：将数字类型转换为字符串 

sum：对一个集合里面的值求和 

super：返回一个代理父类的对象 

tuple：返回一个不可变的元组 

type：返回一个对象的类型 

vars：返回对象的属性 

zip:返回组合一个对等的项 

__import__： 比import高级的导入方法  

quit，exit，copyright，license，credits