Python3--散列（集合，字典），逻辑运算符，运算符优先级

1.集合

定义集合：（1）set（）   （2）{}

In [5]: a = {1,2,3,'a','b','c'} # 执行结果：In [5]: a = {1,2,3,'a','b','c'}
In [6]: b = set({1,2,3,'a','b','c'})# 执行结果：In [5]: a = {1,2,3,'a','b','c'}

如果定义一个空集合，只能用set（）：

In [9]: a = {}
In [10]: type(a)
Out[10]: dict   #可以看到，定义空集合时如果用 {} ，它的类型为字典dict，并不是集合
In [11]: b = set()
In [12]: type(b)
Out[12]: set    #类型为集合set

集合的特点：无序，唯一（去重），可变

无序：

In [13]: a = {2,3,1,7,6}
In [14]: a
Out[14]: {1, 2, 3, 6, 7} #可以看到，输出的结果并不像我们所定义的那样

唯一（去重）：

In [23]: a = {1,2,2,0,2,6}
In [24]: a
Out[24]: {0, 1, 2, 6} #只保留了一个2

集合运算：

（1）并：s1 | s2 （s1,s2所有的值）

In [25]: a = {1,6,4,3}
In [26]: b = {2,4,6,8}
In [27]: a | b
Out[27]: {1, 2, 3, 4, 6, 8}

（2）交：s1 & s2  （s1 ，s2共有）

In [28]: a = {1,6,4,3}
In [29]: b = {2,4,6,8}
In [30]: a & b
Out[30]: {4, 6}

（3）差：s1 - s2  (s1中有的s2中没有)

In [31]: a = {1,6,4,3}
In [32]: b = {2,4,6,8}
In [33]: a - b
Out[33]: {1, 3}

（4）与非：s1 ^ s2 （取s1,s2各自独立的元素）

In [34]: a = {1,6,4,3}
In [35]: b = {2,4,6,8}
In [36]: a ^ b
Out[36]: {1, 2, 3, 8}

集合的增删改查：

增：

add()---增加单个元素

In [37]: a = {1,6,4,3}
In [38]: a.add('hello')
In [39]: a
Out[39]: {1, 3, 4, 6, 'hello'}

update()---添加可迭代对象，类似于列表的extend

In [40]: a = {1,6,4,3}
In [41]: a.update('hello')
In [42]: a
Out[42]: {1, 3, 4, 6, 'e', 'h', 'l', 'o'}
In [53]: a.update({'hello':'hi','kk':'m'}) #添加字典
In [54]: a
Out[54]: {1, 2, 3, 5, 7, 9, 'hello', 'kk'} #字典添加的结果为键值

#如果想用update方法添加一个完整的字符串，可以先将字符串转换为列表  eg:a.update(['hello']) 

删：

pop()---随机的抛出一个值

In [54]: a
Out[54]: {1, 2, 3, 5, 7, 9, 'hello', 'kk'}
In [55]: a.pop()
Out[55]: 1

remove()---凭值移除

In [56]: a
Out[56]: {2, 3, 5, 7, 9, 'hello', 'kk'}
In [57]: a.remove('hello')
In [58]: a
Out[58]: {2, 3, 5, 7, 9, 'kk'}

查：

isdisjoint()---有交集返回False

In [59]: a = {2,1,6,4}
In [60]: b = {2,1}
In [61]: a.isdisjoint(b)
Out[61]: False

issubset()---判断是否包含于

In [62]: a = {2,1,6,4}
In [63]: b = {2,1}
In [64]: a.issubset(b) #a是否包含于b，否，所以返回False
Out[64]: False
In [65]: b.issubset(a)
Out[65]: True

issuperset()---判断是否包含

In [66]: a = {2,1,6,4}
In [67]: b = {2,1}
In [68]: a.issuperset(b) #a是否包含b，是，所以返回True
Out[68]: True
In [69]: b.issuperset(a)
Out[69]: False

2.字典：

两种定义字典的方法
    {‘a’:1,  ‘b’:2}    键值对形式 

    dict(a=1, b=2)         使用dict函数

字典的特性：无序，可变，键唯一（不存在两个或多个一样的键值）

字典方法：

<1>clear()---清空字典

In [70]: d = {'a':1,'b':2,'c':3}
In [71]: d.clear()
In [72]: d
Out[72]: {}

