Preparatory Class-Day7------序列类型---------字典(Dictionary)、集合（Set）

##  字典  ##

一. 定义

(1) 字典名 = {key1:value1,  key2:value2 ...} 

    # 如果事先能拼出整个字典，则此方法比较方便

    # 根据同学的名字查找对应同学的成绩
    name = {'tom':90,'jerry':12,'kate':86}

(2) dict(key1 = value1, key2 = value2 ...)

           # 代码比较少，但键必须为字符串型。常用于函数赋值

    >>> b = {1:2}
    >>> b
    {1: 2}
    >>> b = dict(1=2,tom ='猫', sdb = 5)
    SyntaxError: keyword can't be an expression

(3) dict['key'] = value

    # 如果需要动态地建立字典的一个字段，则此方法比较方便

(4) dict(键值序列)

>>> D4 = dict([('name','Bob'),('age',40)])  
>>> D4  
{'age': 40, 'name': 'Bob'} 

    # 如果需要将键值逐步建成序列，则此方式比较有用,常与zip函数一起使用

    # zip() 会把多个迭代对象逐一打包成元组，然后返回这些元组的迭代体(非列表)

>>> D = dict(zip(('name','bob'),('age',40)))  
>>> D  
{'bob': 40, 'name': 'age'}  

(5) dict.fromkeys(序列，value)

    #  如果键的值都相同的话,用这种方式比较好

>>> D3 = dict.fromkeys(['A','B'])  
>>> D3  
{'A': None, 'B': None} 

二. 特点

(1) 键值对 无序存储
(2) 查询速度快。把 key值映射成Hash code(十六位整型地址)，并存入列表；（牺牲空间换时间）
(3) 字典 key要求是不可变类型（字符串、数值、字节、完全不可变元组）
(4) key 不能重复

三. 访问

字典名[key]

>字典键值不存在时，访问报错

        字典名[key] = value 

         如果该键不存在，则新建该键值对

如果key已经存在，则不添加，而是修改键值对（更新字典）

 

>>> name = {'tom':90,'jerry':12,'kate':86}
>>> name['Geoffrey'] = 100
>>> name
{'kate': 86, 'tom': 90, 'Geoffrey': 100, 'jerry': 12}
>>> name['Geoffrey']  = 'fd'
>>> name
{'kate': 86, 'tom': 90, 'Geoffrey': 'fd', 'jerry': 12}
>>> 

四. 字典的操作

1. 不支持 加号(+)、 称号(*)、 大小与(>)
支持 值相等(==)、对象相等(is)、(in)

注意： in只能判断key是否在字典中，不能判断值

print('tom' in name1)

五、字典的相关方法

1. 创建类

name.fromkeys(seq) 

        # 新建 根据不可变类型seq，把序列每一个元素作为key生成字典,字典为统一值(默认为None)。

name.fromkeys((1,2,3,4),('asd', 'asdads'))  
# 其中('asd', 'asdads')为统一的键值

2. 删除类

dict.pop(key) 删除指定键值对,同时返回该键所绑定的value

del dict[key]  删除指定键值对

> 他们都是如果key不存在，报错

3. 访问 

get(key)
print(name.get('tom')) ----同name[key], 但是如果key不存在，返回None

print(name.get('a', '么有这个key')) --------返回结果也可以自己制定，如 '么有这个key'

>>> name
{'kate': 86, 'tom': 90, 'Geoffrey': 'fd', 'jerry': 12}
>>> print(name.get('a', '么有这个key'))
么有这个key
>>> print(name.get('a'))
None

4. 字典的遍历

（参考自：https://blog.csdn.net/u010159842/article/details/71081024）

>>> D = {'x':1, 'y':2, 'z':3} 

（1）返回所有的键：name.keys()

>>> for key in D.keys():         # 效果同2.x版本中iterkeys()，返回迭代体
        print key, '=>', D[key]    
y => 2  
x => 1  
z => 3  

（2）返回值： name.value()

>>> for value in D.values():           
        print value   
2  
1  
3  

（3）返回所有键值对： name.items() 

>>> for key, value in D.items(): # 返回类似元组的dict_item迭代体         
        print key, '=>', value     
y => 2  
x => 1  
z => 3 

（4）直接访问，用键来访问键值对

>>> for key in D:  
        print key, '=>', D[key]    
y => 2  
x => 1  
z => 3  

5.  由value查找key的几点办法

 (本部分参考自：https://blog.csdn.net/ywx1832990/article/details/79145576)

student = {'小萌': '1001', '小智': '1002', '小强': '1003', '小明': '1004'}

    注意：本部分要求value也满足key的特点：

         (1) 不可变类型

         (2) 不重复   

    方法一： 把字典转化为mx2的二维列表，每个子列表代表一对键值对

>>> student = {'小萌': '1001', '小智': '1002', '小强': '1003', '小明': '1004'}
>>> list(student)                # 直接转换list（）其实只把key转换了
['小萌', '小明', '小智', '小强']
>>> list(student.values())
['1001', '1004', '1002', '1003']
>>> list(student.keys())         # 可以看出，虽然顺序不同，但是键值位置依旧对应
['小萌', '小明', '小智', '小强']
>>> list(student.keys())[list(student.values()).index('1004')]
'小明'

方法二：逐个判断是否值匹配，正确返回对应键

>>> def match(dic, b):
	return [k for k,v in dic.items() if v == b]

>>> match(student, '1004')
['小明']

方法三： 反转键值对1：

反转方法如下几种：

# 方法1 --- 动态赋值
    def method1(d):
        d = d.copy()
        result = {}
        for k,v in d.items():
            result[v] = k
        return result

    # 方法2 --- 生成器
    def method2(d):
        d = d.copy()
        result = {v:k for k,v in d.items()}
        return result

    # 方法3 --- 由值寻找键
    def method3(d):
        d = d.copy()
        # 由键寻找值
        def match(dic, b):
            return [k for k,v in dic.items() if v == b]
        # 先生成key-None,再赋值
        result = {}
        result = result.fromkeys(d.values())
        for k in result.keys():
            result[k] = match(d, k)[0]
        return result

    # 方法4 --- 列表转字典 < 直接转换/动态赋值 >
    def method4(d):
        d = d.copy()
        key = d.keys()
        val = d.values()
        data = list(zip(key, val))

        # 方法4-1
        result1 = {}
        for i in range(len(data)):
            result1[data[i][1]] = data[i][0]

        # 方法4-2
        result2 = dict(zip(val, key))

        return result1, result2

在反转后，可以由值寻找键：

>>> new_dict = method2(student)
>>> new_dict ['1004']
小明

##  集合  ##

> 就像只 存储了字典中的key一样，本质是 value为None的字典
> 跟列表差的远

一. 创建

集合名 = {元素1, 元素2, 元素3, ...}
集合相当于是'值为None的字典'
a = {'A', 'b', 'C', 'C'，(1,2,3,4), b'23b'}

二. 特点：

1. 不重复(如上a,重复元素'C'会自动覆盖)
2. key不可变，必须是不可变类型
3. 无序

三. 运算符

不支持* + >
支持 is in ==

四. 集合等相关方法

1.添加

s.add()

2.删除指定内容元素，不存在报错

s.remove(obj)

s.pop(index=-1)

3. 遍历

# 集合不能使用索引获取元素

for i  in  s:

##  数据转换  ##

列表     list 
元组     turple
字典      dict
集合     set

s = 'abc'

----一下要求参数是可迭代对象即可

list(s) turple(s)set(s)dict(tom=1, jerry=2)