Python字典

一、字典简介

字典是一种可变数据模型。
字典的值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组，键不可重复。
字典是Python中唯一的映射类型，key-value(哈希表)，字典对象是可变的，但键必须用不可变对象。

二、字典的定义

1.定义字典有三种方式：

    d = {'key1':'value1','key2':'value2',}       #简单字典定义
    d1 = dict(key1 = 'value1',key2 = 'value2')   #工厂函数
    d2 = {}.fromkeys(['key1','key2'])            #字典的fromkeys方法

2.定义一个空字典

    In [2]: d = dict()

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

    In [4]: d1 = {}

    In [5]: type(d1)
    Out[5]: dict

3.定义一个包含内容的简单字典

    In [8]: d = {'key1':'value1','key2':'value2'}

    In [9]: d
    Out[9]: {'key1': 'value1', 'key2': 'value2'}

    In [11]: d1 = dict(key1='value1',key2='value2')

    In [12]: d1
    Out[12]: {'key1': 'value1', 'key2': 'value2'}

    In [21]: d2 = {}.fromkeys(['key1','key2'])   #通过fromkeys方法创建的字value默认为None

    In [23]: d2
    Out[23]: {'key1': None, 'key2': None}

4.定义一个复杂字典

    info = {
         'A':{
             'name': 'A',
             'gender':'male',
             'age':18,
             'likes':'music'
         },

         'B': {
             'name': 'B',
             'gender': 'female',
             'age': 18,
             'likes':'reading'
         },
     }

三、字典的操作

1.字典的增删改查

 In [1]: d = dict(a=1, b=2, aa=3)

 In [2]: d
 Out[2]: {'a': 1, 'aa': 3, 'b': 2}

 In [3]: d['abc']=2  #若有对应key则更新value，若无添加key与value

 In [4]: d   #发现dict是无序数据类型
 Out[4]: {'a': 1, 'aa': 3, 'abc': 2, 'b': 2}

 In [29]: d['abc']  #使用key访问对应value
 Out[29]: 2

 In [30]: for key in d:
    ...:     print d[key]
    ...:     
 3
 1
 2
 2

 In [31]: del d['abc']  #删除key为'abc'的项

 In [32]: d
 Out[32]: {'a': 1, 'aa': 3, 'b': 2}

 In [33]: del d  #删除字典d

 In [34]: d
 ---------------------------------------------------------------------------
 NameError                                 Traceback (most recent call last)
 <ipython-input-34-e29311f6f1bf> in <module>()
 ----> 1 d

 NameError: name 'd' is not defined

2.字典的特性

不可行的特性：索引， 切片， 连接， 重复， (因为dict是无序的数据类型)
可行的特性：成员操作符

 In [5]: d[0]
 ---------------------------------------------------------------------------
 KeyError                                  Traceback (most recent call last)
 <ipython-input-5-123a9cc6df61> in <module>()
 ----> 1 d[0]

 KeyError: 0

 In [6]: d[-1]
 ---------------------------------------------------------------------------
 KeyError                                  Traceback (most recent call last)
 <ipython-input-6-1bab3c6dc314> in <module>()
 ----> 1 d[-1]

 KeyError: -1

 In [7]: d[::]
 ---------------------------------------------------------------------------
 TypeError                                 Traceback (most recent call last)
 <ipython-input-7-fabb8133b255> in <module>()
 ----> 1 d[::]

 TypeError: unhashable type

 In [8]: d
 Out[8]: {'a': 1, 'aa': 3, 'abc': 2, 'b': 2}

 In [9]: d1 = dict(a=3,e=5,f=7)

 In [10]: d1
 Out[10]: {'a': 3, 'e': 5, 'f': 7}

 In [11]: d + d1
  ---------------------------------------------------------------------------
 TypeError                                 Traceback (most recent call last)
 <ipython-input-25-c88049db0609> in <module>()
 ----> 1 d + d1

 TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

 In [13]: d
 Out[13]: {'a': 1, 'aa': 3, 'abc': 2, 'b': 2}

 In [14]: 'a' in d
 Out[14]: True

 In [15]: 'c' in d
 Out[15]: False

四、字典的内置方法

1.字典的所有内置方法

 In [36]: d.
 d.clear       d.has_key     d.itervalues  d.setdefault  d.viewkeys
 d.copy        d.items       d.keys        d.update      d.viewvalues
 d.fromkeys    d.iteritems   d.pop         d.values      
 d.get         d.iterkeys    d.popitem     d.viewitems 

2.常用方法

 dict.clear() #删除字典内所有元素
 dict.copy() #返回一个字典的浅复制
 dict.fromkeys(seq[, val]) #创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
 dict.get(key, default=None) #返回指定键的值，如果值不在字典中返回default值
 dict.has_key(key) #如果键在字典dict里返回true，否则返回false
 dict.items() #以列表返回可遍历的(键, 值) # 元组数组
 dict.keys() #以列表返回一个字典所有的键
 dict.setdefault(key, default=None) #和get() #类似, 但如果键不存在于字典中，将会添加键并将值设为default
 dict.update(dict2) #把字典dict2的键/值对更新到dict里
 dict.values() #以列表返回字典中的所有值
 dict.pop(key[,default]) #删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
 dict.popitem() #随机返回并删除字典中的一对键和值。

Eg：Python中没有switch结构，请模拟出switch结构

1.使用if语句实现switch

 Num1 = input("input first num: ")
 do = raw_input("input what want to do: ")
 Num2 = input("input second num: ")
 if do == '+':
     print Num1 + Num2
 elif do == '-':
     print Num1 - Num2
 elif do == '*':
     print Num1 * Num2
 elif do == '/':
     print Num1 / Num2
 else:
     print "wrong"

2.使用dict实现switch

 from __future__ import  division

 Num1 = input("input first num: ")
 do = raw_input("input what want to do: ")
 Num2 = input("input second num: ")
 Dict = {
     '+':Num1 + Num2,
     '-':Num1 - Num2,
     '*':Num1 * Num2,
     '/':Num1 / Num2,
 }

 print Dict.get(do)