6——散列类型、运算符优先级、逻辑运算

集合特性

唯一性：集合中的元素具有唯一性，不存在两个相同的元素

无序性：集合中的元素是无序的，所以没有存在索引

可变性：集合是可变对象

集合的两种定义方法：

01
In [1]: li = [1, 2, 1, 3]

　In [2]: li
　Out[2]: [1, 2, 1, 3]

　In [3]: set(li)
　Out[3]: {1, 2, 3}

　02

　In [4]: se = {1, 2.3, 'a', 'a', True}

　In [5]: se
　Out[5]: {2.3, True, 'a'}

集合的增删改查

01增：add 

In [7]: se.add(9)                                                

In [8]: se                                                       
Out[8]: {2.3, 9, True, 'a'}

02删：pop

In [9]: se.pop() 
Out[9]: 'a'

In [10]: se 
Out[10]: {True, 2.3, 9}

索引删除：remove

In [11]: se.remove(9)                                            

In [12]: se                                                      
Out[12]: {True, 2.3}

03改：update(可添加多个数据)

In [13]: se.update({12, 89, 546, 'dgh', 'ssa'})                  

In [14]: se                                                      
Out[14]: {12, 2.3, 546, 89, True, 'dgh', 'ssa'}

In [15]: s2 = {12, 58, 63}  

04：查：isdisjoint（有交集返回False）

In [19]: se.isdisjoint(s2)                                       
Out[19]: False

issubset　(判断是否包含于)

issuperset (判断是否包含)

字典特性

键唯一性：字典中的键(key)具有唯一性，不存在两个相同的键(key)

无序性：字典中的键也是无序的，所以不能通过索引取值

可变性：字典是可变对象，但是字典的键(key)必须是不可变对象

In [1]: di = {'a':97, 'b':98}                                    

In [2]: di                                                       
Out[2]: {'a': 97, 'b': 98}

In [7]: dict(a=1,b=2)                                            
Out[7]: {'a': 1, 'b': 2}

如何去定义一个空的字典或集合

In [3]: d = {}                                                   

In [4]: type(d)                                                  
Out[4]: dict

In [5]: s = set()                                                

In [6]: type(s)                                                  
Out[6]: set

修改和添加：(直接输入即可)

di['a'] = 2
di['b'] = 3

字典的增删除改查

01增：copy

fromkeys（返回新字典，值都是一样的）

In [13]: di.fromkeys('abcd',2)                                   
Out[13]: {'a': 2, 'b': 2, 'c': 2, 'd': 2}

setdefault（有则查，无则增）

In [14]: di.setdefault('a')                                      
Out[14]: 97

02删：clear

pop（可以指定删除某个字典）

In [17]: di.pop('a')                                             
Out[17]: 97

poppitem（随机删除一组）

In [20]: di.popitem()                                            
Out[20]: ('e', 96)

03改：update（可以增加，修改某组的值）

In [22]: di.update({'a':97,'c':69})                              

In [23]: di                                                      
Out[23]: {'a': 97, 'b': 98, 'c': 69}

04查：get

In [24]: di.get('a')                                             
Out[24]: 97

keys（所有的键）

In [27]: di.keys()                                               
Out[27]: dict_keys(['c', 'a', 'b'])

values（所有的值）

In [29]: list(di.values())                                       
Out[29]: [69, 97, 98]

items（键值对的形式）

In [30]: list(di.items())                                        
Out[30]: [('c', 69), ('a', 97), ('b', 98)]

 

必须掌握：集合定义    集合的交  并   差
必须掌握：常见的运算符的用法
必须掌握：字典的定义   字典的 get   items   keys   pop   popitem   update 方法
必须掌握：三种逻辑运算

 

转载于:https://www.cnblogs.com/Djan-go/p/9904028.html