python 基础 1.5 python数据类型（四）--字典

一.python 数据类型--字典

1.用字符串存储信息，如：存储“姓名，身高，性别”：

In [1]: info='Tom 170 M' //字符串存储信息

In [3]: info[0:3] //字符串提取人名

Out[3]: 'Tom'

2.用列表存储信息

In [10]: list1 = ['name','age']

In [11]: list2 = ['tom','20']

In [12]: list3 = ['mike','30']

In [13]: zip(list1,list2) //zip函数可以把两个列表合在一起，从上一个列表取个值，从下个列表取个值

Out[13]: [('name', 'tom'), ('age', '20')]

In [14]: zip(list1,list3)

Out[14]: [('name', 'mike'), ('age', '30')]

3.字典用大括号{}表示。字符串是引号，列表是中括号[],元组是小括号（），字典是大括号{}。

3.1》字典是python中的唯一的映射类型（哈希表）

3.2》字典对象是可变的，但是字典的键必须用不可变对象，一个字典中可以使用不同类型的键值

3.3》字典的方法：

--keys()

-values()

-items()

3.4》字典中，keys和values是一对，values是可变的，但是键keys是不可变的，在字典中keys是唯一的不同冲突。

4.创建一个字典

In [15]: dic = {} //创建一个空字典

In [16]: type(dic) //查看字典dic的类型

Out[16]: dict //字典dic类型为字典

In [17]: dic = {'a':1,1:123}

2对keys：values

In [18]: dic

Out[18]: {1: 123, 'a': 1} //字典显示的时候是无序的，不是先创建谁，就先显示谁

说明：字典中keys是不可变的，所以keys不能是列表，字符串，可以是元组。

In [19]: dic = {'a':1,1:123,('a','b'):'hello'} //用元组作为keys是可以的，因为元组是不可变的。

In [20]: dic

Out[20]: {1: 123, 'a': 1, ('a', 'b'): 'hello'}

In [21]: len(dic) //查看字典的长度

Out[21]: 3 //有三个元素

In [8]: dic //dic 字典

Out[8]: {'a': 456, 'b': 678}

In [9]: dic = {'a':456,'b':678,[5]:6} //用列表定义字典中的key值时报错，因为key是不可变的，而

列表是可变的。

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

<ipython-input-9-150200d77d1e> in <module>()

----> 1 dic = {'a':456,'b':678,[5]:6}

TypeError: unhashable type: 'list'

5.字典里的方法

In [22]: dic.

dic.clear dic.has_key dic.itervalues dic.setdefault

dic.copy dic.items dic.keys dic.update

dic.fromkeys dic.iteritems dic.pop dic.values

dic.get dic.iterkeys dic.popitem

5.1》In [22]: dic.keys() //查看字典里的键值，可以显示出dic字典里对应的键值，已列表的形式显示出来

Out[22]: ['a', 1, ('a', 'b')]

In [23]: dic.values() //查看字典里的values值，可以显示出dic字典里对应的values值，已列表的形式显示出来

Out[23]: [1, 123, 'hello']

5.2》In [24]: help(dic.get) //查看dic.get的方法

Help on built-in function get:

get(...)

D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.

说明：当k在字典里的时候返回的是K值，当K不在字典里的时候，返回的是values值

In [25]: dic //字典里的元素

Out[25]: {1: 123, 'a': 1, ('a', 'b'): 'hello'}

In [22]: dic.keys() //查看字典里的key值

Out[22]: ['a', 1, ('a', 'b')]

In [23]: dic.values() //查看字典里的values值

Out[23]: [1, 123, 'hello']

In [27]: dic.get('a') //获取键值为‘a’的values值

Out[27]: 1 //values值为1

5.3》通过K值访问字典

In [28]: dic //字典元素

Out[28]: {1: 123, 'a': 1, ('a', 'b'): 'hello'}

In [29]: dic[1] //可以通过keys值访问想对应的values值

Out[29]: 123

In [30]: dic['a']

Out[30]: 1

In [32]: dic[('a','b')]

Out[32]: 'hello'

In [26]: dic['a'] //两种方法都可以通过keys值a，获取到a相对应的values值

Out[26]: 1

In [27]: dic.get('a')

Out[27]: 1

5.4>通过K值可以修改values值

