第 3 天 set集合 字典 队列 函数

1、set 无序不重复集合

1.1创建一个名为s1的set集合对象
 1 >>> s1 = set() 

1.2向集合中添加元素add（）方法:

1 >>> s1 = set()
2 >>> s1.add('alex')
3 >>> s1
4 {'alex'}
5 >>>

set的应用场景：
访问过，就把访问过的元素放入set，最后判断set中 是否存在已访问的元素！
set的优点：
set 访问速度快，解决的运算重复的问题！

1 >>> l1 = ['j','k','j','o','k']
2 >>> s2 = set(l1)
3 >>> s2
4 {'k', 'j', 'o'} ##移除重复元素
5 >>>

 

返回2个集合的不同元素：difference(),difference_update()

1 >>> s2=set(['alex','jim','jim','eric','tony','alex'])
2 >>> s2
3 {'jim', 'eric', 'alex', 'tony'} ##使用有重复元素的列表创建set集合，set会剔除重复个数，只留单个！ (移除重复元素的功能！)
4 >>> 
5 >>> s2.difference(['jim','eric']) ##set的difference()方法，把2 个set中的元素进行对比，返回不同的元素列表！（即创建新的集合）
6 {'alex', 'tony'} ##返回的新的集合
7 >>> 

difference() 没有改变原来的集合，只是生成，并返回了一个新的集合！

 

1 >>> s2 ##
2 {'jim', 'eric', 'alex', 'tony'}
3 ## difference_update()修改了原来s2集合的元素。修改的元素为 difference_update()的参数的不同参数！
4 >>> s2.difference_update(['jim','eric']) ##修改后并未创建(或返回)新的集合，而是在原来集合上进行修改！
5 >>> s2 ##原来的s2集合被修改了！
6 {'alex', 'tony'}
7 >>>

 

 

difference()与 difference_update()的区别：
difference() 没有修改原来的集合，只是返回了 不同的元素。
difference_update()把原来的集合 修改为了 返回不同的元素的集合！

移除元素discard()方法：

 1 >>> s1 = set(['j','k','j','o','k'])
 2 >>> s1
 3 {'o', 'j', 'k'}
 4 >>> s1.discard('o')
 5 >>> s1
 6 {'j', 'k'}
 7 >>> s1.discard('k')
 8 >>> s1
 9 {'j'}
10 >>>

 

取2 个集合的交集intersection()方法：

1 >>> s1 = set(['j','k','j','o','k'])
2 >>> s2 = set(['k','1','3','j'])
3 >>> s1.intersection(s2)
4 {'j', 'k'}
5 >>> s2.intersection(s1)
6 {'j', 'k'}
7 >>>

 

判断2 个集合是否有交集isdisjoint()，没有交集返回True，有交集返回False！

 1 >>> s1
 2 {'o', 'j', 'k'}
 3 >>> s2
 4 {'j', '1', 'k', '3'}
 5 >>> s3
 6 {'l', 'e', 'a', 'x'}
 7 >>> s3.isdisjoint(s1)
 8 True
 9 >>> s3.isdisjoint(s2)
10 True
11 >>> s1.isdisjoint(s2)
12 False
13 >>> s2.isdisjoint(s1)
14 False
15 >>> s2.isdisjoint(s3)
16 True
17 >>> s1.isdisjoint(s3)
18 True
19 >>>

 

判断是否是子集 issubset()：

1 >>> s1
2 {'o', 'j', 'k'}
3 >>> s4 = set(['o', 'j'])
4 >>> s4
5 {'o', 'j'}
6 >>> s4.issubset(s1)
7 True
8 >>>

 

判断是否是父集issuperset():

1 >>> s1
2 {'o', 'j', 'k'}
3 >>> s4
4 {'o', 'j'}
5 >>> s4.issuperset(s1)
6 False
7 >>> s1.issuperset(s4)
8 True
9 >>>

 

移除元素，并返回移除的元素pop():

1 >>> s3
2 {'l', 'e', 'a', 'x'}
3 >>> s3.pop()
4 'l'
5 >>> 
6 >>> s3
7 {'e', 'a', 'x'}
8 >>>

 

指定元素进行移除操作remove()，不返回被移除的元素：

1 >>> s3
2 {'e', 'a', 'x'}
3 >>> s3.remove('a')
4 >>> s3
5 {'e', 'x'}

 

pop() 和remove()的区别：
pop() 移除第一个元素(从第一个元素开始移除！)，并返回被移除的元素.不带参数！
remove() 指定要移除的元素，不返回信息。需要传入指定元素作为参数！


差集symmetric_difference：

 1 >>> s1 = set(['j','3'])
 2 >>> s1
 3 {'j', '3'}
 4 >>> s2
 5 {'j', '1', 'k', '3'}
 6 >>> s1.symmetric_difference(s2)
 7 {'1', 'k'} ##返回 2 个集合相差的集合！
 8 >>> s1
 9 {'j', '3'}
