一.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的调用显然用递归这个词汇不合适。
从字面上理解“迭代”和“递归”也是不同的概念。“迭代”是重复某一过程，“递归”是调用自身。即“迭代”是循环操作，“递归”是且套操作。