In [33]: dic['a'] //起初字典里的a值对应的values值为1

Out[33]: 1

In [34]: dic['a'] = 2 //修改K值‘a’为2

In [35]: dic //查看变更后的values值，因为key值不可变的

Out[35]: {1: 123, 'a': 2, ('a', 'b'): 'hello'}

In [29]: dic //字典dic

Out[29]: {1: 123, 'a': 666, ('a', 'b'): 'hello'}

In [30]: dic.get('cc') //如果当字典中的keys值不存在时，返回的是空，没有输出

In [31]: dic.get('cc','python') //也可以把字典中不存在的keys值给一个values值=‘python’

Out[31]: 'python'

In [33]: dic //dic字典

Out[33]: {1: 123, 'a': 666, ('a', 'b'): 'hello'}

In [34]: 'b' in dic //判断一个key在不在字典里，返回false说明不在字典里

Out[34]: False

In [35]: 'a' in dic //返回true，说明a在字典里

Out[35]: True

In [36]: dic.has_key('a') //也可以用这种方法判断 a键值在不在字典里，返回true，说明在

Out[36]: True

In [37]: dic.has_key('b')

Out[37]: False

5.5》dic.items() //字典里items方法，他是把字典返回成列表形式

In [38]: dic //字典dic

Out[38]: {1: 123, 'a': 666, ('a', 'b'): 'hello'}

In [39]: dic.items() //dic.items 方法把字典返回成列表形式，并且他把字典里的元素分别以元组的形式保存。最外层是大的列表

Out[39]: [('a', 666), (1, 123), (('a', 'b'), 'hello')]

5.6》dic.copy 的方法

In [44]: dic.copy() //dic.copy 就是复制一个字典

Out[44]: {1: 123, 'a': 666, ('a', 'b'): 'hello'}

In [45]: dic1 = dic.copy() //复制一个字典到一个新的字典里

In [46]: dic1 //新字典dic1与dic字典一样

Out[46]: {1: 123, 'a': 666, ('a', 'b'): 'hello'}

5.7》dic.clear 方法。把整个字典清楚里边所有元素都没了

5.8》In [47]: help(dic.pop) //dic.pop方法

pop(...)

D.pop(k[,d]) -> v, remove specified key and return the corresponding value.

If key is not found, d is returned if given, otherwise KeyError is raise

说明：指定移除K值，并返回移除K值的values值。如果K值不存在的时候，他会报K值的错

In [50]: dic //字典dic里的元素

Out[50]: {1: 123, 'a': 666, ('a', 'b'): 'hello'}

In [51]: dic.pop(1) //通过dic.pop方法，移除K值为1的元素

Out[51]: 123 //通过dic.pop方法移除K值的时候，会返回这个K值对应的values值

In [52]: dic //查看字典dic里的元素，发现K值为1的元素，没有了

Out[52]: {'a': 666, ('a', 'b'): 'hello'}

5.9》dic.update 方法。往字典里边更新，或者把两个字典更新成一个字典。

In [53]: dic //字典dic

Out[53]: {'a': 666, ('a', 'b'): 'hello'}

In [54]: dic1 = {'ty':00,('vb','yu'):88} //创建dic1字典

In [55]: dic.update(dic1) ///把dic1字典加到dic字典里

In [56]: dic //查看新的dic字典

Out[56]: {'a': 666, 'ty': 0, ('a', 'b'): 'hello', ('vb', 'yu'): 88}

In [57]: len(dic) ///dic字典总长度为4

Out[57]: 4

6.创建字典

dic = {} //创建空字典

dic = dict() //通过这种方法也可以创建字典。可以把列表变为字典

应用dict(),创建字典

In [66]: list1 = ['name','age'] //创建列表 list1

In [67]: list2 = ['tom',20] //创建列表2 list2

In [68]: list3 = ['mike',18] //创建3 list3

In [69]: zip(list1,list2) //zip函数是把两个列表合成一个大的列表

Out[69]: [('name', 'tom'), ('age', 20)]

In [71]: dict(zip(list1,list2)) //通过dict函数把列表转化成字典，并把之前元组里的name 变成了keys，tom变成了values。age也是keys，20是values。元组中前一个是keys，后一个是values

Out[71]: {'age': 20, 'name': 'tom'}

In [69]: zip(list1,list2)

