python3dictkey
A. python3 defaultdict 和 dict的区别
yangyzh
Python中dict详解
python3.0以上，print函数应为print（），不存在dict.iteritems()这个函数。
在python中写中文注释会报错，这时只要在头部加上# coding=gbk即可
#字典的添加、删除、修改操作
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
dict["w"] = "watermelon"
del(dict["a"])
dict["g"] = "grapefruit"
print dict.pop("b")
print dict
dict.clear()
print dict
#字典的遍历
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
for k in dict:
print "dict[%s] =" % k,dict[k]
#字典items()的使用
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
#每个元素是一个key和value组成的元组，以列表的方式输出
print dict.items()
#调用items()实现字典的遍历
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
for (k, v) in dict.items():
print "dict[%s] =" % k, v
#调用iteritems()实现字典的遍历
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
print dict.iteritems()
for k, v in dict.iteritems():
print "dict[%s] =" % k, v
for (k, v) in zip(dict.iterkeys(), dict.itervalues()):
print "dict[%s] =" % k, v
#使用列表、字典作为字典的值
dict = {"a" : ("apple",), "bo" : {"b" : "banana", "o" : "orange"}, "g" : ["grape","grapefruit"]}
print dict["a"]
print dict["a"][0]
print dict["bo"]
print dict["bo"]["o"]
print dict["g"]
print dict["g"][1]
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
#输出key的列表
print dict.keys()
#输出value的列表
print dict.values()
#每个元素是一个key和value组成的元组，以列表的方式输出
print dict.items()
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
it = dict.iteritems()
print it
#字典中元素的获取方法
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
print dict
print dict.get("c", "apple")
print dict.get("e", "apple")
#get()的等价语句
D = {"key1" : "value1", "key2" : "value2"}
if "key1" in D:
print D["key1"]
else:
print "None"
#字典的更新
dict = {"a" : "apple", "b" : "banana"}
print dict
dict2 = {"c" : "grape", "d" : "orange"}
dict.update(dict2)
print dict
#udpate()的等价语句
D = {"key1" : "value1", "key2" : "value2"}
E = {"key3" : "value3", "key4" : "value4"}
for k in E:
D[k] = E[k]
print D
#字典E中含有字典D中的key
D = {"key1" : "value1", "key2" : "value2"}
E = {"key2" : "value3", "key4" : "value4"}
for k in E:
D[k] = E[k]
print D
#设置默认值
dict = {}
dict.setdefault("a")
print dict
dict["a"] = "apple"
dict.setdefault("a","default")
print dict
#调用sorted()排序
dict = {"a" : "apple", "b" : "grape", "c" : "orange", "d" : "banana"}
print dict
#按照key排序
print sorted(dict.items(), key=lambda d: d[0])
#按照value排序
print sorted(dict.items(), key=lambda d: d[1])
#字典的浅拷贝
dict = {"a" : "apple", "b" : "grape"}
dict2 = {"c" : "orange", "d" : "banana"}
dict2 = dict.()
print dict2
#字典的深拷贝
import
dict = {"a" : "apple", "b" : {"g" : "grape","o" : "orange"}}
dict2 = .deep(dict)
dict3 = .(dict)
dict2["b"]["g"] = "orange"
print dict
dict3["b"]["g"] = "orange"
print dict
补充：
1 初始化
>>> d = dict(name='visaya', age=20)
>>> d = dict(zip(['name', 'age'], ['visaya', 20]))
#dict.fromkeys(listkeys, default=0) 把listkeys中的元素作为key均赋值为value，默认为0
>>> d = dict.fromkeys(['a', 'b'], 1)
>>> d
{'a': 1, 'b': 1}
2 字典视图和几何
dict.keys()类似信使可以进行交集和并集等集合操作（类似集合，因为不存在重复的项），但dict.values()不可以进行如上操作。
>>> k = d.keys()
>>> k
dict_keys(['a', 'b'])
>>> list(k)
['a', 'b']
>>> k | {'x': 3}
{'a', 'x', 'b'}
>>> k | {'x'}
{'a', 'x', 'b'}
>>> k | {'x', 'y'}
{'a', 'y', 'b', 'x'}
>>> k & {'x'}
set()
>>> v = d.values()
>>> v
dict_values([1, 2])
>>> v | {'x'}
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: unsupported operand type(s) for |: 'dict_values' and 'set'
3 排序字典键
两种方法:
3.1 sort:
>>> Ks = list(d.keys())
>>> Ks.sort()
>>> for k in Ks:
... print(k, d[k])
...
a 1
b 2
3.2 sorted:
>>> for k in sorted(d.keys()):
... print(k, d[k])
...
a 1
b 2
3.3 注意
>>> for k in list(d.keys()).sort():
... print(k, d[k])
...
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: 'NoneType' object is not iterable
出错原因：
list.sort() list.append()函数都是对自身的操作，没有返回值，故需先将list(d.keys())的结果保存下来，在结果上进行sort()
4 常用函数
4.1 get()
D.get(k[, d]) => D[k] if k in D else d. d defaults to none.
4.2 pop()
D.pop(value[, d]) => Remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised.
4.3 udpate()
D.update(E, **F) -> None. Update D from dict/iterable E and F.
If E has a .keys() method, does: for k in E: D[k] = E[k]
If E lacks .keys() method, does: for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
>>> d = dict(name='visaya', age=21)
>>> d1= {'age': 20, 'sex': 'male'}
>>> d2 = zip(['a', 'b'], [1, 2])
>>> d.update(d1)
>>> d
{'age': 20, 'name': 'visaya', 'sex': 'male'}
#for k in d1: d[k] = d1[k]
>>> d.update(d2)
>>> d
{'age': 20, 'name': 'visaya', 'sex': 'male'}
#for (k, v) in d2: d[k] = v
4.4 del()
del D[key]
4.5 clear()
4.6 ()
Python中的dict
初始化
构造方法创建
Python代码
d = dict()
d = dict(name="nico", age=23)
d = dict((['name', "nico"], ['age', 23]))
当然还有更方便，简单的
Python代码
d = {}
d = {"name":"nico", "age":23}
遍历
通过对key的遍历，遍历整个dict
Python代码
d = {"name":"nico", "age":23}
for key in d:
print "key=%s, value=%s" % (key, d[key])
for key in d.iterkeys():
print "key=%s, value=%s" % (key, d[key])
for key in d.keys():
print "key=%s, value=%s" % (key, d[key])
for key in iter(d):
print "key=%s, value=%s" % (key, d[key])
for key,item in d.items():
print "key=%s, value=%s" % (key, item)
当然也可以直接遍历value
Python代码
d = {"name":"nico", "age":23}
for value in d.values():
print value
for key,value in d.viewitems():
print "key=%s, value=%s" % (key, value)
for value in d.viewvalues():
print "value=%s" % (value)
这里values和viewvalues的区别
后者返回的是该字典的一个view对象，类似数据库中的view，当dict改变时，该view对象也跟着改变
常用方法
Python代码
d = {"name":"nico", "age":23}
d["name"] = "aaaa"
d["address"] = "abcdefg...."
print d #{'age': 23, 'name': 'aaaa', 'address': 'abcdefg....'}
获取dict值
Python代码
print d["name"] #nico
print d.get("name") #nico
如果key不在dict中，返回default，没有为None
Python代码
print d.get("namex", "aaa") #aaa
print d.get("namex") #None
排序sorted()
Python代码
d = {"name":"nico", "age":23}
for key in sorted(d):
print "key=%s, value=%s" % (key, d[key])
#key=age, value=23
#key=name, value=nico
删除del
Python代码
d = {"name":"nico", "age":23}
Python代码
del d["name"]
#如果key不在dict中，抛出KeyError
del d["names"]
Python代码
Traceback (most recent call last):
File "F:\workspace\project\pydev\src\ddd\ddddd.py", line 64, in <mole>
del d["names"]
KeyError: 'names'
清空clear()
Python代码
d = {"name":"nico", "age":23}
d.clear()
print d #{}
()
Python代码
d1 = d.() #{'age': 23, 'name': 'nico'}
#使用返回view对象
d2 = d1.viewitems() #dict_items([('age', 23), ('name', 'nico')])
#修改字典d1，新增元素
d1["cc"] = "aaaaaa"
print d2
#dict_items([('cc', 'aaaaaa'), ('age', 23), ('name', 'nico')])
pop(key[, default])
如果key在dict中，返回，不在返回default
Python代码
#如果key在dict中，返回，不在返回default
print d.pop("name", "niccco") #nico
print d.pop("namezzz", "niccco") #niccco
#key不在dict中，且default值也没有，抛出KeyError
print d.pop("namezzz") #此处抛出KeyError
popitem()
删除并返回dict中任意的一个(key,value)队，如果字典为空会抛出KeyError
Python代码
d = {"name":"nico", "age":23}
print d.popitem() #('age', 23)
print d.popitem() #('name', 'nico')
#此时字典d已为空
print d.popitem() #此处会抛出KeyError
update([other])
将字典other中的元素加到dict中，key重复时将用other中的值覆盖
Python代码
d = {"name":"nico", "age":23}
d2 = {"name":"jack", "abcd":123}
d.update(d2)
print d #{'abcd': 123, 'age': 23, 'name': 'jack'}
B. Python 字典（dic）操作
具体函数有 set（），pop（），update（），items（），keys（），values（），get（），setdefault（）
python 字典操作
假设字典为 dics = {0:'a', 1:'b', 'c':3}
二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None：
>>> print dics.get('a')
0
>>> print dics.get('Paul')
None
dict.get(key,default=None) 两个选项 一个 key 一个 default= None ----default可以是任何strings（字符）
2.从字典中取值，若找到则删除；当键不存在时，显示异常key error
[方法] dics.pop('key')
3.给字典添加一个条目。如果不存在，就指定特定的值；若存在，就算了。
[方法] dic.setdefault(key, value)
4. update
>>> a = {'a':1,'b':2}
>>> a.update({'c':3})
>>>a
{'a': 1,'c': 3,'b': 2}
>>> a.update({'c':4})
>>>a
{'a': 1,'c': 4,'b': 2}
dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。
有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。
C. Python中如何以dict的key排序输出
#输出的顺序却不是我们预想的那样初始化的顺序，查询相关文献得知，Python保证遍##历字典所有元素，但不保证遍历的顺序，假如我们期望按预先的顺序进行遍历的话，#我目前找到一个办法，就是通过两个List分别存储Key和Value，然后通过zip合并为Dic#tionary，再遍历：
# 通过zip方法合并两个List为Dictionary
# 遍历会按原先的顺序
keys = ["b", "a", "c", "e", "d"]
values = ["2", "1", "3", "5", "4"]
for key,value in zip(keys, values):
print(key,value)
# -- OUTPUT --
# b 2
# a 1
# c 3
# e 5
# d 4
D. python中怎么取出字典的键
举例如下：
1、新增python文件，testdictkey.py；
E. 请问python3中“构造函数 dict() 可以直接从键值对序列中构建字典如下”什么意思
意思是可以这样创建字典:
dict([('key1','value1'),('key2','value2')])
#等于下面
{
'key1':'value1',
'key2':'value2',
}
F. python字典中key怎么表示区间
python字典中key怎么表示区间，操作方法如下。
设备：mac
系统：ios15.4
软件：python3
1、首先在电脑中，打开操作系统的命令行工具python。
G. python3在函数声明里如何设置参数的类型 dict
dict[]和dict.get两个方法的区别吧 dict[key]：当key不存在的时候，会抛出异常 dict.get(key, defaut_value=None) 当key不存在的时候，不会抛出异常，而且会返回默认值
H. 如何使用Python3实现Dict字典的倒序输出
dict是哈希实现的，不存在有序无序
想要实验有序输出，按list就行
ATLst = sorted(ATDict.items(),key=lambda x:x[0],reverse=True)
for item in ATLst:
print(items[0],items[1])
I. python3 判断dict是否含有某元素
list = [1,'a','b',{'key':'value'}]
for i in range(0, list.__len__()):
#遍历list的元素，print其类型
print type(list[i])
#判断类型为str的元素，并输出
print '类型为string的有：'
for i in range(0, list.__len__()):
if isinstance(list[i], str):
print type(list[i])
结果：
<type 'int'>
<type 'str'>
<type 'str'>
<type 'dict'>
类型为string的有：
<type 'str'>
<type 'str'>
J. python dict用法
dic= {key1 : value1, key2 : value2 }
字典也被称作关联数组或哈希表。下面是几种常见的字典属性：
1、dict.clear()
clear() 用于清空字典中所有元素（键-值对），对一个字典执行 clear() 方法之后，该字典就会变成一个空字典。
2、dict.()
() 用于返回一个字典的浅拷贝。
3、dict.fromkeys()
fromkeys() 使用给定的多个键创建一个新字典，值默认都是 None，也可以传入一个参数作为默认的值。
4、dict.get()
get() 用于返回指定键的值，也就是根据键来获取值，在键不存在的情况下，返回 None，也可以指定返回值。
5、dict.items()
items() 获取字典中的所有键-值对，一般情况下可以将结果转化为列表再进行后续处理。
6、dict.keys()
keys() 返回一个字典所有的键。