Python中字典和集合学习小结

时间:2022-09-14 09:02:27

映射类型:

    表示一个任意对象的集合,且可以通过另一个几乎是任意键值的集合进行索引

    与序列不同,映射是无序的,通过键进行索引

        任何不可变对象都可用作字典的键,如字符串、数字、元组等

        包含可变对象的列表、字典和元组不能用作键

        引用不存在的键会引发KeyError异常

1)字典       

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
dict  { }  空字典
     { key1:value1,key2:value2,... }
   字典在其它编程语言中又称作关联数组或散列表;
 通过键实现元素存取;无序集合;可变类型容器,长度可变,异构,嵌套
 支持的操作:
   len(D)           返回D中的项目数           
   D[k]            返回D中键k的值
   D[k] = x          将D[k]的值设为x         
         >>> d1 = {'x':1,'y':2,'z':3}
         >>> d1['x']
         1
         >>> d1['z']         通过键索引
         3
   del D[k]          从D中删除D[k]
         >>> del d1['x']
         >>> d1
         {'y': 2, 'z': 3}
   k in D           如果k是D中的值,则返回True
  支持的方法:
   D.clear()          清除所有元素
   D.copy()          复制一个副本
         >>> d1 = {'x':1,'y':2,'z':3}
         >>> id(d1)
         45320640
         >>> d2 = d1.copy()        深复制
         >>> id(d2)
         45997776     
         >>> d3 = d1            浅复制
         >>> id(d3)
         45320640              d1、d3指向同一对象,d2指向另一对象
   D.get(k[,d])        取得对应键的值,若不存在则返回d(默认为空)
         >>> d1.get('y')
         2
   D.has_key(k)        是否存在键值,返回TrueFalse.(仅在pyhton2中使用)
   D.items()          转换为(key,value)元组组成的列表
         >>> d1.items()
         [('y', 2), ('x', 1), ('z', 3)]
         >>> t1,t2,t3 = d1.items()
         >>> t1
         ('y', 2)
         >>> t2
         ('x', 1)
         >>> t3
         ('z', 3)
         >>> m1,m2 = {'x':1,'y':2}
         >>> print m1
         'y'
         >>> print m2
         'x'                 保存的是键,而不是值!!!
   D.values()         值列表
         >>> d1.values()
         [2, 1, 3]
   D.keys()          键列表
         >>> d1.keys()
         ['y', 'x', 'z']
   D.pop(k[,d])        弹出指定键值,若不指定则会触发异常
         >>> d1.pop()
         TypeError: pop expected at least 1 arguments, got 0
         >>> d1.pop('x')
         1
         >>> d1
         {'y': 2, 'z': 3}
   D.popitem()         随机弹出 
         >>> d1.popitem()
         ('y', 2)
         >>> d1.popitem()
         ('z', 3)
         >>> d1.popitem()       
         KeyError: 'popitem(): dictionary is empty'        为空时异常
         >>> d1
         { }
   D.update(m)          合并字典
         >>> d1 = { 'x':1,'y':2,'z':3 }
         >>> d2={'c':'hello','y':66}
         >>> d1.update(d2)
         >>> d1
         {'y': 66, 'x': 1, 'c': 'hello', 'z': 3}       若键存在则会覆盖,不存在就添加 
   D.iteritems()          返回一个迭代器对象
         >>> d1 = { 'x':1,'y':2,'z':3 }
         >>> i1 = d1.iteritems()
         >>> i1.next()          使用next方式遍历每一个元素
         ('y', 2)
         >>> i1.next()
         ('x':1)
         >>> i1.next()
         ('z':3)
         >>> i1.next()
         StopIteration          遍历结束后不会重新开始
   D.iterkeys()    ->   an iterator over the keys of D
         >>> i2 = d1.iterkey()
         >>> i2.next()
         'y'
   D.itervalues()   ->   an iterator over the values of D
         >>> i3 = d1.iterkey()
         >>> i3.next()
         2
   D.viewvalues()               返回类似集合方式的字典(值组成)
         >>> d1.viewvalues()
         dict_values([2, 1, 3])
   D.viewitems()    ->   a set-like object providing a view on D's items(键值对)
         >>> d1.viewitems()
         dict_items([('y', 2), ('x', 1), ('z', 3)])
   D.viewkeys()    ->   a set-like object providing a view on D's keys
         >>> d1.viewkeys()
         dict_keys(['y', 'x', 'z'])
         >>> d2 = dict(x=1,y=2,z=3)       定义字典另一种方式
         >>> d2
         {'y': 2, 'x': 1, 'z': 3}
 补充:zip  返回元组组成的列表
     >>> zip('xyz','123')
     [('x', '1'), ('y', '2'), ('z', '3')]      一一对应生成列表
     >>> zip('xyzm','123')
     [('x', '1'), ('y', '2'), ('z', '3')]      多余项被舍弃
     >>> zip('xyz','123','qer')
     [('x', '1', 'q'), ('y', '2', 'e'), ('z', '3', 'r')]       
     >>> dict(zip('xyz','123'))           构造字典
     {'y': '2', 'x': '1', 'z': '3'}

       2)集合

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
无序排列、可哈希;
 支持集合关系测试
    成员关系测试:
      in
      not in
      迭代
 不支持:索引、元素获取、切片
 集合的类型: set()  frozenset()
        可变    不可变
 没有特定语法格式,只能通过工厂函数创建 
   例:
      >>> s1=set(1,2,3)                   
      TypeError: set expected at most 1 arguments, got 3       错误方式
      >>> s1 = set([1,2,3])                      正确方式
      >>> s1
      set([1, 2, 3])
      >>> type(s1)
      set

  支持的方法和操作:

3)小结

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
如何获取使用帮助:
   获取对象支持使用的属性和方法:dir()
   某方法的具体使用帮助:help(list.pop)
   获取可调用对象的文档字串:print obj.__doc__
 容器、类型、对象:
   1、列表、元组、字典字面量可在无换行符下分布在多行内,最后一个字符后可跟逗号(若空则不可使用) 
   2、所有对象都有引用计数(sys模块中getrefcount方法);
       >>> import sys
       >>> s1
       set([1, 2, 3])
       >>> sys.getrefcount(s1)         查看s1的引用计数
       3
   3、列表和字典都支持两种类型的复制操作:浅复制和深复制;深复制可使用copy模块中的deepcopy()实现。
   4Python中的所有对象都是“第一类的”,这意味着使用标识符命名的所有对象都具有相同状态,于是,能够命名所有对象都可以直接当数据进行处理;
   5、所有序列都支持迭代;(非负整数的有序集合)
   6、所有序列都支持的操作和方法:
     s[i]      索引        s[i:j]   切片     
     s[i:j:stride]  扩展切片      len(s)
     min(s)     max(s)       sum(s)
     all(s)     所有为true     any(s)   任意为true
     s1 + s2: 连接            s1 * N: 重复
     成员关系判断:
       obj in s1
       obj not in s1
   7、可变序列的操作:
     s[index] = value    元素赋值
     s[i:j] = t       切片赋值
     s[i:j:stride] = t    扩展切片赋值
     del s[index]      元素删除
     del s[i:j]       切片删除
     del s[i:j:stride]    扩展切片删除
   引用计数和垃圾回收:
     所有对象都有引用计数
       给对象分配一个新名称或将其放入一个容器内,其引用计数都会增加
       del语句或为变量重新赋值时,其引用计数会减少
       sys.getrefcount()可以获得对象的当前引用计数
     一个对象的引用计数器归零时,它将被垃圾收集机制回收

以上所述是小编给大家介绍的Python中字典和集合学习小结,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持!

原文链接:http://www.cnblogs.com/fanison/p/7128040.html