Out[69]: [('name', 'tom'), ('age', 20)] //一个大的列表

In [75]: dict([('name', 'tom'), ('age', 20)]) //也可以通过dict函数直接把大列表转化成字典。dict格式：dict()

Out[75]: {'age': 20, 'name': 'tom'}

In [76]: dict(a=10,b=20) //dict也可以传参创建字典

Out[76]: {'a': 10, 'b': 20}

7.dic.fromkeys()，字典元素有相同的值，默认为None。

ddict = {}.fromkeys(('x','y'),100)

dic.fromkeys() 方法适用于字典里的keys值都一样。如下：

In [80]: dic.fromkeys('abc',100) //dic.fromkeys()方法，定义keys a b c 的values值都是100，字典存在dic已经存在的时候才能用fromkeys方法。dic字典元素不会被替换。

Out[80]: {'a': 100, 'b': 100, 'c': 100} //a，b，c values值都是100

In [81]: dic.fromkeys(range(20),100) //通过range函数（范围），创建20个values值都是100的字典，

Out[81]:

{0: 100,

1: 100,

2: 100,

3: 100,

4: 100,

5: 100,

6: 100,

7: 100,

8: 100,

9: 100,

10: 100,

11: 100,

12: 100,

13: 100,

14: 100,

15: 100,

16: 100,

17: 100,

18: 100,

19: 100}

In [84]: dic.fromkeys(range(5)) //如果不给valeus值的话，自动为None，是没有的意思

Out[84]: {0: None, 1: None, 2: None, 3: None, 4: None}

8.总结，创建字典字典

1》In [87]: dict() //也可以通过dict创建空字典

Out[87]: {}

2》In [88]: dict(x=10,y=10) //可以进行传参

Out[88]: {'x': 10, 'y': 10}

3》In [89]: dict([('a',10),('b',20)]) //dict(),括号里边还可以是可迭代的对象。

Out[89]: {'a': 10, 'b': 20}

4》In [90]: dic.fromkeys('abc',100)

Out[90]: {'a': 100, 'b': 100, 'c': 100}

9.总结，访问字典

可以通过keys值进行访问

1》In [91]: dic

Out[91]: {'a': 666, 'ty': 0, ('a', 'b'): 'hello', ('vb', 'yu'): 88}

In [92]: dic['a']

Out[92]: 666

2》通过dic.items 方法进行访问

In [91]: dic

Out[91]: {'a': 666, 'ty': 0, ('a', 'b'): 'hello', ('vb', 'yu'): 88}

In [93]: dic.items() //dic.items 把字典里边的keys和values 变成了元组里边的两个元素存在了列表里

Out[93]: [('a', 666), (('a', 'b'), 'hello'), (('vb', 'yu'), 88), ('ty', 0)]

3》通过for循环的方式访问字典

In [98]: dic

Out[98]: {'a': 666, 'ty': 0, ('a', 'b'): 'hello', ('vb', 'yu'): 88}

In [99]: for k in dic: //通过键值访问dic字典

....: print k //打印k值

....:

a

('a', 'b')

('vb', 'yu')

ty

4》通过for循环访问字典里的keys和values值

In [100]: for k in dic:

.....: print k,dic[k] //打印k值及字典里k值对应的values值，逗号表示keys和values值显示在一行

.....:

a 666

('a', 'b') hello

('vb', 'yu') 88

ty 0

In [101]: for k in dic:

.....: print "%s,%s" % (k,dic[k]) // %s 是让元组里的元素“k，dic[k]” 替换的。

.....:

a,666

('a', 'b'),hello

('vb', 'yu'),88

ty,0

In [102]: for k, v in dic.items(): print k,v

a 666

('a', 'b') hello

('vb', 'yu') 88

ty 0

10.可迭代与递归的意思

迭代：指重复执行一个命令，用在python的list里，是指重复调用list对象。将调用list对象返回的数据作为参数传递给一个函数，并有返回的结果，组成一个新的list。

递归：指一个函数执行过程中调用了自己，是对一种计算方法的描述。对于python的list的调用显然用递归这个词汇不合适。

从字面上理解“迭代”和“递归”也是不同的概念。“迭代”是重复某一过程，“递归”是调用自身。即“迭代”是循环操作，“递归”是且套操作。