10 >>> s2
11 {'j', '1', 'k', '3'}
12 >>>

 

difference()和symmetric_difference()的区别：

 1 >>> s1 = set(['2','3','4','5','6'])
 2 >>> s2 = set(['3','5','6','8'])
 3 >>> s1.difference(s2) ##以s1 为参考，循环s2 
 4 {'2', '4'}
 5 >>> s1.symmetric_difference(s2) ##分别以s1 、s2为参考，分别循环s1和s2
 6 {'4', '2', '8'}
 7 >>> 
 8 >>> s2.difference(s1)
 9 {'8'}
10 >>> s2.symmetric_difference(s1)
11 {'4', '2', '8'}
12 >>>

 


把2个集合相差的元素 更新到原来的集合中symmetric_difference_update（）

 1 >>> s1
 2 {'j', '3'}
 3 >>> s2
 4 {'j', '1', 'k', '3'}
 5 >>> s1.symmetric_difference_update(s2)
 6 >>> s1
 7 {'1', 'k'}
 8 >>> s2
 9 {'j', '1', 'k', '3'}
10 >>>

 


取2 个集合的并集union()：

1 >>> s1
2 {'1', 'k'}
3 >>> s2
4 {'j', '1', 'k', '3'}
5 >>> s1.union(s2)
6 {'1', 'k', '3', 'j'}
7 >>>

 

更新集合元素update():

 1 >>> s1
 2 {'1', 'k'}
 3 >>> s2
 4 {'j', '1', 'k', '3'}
 5 >>> s1.update(s2)
 6 >>> s1
 7 {'1', 'k', '3', 'j'}
 8 >>> s2
 9 {'j', '1', 'k', '3'}
10 >>>

 

set的应用场景：
old_dict = {
"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
"#2":{ 'hostname':'h2', 'cpu_count': 2, 'mem_capicity': 80 }, ##需要删除的条目
"#3":{ 'hostname':'h3', 'cpu_count': 2, 'mem_capicity': 80 } ##需要更新到new_dict中的条目
}

new_dict = {
"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 },
"#3":{ 'hostname':'h3', 'cpu_count': 2, 'mem_capicity': 80 }, ##需要添加的条目
"#4":{ 'hostname':'h4', 'cpu_count': 2, 'mem_capicity': 80 } ##需要更新到new_dict中的条目

}

old_set = set(old_dict.keys()) ##{'#2', '#1', '#3'}
new_set = set(new_dict.keys()) ##{'#1', '#4', '#3'}

# print(new_set)

##获取要更新的集合(获取new_dict和old_dict 的key的交集{'#1', '#3'})
update_set = old_set.intersection(new_set)
# print(update_set) ##{'#1', '#3'}


##old 集合和new 集合的差集 (该集合只有old集合中有，是要删除的集合)
delect_set = old_set.symmetric_difference(update_set)
# print(delect_set) ##{'#2'}

## 需要添加的集合
add_set = new_set.symmetric_difference(update_set)
print(add_set) ##{'#4'}

计数器counter
counter是对字典的补充,用于追踪值的出现次数！它具备字典的所有功能，还拥有自己的功能！

 1 import collections
 2 c = collections.Counter('symmetric_difference')
 3 print(c)
 4 Counter({'e': 4, 'c': 2, 'r': 2, 'f': 2, 'm': 2, 'i': 2, 'n': 1, 't': 1, 's': 1, 'y': 1, 'd': 1, '_': 1})
 5 
 6 for i in c.elements(): ##打印出原生字符元素
 7 print(i)
 8 r
 9 r
10 e
11 e
12 e
13 e
14 d
15 m
16 m
17 t
18 y
19 c
20 c
21 _
22 f
23 f
24 i
25 i
26 n
27 s
28 for k,v in c.items(): ##统计字符
29 print(k,v)
30 n 1
31 e 4
32 c 2
33 r 2
34 f 2
35 t 1
36 s 1
37 m 2
38 i 2
39 y 1
40 d 1
41 _ 1

 

 1 d = collections.Counter(['hello','piter','alex'])
 2 print(d)
 3 d.update(['hello','jac']) ##统计增加个数！ (update 添加元素)
 4 print(d)
 5 Counter({'hello': 1, 'alex': 1, 'piter': 1})
 6 Counter({'hello': 2, 'jac': 1, 'alex': 1, 'piter': 1})
 7 
 8 d = collections.Counter(['hello','piter','alex']) （删除元素）
 9 d.subtract(['hello','aliba'])
10 print(d)
11 Counter({'piter': 1, 'alex': 1, 'hello': 0, 'aliba': -1})

 


有序字典orderedDict

 1 dic = collections.OrderedDict()
 2 
 3 dic['k1']='v1'
 4 dic['k2']='v2'
 5 dic['k3']='v3'
 6 
 7 print(dic)
 8 OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
 9 print(dic.pop('k2')) ##获取对应值
