Python菜鸟之路基础篇(三)
列表（list）是Python以及其他语言中最常用到的数据结构之一。Python使用使用中括号 [ ] 来解析列表。列表是可变的（mutable）——可以改变列表的内容。 列表是一组有序项目的集合 ,可变的数据类型【可进行增删改查】; 列表中可以包含任何数据类型，也可包含另一个列表【可任意组合嵌套】 列表是以方括号“”包围的数据集合，不同成员以“,”分隔 列表可通过序号访问其中成员. 1、创建列表列表
>>> names = ['lucky', 'jack', 'tom', 'jim', 'erica'] #方法一 [quote]>> print(names) ['lucky', 'jack', 'tom', 'jim', 'erica'][/quote] [quote]>> names = list(('jason', 'chris', 'andy', 'sunny', 'sun')) #方法二 >>> print(names) ['jason', 'chris', 'andy', 'sunny', 'sun']2、访问元素 通过下标访问列表中的元素，下标从0开始计数
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs[1] 'UI' >>> jobs[2] 'UE' >>> jobs[4] 'DBA' >>> jobs[-2] # 还可以倒数着来，不过下标从-1开始 'DBA'3、列表切片
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs[1:4] # 取下标从1到4的元素，但是不包括4，列表切片的特征就是左开右闭，也就是左取右弃。 ['UI', 'UE', 'OPS'] >>> jobs[1:-1] # 取下标为1到-1的元素，不包括-1，也就是最后一个元素不会被取出来。 ['UI', 'UE', 'OPS', 'DBA'] >>> jobs[:] # 这个在切片符左右没有下标限制，所以就是代表全取 ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs[::] # 效果和上面一样，但是你会发现有两切片符，这是因为切片有一个步长的概念 ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs[0:3] # 取下标0到3的元素，但不包括3 ['PM', 'UI', 'UE'] >>> jobs[:3] # 和上面效果一样 ['PM', 'UI', 'UE'] >>> jobs[3:] # 从下标3开始，到最后一个元素 ['OPS', 'DBA', 'DEV'] >>> jobs[3:-1] # 从下标3开始，到最后一个元素，但是不包括最后一个元素 ['OPS', 'DBA'] >>> jobs[0::2] # 从下标0开始，按照2个步长取值 ['PM', 'UE', 'DBA'] >>> jobs[::2] # 和上面效果一样 ['PM', 'UE', 'DBA']利用下标取出的一个单独元素是str类型，而利用分片取出的是一个list类型。[/quote] 4、列表追加
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] [quote]>> jobs.append('QA') #添加到最后 >>> jobs ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV', 'QA']5、列表插入
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs.insert(2, 'Sales') # 从下标为2的元素后面插入，其实可以理解为我插入一个元素，下标为3 >>> jobs ['PM', 'UI', 'Sales', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs.insert(-1, 'QA') # 也可以倒数着来 >>> jobs ['PM', 'UI', 'Sales', 'UE', 'OPS', 'DBA', 'QA', 'DEV']6、修改元素
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs[2] = 'QA' # 把下标为2的元素替换成QA，根据下标然后给元素重新赋值 >>> jobs ['PM', 'UI', 'QA', 'OPS', 'DBA', 'DEV'] >>> jobs[-2] = 'Sales' # 把下标为12的元素替换成Sales，根据下标然后给元素重新赋值 >>> jobs ['PM', 'UI', 'QA', 'OPS', 'Sales', 'DEV']7、删除元素
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> del jobs[-1] # del方法删除最后一个元素 >>> jobs ['PM', 'UI', 'UE', 'OPS', 'DBA'] >>> del jobs[1] # del方法删除下标为1的元素 >>> jobs ['PM', 'UE', 'OPS', 'DBA'] >>> jobs.remove("DBA") # 根据remove方法，指定你想删除的元素 >>> jobs ['PM', 'UE', 'OPS'] >>> jobs.pop() # pop方法，默认删除最后一个，返回删除元素 'OPS' >>> jobs ['PM', 'UE'] >>> jobs.pop(0) # pop还可以指定元素下标，指定删除 'PM' >>> jobs ['UE'] >>> jobs.clear() # clear 删除列表所有的元素，就是清空列表，变成为一个空列表 >>> jobsremove方法删除一个元素，必须是在列表中的，否则会报错，del利用下标来删除元素，pop默认删除最后一个元素，也可以指定元素下标来删除。 8、扩展列表
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> job = ['Sales', 'QA', 'HR'] >>> jobs.extend(job) # extend方法就是把job列表里面的元素一个个添加到jobs列表中。 >>> jobs ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV', 'Sales', 'QA', 'HR']9、列表拷贝
>>> jobs ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs_copy = jobs.copy() # 复制一份jobs列表 >>> jobs_copy ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs = ['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 嵌入式列表 >>> jobs_copy2 = jobs.copy() >>> jobs_copy2 ['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] >>> jobs[0] = 'HR' # 改变小标为0的元素 >>> jobs ['HR', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 改变了 >>> jobs_copy2 ['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 没变 >>> jobs[-1][0] = 'Sales' # 改变内嵌列表的下标为0的元素 >>> jobs ['HR', 'UI', 'UE', 'OPS', ['Sales', 'QA', 'DEV']] # 改变了 >>> jobs_copy2 ['PM', 'UI', 'UE', 'OPS', ['Sales', 'QA', 'DEV']] # 改变了从上面可以看出列表的copy方法是一个浅copy的栗子，只会拷贝第一次，而多层嵌入的话，会随着源列表的变化为变化，关于深拷贝和浅拷贝后面详细介绍。 10、列表统计
>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs.count('OPS') # 因为列表是有序的一种数据类型，所以它的元素是可以重叠的，所以有元素统计。
2
11、排序和翻转>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV', 1, 2, 3] >>> jobs.sort() Traceback (most recent call last): File "sort()方法会修改原列表，而不是创建一个新的有序列表，reverse()也会修改原列表，但是你希望排序，但是又不希望修改原列表，你只能利用python中一个名为sorted()的内置函数来操作：", line 1, in TypeError: unorderable types: int() < str() # Python3.0里不同数据类型不能放在一起排序了，擦 >>> jobs[-1] = '3' >>> jobs[-2] = '2' >>> jobs[-3] = '1' >>> jobs ['DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI', '1', '2', '3'] >>> jobs.sort() >>> jobs ['1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI'] >>> jobs.append('#') >>> jobs.append('&') >>> jobs.sort() >>> jobs ['#', '&', '1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI'] # 可以看出排序的顺序 特殊字符->数字->字母 这么一个优先级 >>> jobs.reverse() # 翻转最后到最前面 >>> jobs ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']
>>> jobs = ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#'] >>> newlist = sorted(jobs) >>> jobs ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#'] >>> newlist ['#', '&', '1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI']12、列表索引
>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV', 'UE'] >>> jobs.index('OPS') 2 >>> jobs.index('UE') 3 >>> jobs.index('xx') Traceback (most recent call last): File "索引下标，只会返回第一个元素的下标,如果元素不在列表中，会报错，我们可以利用in这个关键之来判断元素是否在列表中。 列表所有的方法如下：", line 1, in ValueError: 'xx' is not in list >>> if 'OPS' in jobs: ... print(jobs.index('OPS')) ... 2
class list(object): """ list() -> new empty list list(iterable) -> new list initialized from iterable's items """ def append(self, p_object): # real signature unknown; restored from __doc__ """ L.append(object) -> None -- append object to end """ pass[/quote] def clear(self): # real signature unknown; restored from __doc__ """ L.clear() -> None -- remove all items from L """ pass def copy(self): # real signature unknown; restored from __doc__ """ L.copy() -> list -- a shallow copy of L """ return def count(self, value): # real signature unknown; restored from __doc__ """ L.count(value) -> integer -- return number of occurrences of value """ return 0 def extend(self, iterable): # real signature unknown; restored from __doc__ """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """ pass def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__ """ L.index(value, [start, [stop]]) -> integer -- return first index of value. Raises ValueError if the value is not present. """ return 0 def insert(self, index, p_object): # real signature unknown; restored from __doc__ """ L.insert(index, object) -- insert object before index """ pass def pop(self, index=None): # real signature unknown; restored from __doc__ """ L.pop([index]) -> item -- remove and return item at index (default last). Raises IndexError if list is empty or index is out of range. """ pass def remove(self, value): # real signature unknown; restored from __doc__ """ L.remove(value) -> None -- remove first occurrence of value. Raises ValueError if the value is not present. """ pass def reverse(self): # real signature unknown; restored from __doc__ """ L.reverse() -- reverse [i]IN PLACE[/i] """ pass def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__ """ L.sort(key=None, reverse=False) -> None -- stable sort [i]IN PLACE[/i] """ pass13、列表的遍历 在Python中常用循环对象来遍历列表，在这里for循环自动调用next()方法，将该方法的返回值赋予给循环对象i。循环检测到StopIteration的时候才结束。相对于序列，用循环对象的好处在于：不用在循环还没有开始的时候，就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成。这样，节省了空间，提高了效率，编程更灵活。
#!/usr/bin/env python3 # _[i]_coding:utf-8_[/i]_ # Author: Lucky.chen jobs = ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#'] for i in jobs: print(i) # 自动调用迭代器，自动检测StopIteration # 在上面的程序中，无法知道当前访问元素的索引，于是有如下代码： for i in range(len(jobs)): print(jobs[i]) # 同时需要索引，又结合迭代器，就可以采用内置的enumerate函数，代码如下： for index, i in enumerate(jobs): print(index, i)[/i]扩展：（表推导方法） 表推导(list comprehension)是快速生成列表的方法。它的语法简单，很有实用价值。
[i]L = [x**2 for x in range(10)] print(L) Result: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81][/i]zip函数 如果你多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用zip()方便地实现：
[i]t1 = [1, 2, 3] t2 = [9, 8, 7] t3 = ['a', 'b', 'c'] for (a, b, c) in zip(t1, t2, t3): print(a, b, c) Result： 1 9 a 2 8 b 3 7 c[/i]每次循环时，从各个序列分别从左到右取出一个元素，合并成一个tuple，然后tuple的元素赋予给a,b,c
[i]#!/usr/bin/env python3 # _[i]_coding:utf-8_[/i]_ # Author: Lucky.chen ShopName = ['iphone', 'MacPro', 'iWatch'] money = [5500, 12000, 3800] Car = for it in zip(ShopName, money): Car.append(it) print(Car) Result: [('iphone', 5500), ('MacPro', 12000), ('iWatch', 3800)][/i]
元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表，用小括号（）表示。 元组创建：元组
>>> tup1 = () # 创建空元组
[quote]>> tup2 = ('DEV', 'DBA', 1, 2, 3) # 中括号方式
>>> tup3 = "x", "y", "z" # 字符串排列方式
>>>
# 元组中只包含一个元素时，需要在元素后面添加逗号
>>> tup4 = ('openskill')
>>> print(tup4)
openskill
>>> tup5 = ('openskill.cn',)
>>> print(tup5)
('openskill.cn',)元组与字符串类似，下标索引从0开始，可以进行截取，组合等。[/quote]
访问元组
元组可以使用下标索引来访问元组中的值，如下实例:
#!/usr/bin/env python3 # _[i]_coding:utf-8_[/i]_ # Author: Lucky.chen tup1 = ('Python', 'PHP', 1989, 1994) tup2 = (1, 2, 3, 4, 5, 6, 7 ) print("tup1[0]: ", tup1[0]) print("tup2[1:5]: ", tup2[1:5])Result:
tup1[0]: Python tup2[1:5]: (2, 3, 4, 5)修改元组 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
#!/usr/bin/env python3 # _[i]_coding:utf-8_[/i]_ # Author: Lucky.chen tup1 = (200000, 400000) tup2 = ('MG', 'JD') # 以下修改元组元素操作是非法的。 # tup1[0] = 100; # 创建一个新的元组 tup3 = tup1 + tup2 print(tup3)Resutl: [/code] 删除元组 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
#!/usr/bin/env python3 # _[i]_coding:utf-8_[/i]_ # Author: Lucky.chen tup = ('dog', 'cat', 3000, 2000) print(tup) del tup print("After deleting tup : ") print(tup)以上实例元组被删除后，输出变量会有异常信息，输出如下所示： After deleting tup : Traceback (most recent call last): File "/Users/crh/PycharmProjects/s14/day3/qixi.py", line 10, in
L = ('spam', 'Spam', 'SPAM!')[attach]1323[/attach]
无关闭分隔符
任意无符号的对象，以逗号隔开，默认为元组，如下实例：
#!/usr/bin/env python3 # _[i]_coding:utf-8_[/i]_ # Author: Lucky.chen print('abc', -4.24e93, 18+6.6j, 'xyz') x, y = 1, 2 print("Value of x , y : ", x, y)以上实例运行结果：
abc -4.24e+93 (18+6.6j) xyz Value of x , y : 1 2元组内置方法
a = (1, 2, 3, 4, 3, 2, 1, 4) print(a.count(2)) # count方法统计元素的个数 print(a.index(2)) # index检索元素的下标，默认是第一个元素 print(a.index(2, 4, 6)) # 可以指定下标范围来检索系统内置函数 Python元组包含了以下内置函数 [attach]1324[/attach]
字典是另一种可变容器模型，且可存储任意类型对象。 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容,格式如下所示：字典
d = {key1 : value1, key2 : value2 }字典的特性：
- []dict是无序的[/][]key必须是唯一的,天生去重[/]
>>> d = {'name': 'lucky', 'job': 'IT', 'gender': 'man'}
[quote]>> d['address'] = 'BJ'
>>> print(d)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
元素修改
>>> d = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> d['address'] = 'SH'
>>> print(d)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'SH'}[/quote]
# 把北京修改为上海
元素删除
>>> d = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
[quote]>> d.pop('gender') # 标准删除一个，如果元素不存在会报错
'man'
>>> print(d)
{'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>>
>>> del d['job'] # 内置函数删除,如果元素不存在会报错
>>> print(d)
{'name': 'lucky', 'address': 'BJ'}
>>>
>>> d.popitem() # 随机删除,如果字典为空报错
('name', 'lucky')
>>> print(d)
{'address': 'BJ'}
>>> del d # 删除整个字典
元素查找
>>> info = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> 'job' in info # 判断元素是否在字典中
True
>>> info.get('job') # 获取
'IT'
>>> info['name'] # 跟列表获取index一样
'lucky'
>>> info['phone'] # 如果不存在的key会报错
Traceback (most recent call last):
File "", line 1, in
KeyError: 'phone'
>>> info.get('phone') # get方法则不会
>>> if 'job' in info: info.get('job') # 标准获取方法
...
'IT'
多级字典嵌套
#!/usr/bin/env python3 # _[i]_coding:utf-8_[/i]_ # Author: Lucky.chen[/quote] av_catalog = { "欧美": { "www.youporn.com": ["很多免费的,世界最大的","质量一般"], "www.youjizz.com": ["都是免费的,挺多", "质量还不错"], "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"], "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"], "x-art.com": ["质量很高,真的很高","全部收费,屌比请绕过"] }, "日韩": { "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"] }, "大陆": { "1024": ["全部免费,真好,好人一生平安","服务器在国外,慢"], "720lu": ["很多免费的,小众", "访问速度还行"] } } # 嵌套逻辑就是 AV层---->国家层---->网站层---->说明层(列表) # 一切皆可嵌套 av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来" print(av_catalog["大陆"]["1024"]) # 执行结果 ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']其他方法
>>> info = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
[quote]>> info.clear() # 清空字典
>>> print(info)
{}
>>> info = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> cinfo = info.copy() # 字典浅copy
>>> print(info, cinfo)
({'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}, {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'})
>>> print(info)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> print(cinfo)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> info = {'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': ['BJ', 'SH']}
>>> cinfo = info.copy()
>>> info['address'][1] = 'TJ'
>>> print(info)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': ['BJ', 'TJ']}
>>> print(cinfo)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': ['BJ', 'TJ']}
>>> info['address'] = 'BJ'
>>> print(cinfo)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': ['BJ', 'TJ']}
>>> print(info)
{'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>>
>>> dict.fromkeys([1,2,3],'testd') # 通过一个列表生成默认dict,有个没办法解释的坑，少用吧这个
{1: 'testd', 2: 'testd', 3: 'testd'}
>>> info.items() # 把key和value 编程一个元组放到列表中
[('gender', 'man'), ('job', 'IT'), ('name', 'lucky'), ('address', 'BJ')]
>>> info.keys() # 获取所有的key
['gender', 'job', 'name', 'address']
>>>
>>> info.setdefault('wage', '2000') # 添加一个元素，如果存在则不添加
'2000'
>>> info
{'wage': '2000', 'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> info.setdefault('gender', 'woman')
'man'
>>> info
{'wage': '2000', 'gender': 'man', 'job': 'IT', 'name': 'lucky', 'address': 'BJ'}
>>> info.values() # 获取所有的value
['2000', 'man', 'IT', 'lucky', 'BJ']
>>> db = {'db': 'mysql', 'job': 'IT'}
>>> info.update(db) # 更新字典，相当于合并，但是相同的key的不会合并过来
>>> info
{'wage': '2000', 'job': 'IT', 'name': 'lucky', 'address': 'BJ', 'gender': 'man', 'db': 'mysql'}所有方法说明如下：
class dict(object):
"""
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
"""
def clear(self): # real signature unknown; restored from __doc__
""" D.clear() -> None. Remove all items from D. """
pass[/quote]
def copy(self): # real signature unknown; restored from __doc__
""" D.copy() -> a shallow copy of D """
pass
@staticmethod # known case
def fromkeys([i]args, [/i]*kwargs): # real signature unknown
""" Returns a new dict with keys from iterable and values equal to value. """
pass
def get(self, k, d=None): # real signature unknown; restored from __doc__
""" D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """
pass
def items(self): # real signature unknown; restored from __doc__
""" D.items() -> a set-like object providing a view on D's items """
pass
def keys(self): # real signature unknown; restored from __doc__
""" D.keys() -> a set-like object providing a view on D's keys """
pass
def pop(self, k, d=None): # real signature unknown; restored from __doc__
"""
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 raised
"""
pass
def popitem(self): # real signature unknown; restored from __doc__
"""
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
"""
pass
def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
""" D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
pass
def update(self, E=None, **F): # known special case of dict.update
"""
D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
"""
pass
def values(self): # real signature unknown; restored from __doc__
""" D.values() -> an object providing a view on D's values """
pass
字典的遍历
#方法1
for key in info:
print(key,info[key])
#方法2
for k,v in info.items(): #会先把dict转成list,数据里大时莫用
print(k,v)
未完待续，下面介绍set集合。。。。。。。。 
