本章内容
- 字符串（String）
- 元组（Tuple）
- 列表（List）
- 字典（Dictionary）
- 集合（Sets）
前言
这一篇专讲 str、tuple、list、dict、set。这样写对于新手是比较有好处的，因为这一类操作复杂（或者说操作多）的数据类型，操作之间存在着相同点（占多比例）和不同点。要想学好python，最基本的数据类型一定要深入掌握。
工具：Python shell 3.x 和 pycharm 版本：3.x
一、字符串
字符串的使用需要用引号括起来，例如：name = "Lyon"；这里name就是一个变量名，而引号里面的 Lyon 则就是变量，该值的类型为 " str" 类型。这就是字符串！
当然如上使用的是双引号，这里其实还可以使用单引号 “ 'Lyon' ” 以及三引号 “ '''Lyon''' ” (或者是"""Lyon"""，单引号双引号都可以)。不过对于三引号，我们通常是表示多行字符串，这样我们就不需要利用 " " （换行符）来进行每一行的换行了。
字符串操作：这是一个重点，对于字符串操作我们应该熟练的掌握。
字符串操作有哪些呢？主要有 拷贝（复制）、拼接、查找、比较、统计、切片、测试、大小写等。我们需要掌握一些比较重要的，当然其他的就自己去学习吧！
在开始详细了解这些操作之前，我们需要记住一个性质：字符串是不可变的，不可变啊不可变！那么你就会问了，既然不可变那么下面的操作是 玩捏？放风筝捏？想知道？操作都掌握了再告诉你。
1.拷贝（复制）
1 >>> a = "Lyon"
2 >>> b = a
3 >>> print(a,b)
4 Lyon Lyon
2.拼接
1 >>> a = "Hello"
2 >>> b = "Lyon"
3 >>> print(a+b)
4 HelloLyon
注：这个方法要特别说明一下，“+”是一个坑，因为使用加号连接2个字符串会调用静态函数string_concat(register PyStringObject *a,register PyObject *b)，这个函数大致的作用呢，就是首先开辟一块a+b大小的内存的和的存储单元，然后把a和b都拷贝进去。一个“+”就是一次啊！那n个字符串拼接，那就是n-1次啊！你想想这玩意在你电脑里面做这些无聊的事情还占你内存，要是我上去就是一大嘴巴子！
1 >>> a = "Lyon"
2 >>> b = "Hello"
3 >>> print(a.join(b))
4 HLyoneLyonlLyonlLyono #HLyon eLyon lLyon lLyon o
可以用join来将list中的元素进行拼接成字符串：' '.join( list ) 即以空字符串连接列表中的每一个元素。
注：.join()：连接2个字符串，可以指定连接符号（符号？你把"Hello"改成“****”（符号）自己试试）
3.查找
1 >>> name = "Lyon"
2 >>> name.index('L') #"L"在"Lyon"的第几个？答案是第一个！
3 0 #那他怎么返回0？因为0就是第一个，下标索引以0开始，列表里我们还能再见！
4 >>> name.index('N') #如果name里面没有就会报错
5 Traceback (most recent call last):
6 File "<stdin>", line 1, in <module>
7 ValueError: substring not found #自己翻译一下，要学会看错误。
4.比较
本来呢，python中有个str.cmp方法来比较两个对象，并根据结果返回一个整数。整数的征服就是数值的大小了。但是在python3中就没有这个方法了，官方文档如下：
The cmp() function should be treated as gone, and the __cmp__() special method is no longer supported. Use __lt__() for sorting, __eq__() with __hash__(), and other rich comparisons as needed. (If you really need the cmp() functionality, you could use the expression (a > b) - (a < b) as the equivalent for cmp(a, b).)
大致的意思呢就是cmp()函数已经走了，如果你真的需要cmp函数，你可以用表达式(a>b)-(a<b)代替cmp(a,b)，看下面2.7的代码：
1 >>> a = "100"
2 >>> b = "50"
3 >>> cmp(a,b) #a>b 负数
4 -1
5 >>> cmp(b,a) #b<a 正数
6 1
在python3中呢，你还可以吧字符串转换成数字再来进行比较哦。
5.统计
1 >>> name = "Lyon"
2 >>> name.count("L") #name中"L"的个数
3 1
6.切片
1 >>> name = "i like Lyon"
2 >>> name[7:10] #不包括10哦
3 'Lyo'
4 >>> name = "i like Lyon"
5 >>> name[7:11]
6 'Lyon'
注：对于切片的问题啊，这里不多讲，到列表再详细的讲，因为啊，列表里面也有切片，而且跟字符串是一样的用法哦。而且切片博大精深！
7.检测
1 >>> name = "Lyon"
2 >>> "L" in name #检测"L"是否在name中，返回bool值
3 True
4 >>> num = "3412313"
5 >>> num.isdigit() #检测num里面是否全都是整数（浮点数都不行）
6 True
7 >>> name = "Lyon"
8 >>> name.isidentifier() #检测name是否可以被当作标标志符，即是否符合变量命名规则
9 True
10 >>> name.find('L') #检测name里面有没有"L"啊，有就返回index同样从0开始
11 0
12 >>> name.find('N') #检测name里面有没有"N"啊，没有就返回-1
13 -1
还有以下方法哦，就不一一举例了。
1 str.startswith(prefix[,start[,end]]) #是否以prefix开头
2 str.endswith(suffix[,start[,end]]) #以suffix结尾
3 str.isalnum() #是否全是字母和数字，并至少有一个字符
4 str.isalpha() #是否全是字母，并至少有一个字符
5 str.isdigit() #是否全是数字，并至少有一个字符
6 str.isspace() #是否全是空白字符，并至少有一个字符
7 str.islower() #S中的字母是否全是小写
8 str.isupper() #S中的字母是否便是大写
9 str.istitle() #S是否是首字母大写的
注：结果全是bool值哟。
8.大小写
1 >>> name = "I am Lyon"
2 >>> name.swapcase() #大小写互换
3 'i AM lYON'
4 >>> name.capitalize() #首字母大写，其它都小写
5 'I am lyon'
6 >>> name.upper() #转换为大写
7 'I AM LYON'
8 >>> name.lower() #转换为小写
9 'i am lyon'
9.更多
1 str.ljust(width,[fillchar]) #输出width个字符，str左对齐，不足部分用fillchar填充，默认的为空格。
2
3 str.rjust(width,[fillchar]) #右对齐
4
5 str.center(width, [fillchar]) #中间对齐
6
7 str.zfill(width) #把str变成width长，并在右对齐，不足部分用0补足
8
9 str.replace(oldstr, newstr, [count]) #把str中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换
10
11 str.strip([chars]) #把str中前后chars中有的字符全部去掉，可以理解为把str前后chars替换为None
12
13 str.lstrip([chars]) #把str前面的去掉
14
15 str.rstrip([chars]) #把str后面的去掉
16
17 str.expandtabs([tabsize]) #把str中的tab字符替换没空格，每个tab替换为tabsize个空格，默认是8个
18
19 str.split([sep, [maxsplit]]) #以sep为分隔符，把str分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符
20
21
22 str.splitlines([keepends]) #把str按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。
23 str.maketrans(from, to) #返回一个256个字符组成的翻译表，其中from中的字符被一一对应地转换成to，所以from和to必须是等长的。
24
25 str.translate(table[,deletechars]) # 使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉。需要注意的是，如果str为unicode字符串，那么就不支持 deletechars参数，可以使用把某个字符翻译为None的方式实现相同的功能。此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。
更多方法可以通过help(str)来了解哟，或者直接看官方文档。
字符串的操作基本呢就以上这些了，但是记不记得我上面说的一句话，字符串是不可变的，那么上面的一堆操作字符串都变成什么样了？那你说字符串不可变不是在瞎扯淡么？那么好重点来了，以上的这些操作，也就是用str中的方法来改变这些字符串的样子，其实是生成了一个新的字符串，而那个旧的呢，依然在内存中。
字符串中的 encode() 和 decode()，即编码的转换问题，对于新手绝对是一个难点，所以我准备单独写一篇关于字符编码的博客。并且主要是在python2.7中的坑比较多，在python3中则基本不会有什么问题。所以捏这里就不多讲，在上面的操作中我也没有说哦。
-->>字符编码篇直通车（当然现在还没有完成，遇到了点小小的问题，我的2.7可能装的是个假的。）
二、元组
上面讲str的时候呢，我是在shell下进行的，现在开始我就要用pycharm，强烈建议新手用这个，Python IDE有很多，pycharm打开速度是慢了点，不过它的功能是毋庸置疑的哦。而且现在很多公司做项目也是用的pycharm。当然了，你也可以用你自己喜欢的。下面开始笔记啦。
元组和字符串一样，元组也是不可修改的。元组使用小括号，元组的创建很简单，只需要在括号中添加元素，并使用逗号隔开即可(在str中并没有怎么说明字符串的创建，因为啊，引号一加，谁还不是字符串呢！)。元组需要掌握的分别有创建、访问、修改、删除、切片、检测等。
1.创建
1 #创建一个带有元素的元组
2 tuple_name = ("Lyon","Alex","Leon",1,2,3)
3 #这样也可以
4 tuple_names = "Lyon","Alex","Leon",1,2,3
5 #创建一个空元组
6 tuple_empty = ()
7 #当元组中只有一个元素，加逗号来消除歧义哟，这是一个好习惯，因为()既可以表示tuple又可以表示数学公式中的小括号
8 tuple_one = ("Lyon",)
2.访问
1 #创建一个元组
2 tuple_name = ("Lyon","Alex","Leon",1,2,3)
3 #访问元组中的第一个元素并打印结果，下标索也是从0开始
4 print(tuple_name[0]) #打印：Lyon
5 #访问元组中第一和第二个元素并打印结果
6 print(tuple_name[0:2]) #打印：('Lyon', 'Alex')
注：结果发现访问单个元素结果是字符串类型哟，而多个则是元组类型。字符串中每个字符就是一个元素，而元组中则是一个数字或者一个字符串就是一个元素。
3.修改
#创建一个元组
tuple_name = ("Lyon","Alex","Leon",1,2,3)
#创建另一个元组
tuple_num = (1,2,3,4,5)
#生成一个新的元组
tuple_total = tuple_name + tuple_num
#打印tuple_total
print(tuple_total) #打印：('Lyon', 'Alex', 'Leon', 1, 2, 3, 1, 2, 3, 4, 5)
#复制元组内元素一次
tuple_total = tuple_name * 2
#打印tuple_total看结果
print(tuple_total) #打印：('Lyon', 'Alex', 'Leon', 1, 2, 3, 'Lyon', 'Alex', 'Leon', 1, 2, 3)
#在列表中可以通过索引取值后进行修改，但是元组里面是非法的哦
tuple_name[0] = "lyon" #这里直接就报错
注：上面就说了的，元组也是不可变的，这里的操作都是生成了一个新的元组。
4.删除
1 #创建一个元组
2 tuple_name = ("Lyon","Alex","Leon",1,2,3)
3 # 删除元组tuple_name
4 del tuple_name
5 #打元组tuple_name
6 print(tuple_name) #这里直接报错：name 'tuple_name' is not defined ，因为已经删除了
7 #下面这种方式也是不行的
8 del tuple_name[0] #这里报错： 'tuple' object doesn't support item deletion
5.切片
如2小点访问中的索引一样，就是利用index（下标）来进行操作。这个呢，还是放到列表中来写。
6.检测
1 #创建一个元组
2 tuple_name = ("Lyon","Alex","Leon",1,2,3)
3 #"Lyon"是否在tuple_name中，打印结果
4 print("Lyon" in tuple_name) #打印 True
7.更多
1 #创建一个元组
2 tuple_name = ("Lyon","Alex","Leon",1,2,3)
3 #计算元组元素个数
4 tuple_len = len(tuple_name)
5 #打印结果
6 print(tuple_len) #打印：6
7 #创建一个元素全为数字的元组
8 tuple_num = (1,2,3,4,5)
9 #返回元组中的最大值
10 print(max(tuple_num)) #打印：5
11 #返回元组中的最小值
12 print(min(tuple_num)) #打印：1
13 #创建一个列表
14 list_name = ["Lyon","Alex","Leon"]
15 #将列表转换为元组
16 tuple_names = tuple(list_name)
17 #打印tuple_names
18 print(tuple_names) #打印：('Lyon', 'Alex', 'Leon')
更多详细资料可以通过help(tuple)来查找哟，或者直接看官方文档。
三、列表
列表是我们以后最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作。接下来就要开始详细说说列表中的基本操作了。列表是可变的，所以操作也会有点多。基本操作有：创建、访问、切片、追加、插入、修改、删除、扩展、拷贝（copy）、统计、排序&翻转、获取下标等。
1.创建
1 #创建一个列表
2 names = ["Alex","Lyon","Leon"]
3 #创建一个空列表
4 names = []
2.访问
1 #创建一个列表
2 names = ["Alex","Lyon","Leon"]
3 #与字符串的索引一样，列表索引从0开始
4 #访问列表中的第一个元素
5 fristname = names[0]
6 #访问列表中第三个元素
7 threename = names[2]
8 #访问列表中最后一个元素
9 endname = names[-1]
10 #访问倒数第二个元素
11 secondlastname = names[-2]
12
13 #注：以上运行时并不会有结果，获取结果应该利用print方法来进行
3.切片
1 #创建一个列表
2 names = ["Alex","Lyon","Leon","CTO","WuHan"]
3 #取下标为1至下标3之间的值，包括1，不包括4
4 cutnames1 = names[1:3]
5 #打印cutnames1
6 print(cutnames1) #打印：['Lyon', 'Leon']
7 #取下标为1至-1的值，不包括-1（-1就是最后一个）
8 cutnames2 = names[1:-1]
9 #打印cutnames2
10 print(cutnames2) #打印：['Lyon', 'Leon', 'CTO']
11 #从第一个到第三个
12 cutnames3 = names[0:3]
13 #从头开始取，0可以省略，跟上面的效果一样
14 cutnames4 = names[:3]
15 #打印cutnames3，cutnames4
16 print(cutnames3,cutnames4) #打印:['Alex', 'Lyon', 'Leon'] ['Alex', 'Lyon', 'Leon']
17 #想取最后一个，只能这样写，切片是不包含后一个参数的
18 cutnames5 = names[3:]
19 #后面的2是代表，每隔一个元素，就取一个
20 cutnames6 = names[0::2]
21 #或者这样
22 cutnames7 = names[::2]
23 #打印cutnames6,cutnames7
24 print(cutnames6,cutnames7) #打印：['Alex', 'Leon', 'WuHan'] ['Alex', 'Leon', 'WuHan']
4.追加
1 #创建一个列表
2 names = ["Alex","Lyon","Leon","CTO","WuHan"]
3 #追加一个元素
4 names.append("New")
5 #打印names
6 print(names) #['Alex', 'Lyon', 'Leon', 'CTO', 'WuHan', 'New']
7
8 #注：append 方法只能追加到列表的最后一位
5.插入
1 #创建一个列表
2 names = ["Alex","Lyon","Leon","CTO","WuHan","New"]
3 #插入到下标1前面
4 names.insert(1,"Insert")
5 #打印names
6 print(names) #['Alex', 'Insert', 'Lyon', 'Leon', 'CTO', 'WuHan', 'New']
7 #如果下标不存在就会插入到最后一个
8 names.insert(7,"NoIndex")
9 #打印names
10 print(names) #['Alex', 'Insert', 'Lyon', 'Leon', 'CTO', 'WuHan', 'New', 'NoIndex']
6.修改
1 #创建一个列表
2 names = ['Alex', 'Insert', 'Lyon', 'Leon', 'CTO', 'WuHan', 'New', 'NoIndex']
3 #把 'WuHan' 改成 'BeiJing'
4 names[5] = 'BeiJing'
5 #打印names
6 print(names)
7 #注：就是通过下标直接改变list本身哟
7.删除
1 #创建一个列表
2 names = ['Alex', 'Insert', 'Lyon', 'Leon', 'CTO', 'BeiJing', 'New', 'NoIndex']
3 #删除下标为7的元素
4 del names[7] #以下标取值删除
5 #打印names
6 print(names) #打印：['Alex', 'Insert', 'Lyon', 'Leon', 'CTO', 'BeiJing', 'New']
7 #删除 'Insert'
8 names.remove("Insert") #remove删除指定元素
9 #打印names
10 print(names) #打印：['Alex', 'Lyon', 'Leon', 'CTO', 'BeiJing', 'New']
11 names.pop() #删除列表的最后一个值
12 #打印names
13 print(names) #打印：['Alex', 'Lyon', 'Leon', 'CTO', 'BeiJing']
8.扩展
1 #创建一个列表
2 names = ['Alex', 'Lyon', 'Leon', 'CTO', 'BeiJing']
3 #创建另一个列表
4 name = ["IT",21,"man"]
5 #将name扩展到names
6 names.extend(name)
7 #打印names
8 print(names) #打印：['Alex', 'Lyon', 'Leon', 'CTO', 'BeiJing', 'IT', 21, 'man']
9
10 #这里还有一个"万恶的'+' "也是可以的
11 print(names + name) #结果是一样的哦
9.拷贝
1 #创建一个列表
2 names = ['Alex', 'Lyon', 'Leon', 'CTO', 'BeiJing',"IT",21,"man"]
3 #拷贝names
4 names_copy = names.copy() # 浅copy
5 #打印names_copy
6 print(names_copy) #打印：['Alex', 'Lyon', 'Leon', 'CTO', 'BeiJing', 'IT', 21, 'man']
注：在python2.7中列表的内置函数是没有copy这个方法的，这是在python3后加的，并且python3也只有有copy（浅copy）这一个方法，用深copy需要我们导入copy模块喲，即 import copy 。
深、浅copy：对于简单的object，shallow copy 和deep copy 是没有区别的。但是对于复杂的object，shallow copy 和deep copy 就会有不一样的结果，这跟python的变量储存方式是脱不开关系的。这么来讲，在python中创建一个变量即为该变量打上一个以该变量名命名的标签，而当我重新赋值时，就会把之前的标签拿下来，打到新的变量上，例如：
1 #为 "Lyon" 打上一个 "a标签"
2 a = "Lyon"
3 #b = a 即给"Lyon"再打上一个 "b标签"
4 b = a
5 #给a重新赋值，那么"Lyon"上的 "a标签" 就会被拿掉
6 a = "New"
7 #打印a
8 print(a) #打印：New
9 #打印b
10 print(b) #打印：Lyon
读取变量其实就相当于到贴有"a、b标签"的 "房子" 里面去拿东西，ab就是这个房子的门牌号啦。a的门牌号发生了改变，你知道变量名是唯一的，也就是说门牌号是唯一的，所以你只看得到最后一次修改的门牌号，以上有两个房子，便于理解我首先定义为房子1和房子2，首先给房子1贴了个门牌号 " a " ，然后又给房子1贴了个门牌号 " b " ，而后我又把房子1的门牌号" a "撕了下来贴到了房子2，所以a的值发生了改变，而b的值是没有变的。
有了上面的列子就好说了，其实shallow copy(浅copy)就是贴 "门牌号"(打标签) 的故事；而deep copy(深copy) 则是符合我们心中的拷贝，就是把原来的东西拷贝一份，于是就有了独立的两份，所以你对其中一份作出改变，另一份并不会发生变化哟。
注：上述中讲的复杂的object。上述说到对于简单的object两者并没有区别，这里我推测：因为就算是 浅copy 也能把简单的object拷贝并独立出来，也就是说他能做一层工作并且也只能做这一层工作，而对于复杂的object，比如list嵌套的object，浅copy只能把第一层的list copy过来，而再下一层就不行啦。还是给个例子吧：
1 #导入copy模块
2 import copy
3 #创建一个嵌套的list
4 object = ["num","1",["Lyon",21]]
5 #进行浅copy
6 cop1 = copy.copy(object)
7 #进行深copy
8 cop2 = copy.deepcopy(object)
9 #改变object里面嵌套的list中的元素
10 object[2][1] = 18
11 #顺便改变第一层list的元素看看
12 object[1] = 2
13 #打印cop1
14 print(cop1) #打印：['num', '1', ['Lyon', 18]]
15 #打印cop2
16 print(cop2) #打印：['num', '1', ['Lyon', 21]]
17 #我们可以看到第一层并没有改变，但是第二层变了哟
到这里相信对于深浅copy你已经懂了吧，如果还不够透彻你可以看看这个 超链接 ，我也参考了一点哟。注意哦，深浅copy不仅仅list有，dict，set这些数据类型都是一样的。
10.统计
1 #创建一个列表
2 names = ['Alex', 'Lyon', 'Leon', 'CTO', 'BeiJing',"IT",21,"man"]
3 #统计 "Lyon" 的个数，并打印
4 print(names.count("Lyon")) #打印：1
11,排序&翻转
1 #创建一个列表
2 names = ['Alex', 'Lyon', 'Leon', 'CTO', 'BeiJing',"IT",21,"man"]
3 #在python3中不同的数据类型不能一起排序哟，换成str
4 names[-2] = "21"
5 #排序，顺序为数字>大写>小写
6 names.sort()
7 #打印names
8 print(names) #打印：['21', 'Alex', 'BeiJing', 'CTO', 'IT', 'Leon', 'Lyon', 'man']
9 #翻转
10 names.reverse()
11 #打印names
12 print(names) #打印：['man', 'Lyon', 'Leon', 'IT', 'CTO', 'BeiJing', 'Alex', '21']
12.获取下标
1 #创建一个列表
2 names = ['Alex', 'Lyon', 'Leon', 'CTO','Lyon']
3 #获取下标并打印
4 print(names.index('Lyon')) #打印：1
5 #注:只返回找到的第一个下标
更多详细资料可以通过help(list)来查找哟，或者直接看官方文档。
四、字典
字典是一种key - value 的数据类型，用 冒号(" : ") 来分割，每个对象之间用逗号(" , ")分割。整个字典包括在花括号({ })中。
字典中的键(key)是唯一的，但值(value)则不必。字典是可变的数据类型，并且是无序的。基本操作：创建、增加、修改、删除、查找、遍历、多级嵌套等。在开始操作之前要注意字典键的特性：
1）key是唯一的，如果出现多个相同的key被赋值，那么值为最后一个赋的值
2）key是不可变的，所以可变的数据类型是不能用的，如：list。对于不可变的数据类型则可以，如：str、int、tuple
1.创建
1 #创建一个空字典
2 empty_info = {}
3 #创建一个字典
4 info = {"name":"Lyon","age":21}
2.增加
1 #创建一个字典
2 info = {"name":"Lyon","age":21}
3 #增加新的键/值对
4 info["school"] = "university"
5 #打印info
6 print(info) #打印：{'school': 'university', 'age': 21, 'name': 'Lyon'}
7
8 #注：字典是无序的，所以打印结果也是随机打印
3.修改
1 #创建一个字典
2 info = {"name":"Lyon","age":21,"school":"university"}
3 #修改age
4 info["age"] = 18
5 #打印info
6 print(info) #打印：{'age': 18, 'school': 'university', 'name': 'Lyon'}
4.删除
1 #创建一个字典
2 info = {"name":"Lyon","age":21,"school":"university"}
3 #标准删除姿势
4 info.pop("school")
5 #打印info
6 print(info) #打印：{'name': 'Lyon', 'age': 21}
7 #换个姿势
8 del info["age"]
9 #打印info
10 print(info) #打印：{'name': 'Lyon'}
11 #还有个随机删除，哈哈，因为只有一个键值对了，所以你懂的
12 info.popitem()
13 #打印info
14 print(info) #打印：{} 空啦
5.查找
1 #创建一个字典
2 info = {"name":"Lyon","age":21,"school":"university"}
3 #标准查找,我就直接打印了，在返回True，否则False
4 print("name" in info) #打印：True
5 #获取值,继续直接打印
6 print(info.get("name")) #打印：Lyon
7 #换换姿势，跟上面一样
8 print(info["name"]) #打印：Lyon
9 #区别来了，如果一个key不存在，就会报错，但是get方法，不存在值返回None
10 print(info["home"])
11 #报错：KeyError: 'home'
6.遍历（循环）
1 #创建一个字典
2 info = {"name":"Lyon","age":21,"school":"university"}
3 #方法1
4 for key in info:
5 print(key,info[key])
6 #方法2
7 for k,v in info.items():
8 print(k,v)
9 '''
10 结果：
11 school university
12 name Lyon
13 age 21
14 school university
15 name Lyon
16 age 21
17 '''
7.多级嵌套
1 #创建一个多级嵌套字典
2 datas ={
3 '湖北省':{
4 "武汉市":{
5 "武昌区":["Hello"],
6 "洪山区":["Sorry"],
7 "江夏区":["Welcome"],
8 },
9 },
10 '湖南省':{
11 "长沙市":{
12 "岳麓区":{},
13 "天心区":{},
14 "芙蓉区":{},
15 },
16 },
17 '广东省':{
18 "佛山市":{
19 "三水区":{},
20 "顺德区":{},
21 "男海区":{},
22 },
23 },
24 }
25 #修改最里层的value
26 datas["湖北省"]["武汉市"]["武昌区"].append("Lyon")
27 #打印结果
28 print(datas["湖北省"]["武汉市"]) #打印：{'洪山区': ['Sorry'], '武昌区': ['Hello', 'Lyon'], '江夏区': ['Welcome']}
8.更多
1 len(dict) #计算字典元素个数
2 str(dict) #输出字典可打印的字符串表示，数据类型会发生改变
3 dict.clear() # 清空词典所有条目
4 dict.fromkeys(seq, val)) #创建一个新字典，以列表 seq 中元素做字典的键，val 为字典所有键对应的初始值
5 dict.has_key(key) #如果键在字典dict里返回true，否则返回false
6 dict.items() #以列表返回可遍历的(键, 值) 元组数组
7 dict.keys() #以列表返回一个字典所有的键
8 dict.values() #以列表返回字典中的所有值
9 dict.setdefault(key, default=None) #和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
10 dict.update(dict2) #把字典dict2的键/值对更新到dict里
更多详细资料可以通过help(dict)来查找哟，或者直接看官方文档。
五、集合
集合是一个无序的，不重复的数据组合，它的主要作用如下：
-
- 去重，把一个列表变成集合，就自动去重了
- 关系测试，测试两组数据之前的交集、差集、并集等关系
python2.7中我们看到的集合都是set([1，2，3 ])这样的，而在python3中则是{1，2，3}这样的。我用的就是3，所以看到这个东西别以为它是一个错误的字典，它其实是是一个集合(set)！集合的应用还是很多的，所以不要轻视这个东西哟。
集合中的操作也跟以上的数据类型有一些差异，集合支持一系列标准操作，包括并集、交集、差集和对称差集，如下：
1 a = t | s # t 和 s的并集
2 b = t & s # t 和 s的交集
3 c = t – s # 求差集（项在t中，但不在s中）
4 d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中）
集合的增删改查跟上述数据类型也是大同小异，所以直接给说明就不举例子了。
基本操作：
1 创建方式： 2 #2和3都行 3 #方式一： 4 s = set([1,2,3]) 5 #方式二： 6 s = {1,2,3} 7 8 基本操作： 9 s.add('x') # 添加一项 10 s.update([10,37,42]) # 在s中添加多项 11 s.remove(1) #删除一项 12 len(s) #set 的长度 13 x in s #测试 x 是否是 s 的成员 14 x not in s #测试 x 是否不是 s 的成员 15 s.issubset(t) #s <= t 测试是否 s 中的每一个元素都在 t 中，s>t返回False 16 s.issuperset(t) #s >= t 测试是否 t 中的每一个元素都在 s 中，同上 17 s.union(t) #s | t 返回一个新的 set 包含 s 和 t 中的每一个元素 18 s.intersection(t) #s & t 返回一个新的 set 包含 s 和 t 中的公共元素 19 s.difference(t) #s - t 返回一个新的 set 包含 s 中有但是 t 中没有的元素 20 s.symmetric_difference(t) #s ^ t 返回一个新的 set 包含 s 和 t 中不重复的元素 21
更多详细资料可以通过help(set)来查找，或者直接看官方文档，或者百度吧。
获奖感言：
写博客，一、是为了分享自己的心得；二、是希望看到的大佬们可以帮忙矫正错误的地方；三、希望有人一起探讨。
在这里对Alex老师说声对不起，因为啊哈哈，我举的例子好像都有他。
告诉你们：长相分两种，一种是好看的，一种是难看的，你是属于中间的，好难看的。
注：该获奖感言以正能量为主，以逗为辅。