10 v2
11 dic.popitem()
12 print(dic)
13 OrderedDict([('k1', 'v1'), ('k2', 'v2')])
14 
15 dic.update({'k1':'kk','k4':'78'}) ##更新字典
16 print(dic)
17 OrderedDict([('k1', 'v1'), ('k2', 'v2')])
18 OrderedDict([('k1', 'kk'), ('k2', 'v2'), ('k4', '78')])

 


9、默认字典

 1 s1 = "{name} is {age}"
 2 l = ["jima","sa"]
 3 
 4 ret = s1.format(name='alex',age='16')
 5 
 6 print(ret)
 7 s1 = "{name} is {age}"
 8 l = ["jima","sa"]
 9 d = {'name':'jima','age':19}
10 # ret = s1.format(name='alex',age='16')
11 ret = s1.format(**d) ##使用 2 个*号作参数
12 print(ret)
13 jima is 19
14 
15 lambda表达式：
16 func = lambda a:a+1 ## a为形参
17 r = func(3) 
18 print(r)
19 4

 

10、可命名元组

1 import collections
2 Mytclass = collections.namedtuple('Mytclass',['x','y','z'])
3 obj = Mytclass(1,3,4)
4 print(obj.x)
5 print(obj.y)
6 print(obj.z)
7 1
8 3
9 4

 

11、队列

 1 import collections
 2 
 3 d = collections.deque()
 4 d.append('1')
 5 d.appendleft('10')
 6 d.appendleft('1')
 7 print(d)
 8 
 9 deque(['1', '10', '1'])
10 
11 c = d.count('1') ##统计 “1” 元素出现次数
12 print(c)
13 2
14 
15 d.extend(['ss','sdw']) ##扩展
16 deque(['1', '10', '1', 'ss', 'sdw'])
17 
18 
19 print(d)
20 d.rotate(2) ##从队列后边取2 个元素放到队列前边
21 print(d)
22 deque(['1', '10', '1', 'ss', 'sdw'])
23 deque(['ss', 'sdw', '1', '10', '1'])

 


12、单向队列

1 import queue
2 q = queue.Queue() ##创建一个单向队列
3 q.put('hello')
4 q.put('dw')
5 print(q.qsize())
6 2
7 print(q.get()) ##先进先出
8 hello

 

函数：
result =Ture
try :
...
except Exception:
result = False
return result

遇到reture时，函数就结束。retrue以下代码就不会执行了！

函数的默认参数：

 1 def show (a1,a2=777): ##a2 = 777为默认参数
 2 print(a1,a2)
 3 
 4 show('s')
 5 s 777
 6 def show (a1,a2=777): ##默认参数放在最后
 7 print(a1,a2)
 8 
 9 show('s','aaa')
10 s aaa
11 
12 指定参数：
13 def show(a1,a2):
14 print(a1,a2)
15 
16 show (a2=121,a1=777) ##指定参数
17 777 121

 

 

动态参数：

 1 def show(*arg): ##1个* 时，转换为元组
 2 print(arg,type(arg))
 3 
 4 show(1) ##(1,) <class 'tuple'>
 5 show(1,2,3,4,55,4) ##(1, 2, 3, 4, 55, 4) <class 'tuple'>
 6 
 7 def show(**arg): ##2 个* 时,转换为字典
 8 print(arg,type(arg))
 9 show(n1=1,n2=4) ##{'n1': 1, 'n2': 4} <class 'dict'>
10 
11 def show(*args,**kwargs): ##组合使用
12 print(args,type(args))
13 print(kwargs,type(kwargs))
14 show(1,2,3,n1=5,n2=11)
15 
16 (1, 2, 3) <class 'tuple'>
17 {'n1': 5, 'n2': 11} <class 'dict'>
18 
19 def show(*args,**kwargs):
20 print(args,type(args))
21 print(kwargs,type(kwargs))
22 l = [11,22,33]
23 d = {'a':'7','b':'77'}
24 show(l,d)
25 ([11, 22, 33], {'a': '7', 'b': '77'}) <class 'tuple'>
26 {} <class 'dict'>
27 
28 def show(*args,**kwargs):
29 print(args,type(args))
30 print(kwargs,type(kwargs))
31 l = [11,22,33]
32 d = {'a':'7','b':'77'}
33 show(*l,**d) ##对应的参数要加对应的*
34 (11, 22, 33) <class 'tuple'>
35 {'a': '7', 'b': '77'} <class 'dict'>

 

 

使用动态参数实现字符串格式化：

1 s1 = "{0} is {1}"
2 l = ["jima","sa"]
3 
4 ret = s1.format(*l) ##使用1 个*号作参数
5 
6 print(ret) ##jima is sa
7 jima is sa

 

posted @ 2016-02-04 03:05  芳草天涯  阅读(188)  评论(0)  编辑  收藏  举报