<2>copy()函数---浅复制

In [81]: d = {'a':[1,2,3],'b':4}
In [82]: c = d.copy()
In [83]: d['a'][0] = '9' #改变键值'a'的值
In [84]: d
Out[84]: {'a': ['9', 2, 3], 'b': 4}
In [85]: c
Out[85]: {'a': ['9', 2, 3], 'b': 4} #可见浅复制，只复制了表层，一旦某些值发生变化，复制的新字典也会发生变化

<3>get---存在返回对应值，不存在就返回None（不存在时可以自定义返回的值）

In [86]: d = {'a':[1,2,3],'b':4}
In [87]: d.get('a')
Out[87]: [1, 2, 3] # 'a'存在，所以返回'a'对应的值[1,2,3]
In [88]: d.get('v') #'v'不存在，所以返回None，即没有返回任何结果
In [89]: d.get('v','我不在这里哦') #当查找的值不在时，可以自定义返回一个值
Out[89]: '我不在这里哦'

<4>fromkeys---创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。

fromkeys()方法语法：dict.fromkeys(seq[,value])

参数：seq --字典键值序列    value--可选参数，设置键序列（seq）的值

In [1]: seq = ['a','b','c']  #用('a','b','c')--元组,'abc'--字符串 也可以（序列类型）
In [2]: dict. fromkeys(seq)
Out[2]: {'a': None, 'b': None, 'c': None}
[3]: dict. fromkeys(seq,'666')
Out[3]: {'a': '666', 'b': '666', 'c': '666'}
In [4]: dict. fromkeys(seq,'666')

<5>items---返回整个键值对

In [90]: d = {'a':[1,2,3],'b':4}
In [91]: d.items()
Out[91]: dict_items([('b', 4), ('a', [1, 2, 3])]) #返回整个键值对，看上去像列表，但不是
In [92]: list(d.items())  #转换成列表
Out[92]: [('b', 4), ('a', [1, 2, 3])]

<6>keys---返回键的值

In [93]: d = {'a':[1,2,3],'b':4}
In [94]: d.keys()
Out[94]: dict_keys(['b', 'a'])
In [95]: list(d.keys())
Out[95]: ['b', 'a']

<7>values---返回键对应的值

In [96]: d = {'a':[1,2,3],'b':4}
In [97]: d.values()
Out[97]: dict_values([4, [1, 2, 3]])
In [98]: list(d.values())
Out[98]: [4, [1, 2, 3]]

<8>pop---删除指定键，若键存在，则弹出对应的值，若键不存在，可以自定义返回值

In [102]: d = {'a':[1,2,3],'b':4}
In [103]: d.pop('a')
Out[103]: [1, 2, 3]
In [104]: d.pop('c','哈哈')
Out[104]: '哈哈'

<10>popitem---随机删除一键值对（一般删除末尾键值对）

In [105]: d = {'a':[1,2,3],'b':4,'c':666}
In [106]: d.popitem()
Out[106]: ('c', 666)

<11>setdefault---有则查，无则增

In [112]: d = {'a':[1,2,3],'b':4,'c':666}
In [113]: d.setdefault('a')
Out[113]: [1, 2, 3] #有要查的键，则返回键对应的值
In [114]: d.setdefault('d')
In [115]: d
Out[115]: {'a': [1, 2, 3], 'b': 4, 'c': 666, 'd': None}  #不存在要查的键，则添加进来，但是键对应的值默认为None

<12>update---相当与增加了字典的内容

In [117]: d = {'a':[1,2,3],'b':4,'c':666}
In [118]: d.update({'1':'a'})
In [119]: d
Out[119]: {'1': 'a', 'a': [1, 2, 3], 'b': 4, 'c': 666}

3.逻辑运算符

（1）查看对象类型

type---直接给出结果，某某是什么类型的

In [6]: seq = ('a','b','c')
In [7]: type(seq)
Out[7]: tuple

isinstance---判断某某是不是什么类型的

In [8]: seq = ('a','b','c')
In [9]: isinstance(seq,str) 
Out[9]: False
In [10]: isinstance(seq,tuple)
Out[10]: True

（2）比较运算符：==  ， ！=

（3）如果有多个条件：

01.判断语句1  and  判断语句2  （同真为真）

02.判断语句1  or    判断语句2    （一真则真）

03.not   判断语句1    

4.运算符优先级