首页 > 其他 > 详细

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

时间:2016-02-04 06:41:31      阅读:245      评论:0      收藏:0      [点我收藏+]

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

 

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

原文:http://www.cnblogs.com/zhang252709/p/5180871.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!