python的dictzip

⑴ python常见数据类型

一,python整数类型所表示的数据。

1,一般用以表示一类数值:所有正整数,0和负整数;

2,整型作为最常用的,频繁参与计算的数据类型，在python3.5中解释器会自动在内存中创建-5-3000之间的（包含5，不包含3000）整型对象，也就是说在该范围内,相等都是同一个已经创建好的整型对象。范围之外的即使相等也表示不同对象，该特性随python版本而改变，不要过于依赖。

3,bool型继承了int型，他是int的子类。

4,Python2中有长整型long，数值范围更大，在python3中已取消，所有整型统一由int表示。

5,参与所有数值计算，数学运算，科学计算。这也是所有编程语言都有的数据类型，因为编程语言生而需要模拟人的思维，借助数学方式，自动计算、更好的解决大量重复性的事务，因此数值类型、整数类型在编程语言中不可或缺。

6,支持二进制(0b\0B开头),十进制,八进制(0o\0O),十六进制(0x\0X)

二，python整数和浮点型支持常规的数值运算

整数和浮点数都可参与的运算：+ - * / %（取余） //（整除） **（幂）

Python字符型：

python字符型表示的数据：
python3支持Unicode编码，由字母、数字和符号组成的形式就叫字符串，更接近或者相同与人们文字符号表示，因此在信息表示和传递时它也是最受认可的形式。在程序编写中也是非常常用，对应的可操作的方法也很多，很有意思。
字符串不可被修改，可以拼接等方法创建新字符串对象；
支持分片和下标操作；a[2:]
支持+拼接，*重复操作和成员关系in/not in；
表示形式：用单引号双引号包含起来的符号；a = str(‘sdfsdfsdf’) 或 r’\t\nabcd’ 原始字符，Bytes：b’abcd’；
6,字符串属于不可变数据类型，内部机制为了节省空间，相同的两个字符串表示相同的一个对象。a = ‘python’ b = ‘python’ a is b :True

二, 字符串支持的运算方法

1,capitalize() :首字母大写后边的字母小写 a = ‘abcd’ b = a.capitalize() b:Abcd

2,casefold() lower():字母转换为全小写

3,center(width,fillchar) :居中，width填补的长度；fillchar添加的字符

a = a.center(10,’_’) //’____abcd____’ 默认无fillchar填充空格

4,count(sub,star,end) :字母计数：sub要查询的字符

5,encode(encoding=’utf-8’,errors=’strict’) 设置编码

Errors :设置错误类型

6,endswith(suffix,star,end) : 若以suffix结尾返回True

7，expandtabs(8) :设置字符串中tab按键符的空格长度：’\tabcde’

8,find(sub,star,end) : 返回指定范围内的字符串下标，未找到返回-1

9，index(sub,star,end) :返回指定范围字符串下标未找到抛出异常

10，isalnum() :判断字符串是否是字母或数字，或字母和数字组合

11，isalpha() :判断是否全是字母

12，isdecimal() :判断字符串是否是十进制数值

13，isdigit() :判断字符串是否是数字

14，isidentifier() :判断字符串中是否包含关键字

15，islower() :判断是否全小写

16，isnumeric() :判断全是数字

17，isspace() :判断是否是空格

18，isupper() 判断是否大写

19，istitle() :判断是否首字母大写

20，join(iterable) :把可迭代对象用字符串进行分割：a.join(‘123’)

21,ljust(width,fillchar);rjust() :左对齐右对齐

22, upper() :将字符串改为大写

23，split(sep=None,maxsplit=-1) :分割一个字符串，被选中字符在字符串中删除

‘ab1cd1efg’.split(‘1’) :[‘ab’,’cd’,’efg’]

三，字符串格式化：按照规格输出字符串

format(*args,**kwargs) :args位置参数，kwargs关键字参数

‘{0:.1f}’.format(123.468) :格式化参数，小数点后保留1位四舍五入

四，字符串操作符%

1，%s :格式化字符串 ‘abcd%sdef’%’dddd’

2，%d:格式化整数

3，%o格式化无符号八进制

4，%x格式化无符号十六进制

5，%f格式化定点数

6, %e: 科学计数法格式化定点数

7，%g 根据值大小自动选%f,%e

8, %G E X :大写形式

五，格式化辅助命令：

m.n :m最小总宽度，n小数点后位数：’%12.4f’%23456.789

六，转义字符：字符串前r避免转义：r’\nhello\thi’

\n:换行符

\t:横向制表符

\':'

\":"

\b:退格符

\r:回车

\v:纵向制表符

\f:换页符

\o,\x:八进制和十六进制

\0:空字符串

Python列表list

一，Python的列表list类型表示的数据：

Python列表在cpython中被解释为长度可变的数组，用其他对象组成的连续数组。

列表中元素可以是相同或不同的数据类型；
当列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有缝隙，总是连续的。
Python中的列表是一个序列，也是一个容器类型
创建列表：a = []; b = [1,’python’]; c = list(); d = list((1,3,4,5))
支持切片操作list[start,stop,step]
python列表常用方法
1,append添加单个元素：list.append(object); //a.append(‘python’)

2,extend添加可迭代对象: list.extend(iterable); //a.extend(‘abcde’/[1,2,3])

3,insert 插入元素：list.insert(index,object): 在index下标前插入元素//a.insert(2,’python’)

4,clear 清空所有元素：list.clear() //a.clear()

5,pop 删除并返回一个元素：list.pop(index) //默认删除默认一个元素

remove 删除指定元素：list.remove(v) ,v元素不存在报错 //a.remove(‘c’)
7，count 返回这个值在列表中数量：list.count(value)

8, 浅拷贝一个新列表：list.()

9,sort:排序list.sort(reverse=False/True) :默认升序

排序函数：sorted(list)

10，reverse: 原地翻转：list.reverse()

11，index(value,star,stop) :指定范围内该值下标：list.index(2,0,5)

列表元素访问：
下标访问：list[1]
For循环遍历
通过下标修改元素：list[2 ] = ‘hello’
列表常用运算符：
1,比较运算符：从第一个元素开始对比

2，+ 拼接一个新列表：l1+ l2

3, 重复操作符：* ,多个列表拼接

成员关系操作符：in/ not in
逻辑运算符：and not or
列表常用的排序方法：
冒泡排序；选择排序；快速排序；归并排序

Python元组tuple

一，Python元组tuple数据类型表示的数据：

元组是受到限制的、不可改变的列表；
可以是同构也可以是异构；
元组是序列类型、是可迭代对象，是容器类型。
元组的创建: a = (1,2,3)或a=1,2,3; b = tuple(); c = tuple(iterable)
支持切片操作tuple[start,stop,step]

二，python元组常用方法

1,index(value,star,stop) :指定范围内该值下标：tuple.index(2,0,5)

2,count(value) ：值出现次数

三，支持运算：

1,比较运算符：从第一个元素开始对比

2，+ 拼接一个新元组：l1+ l2

3, 重复操作符：* ,多个元组拼接

4成员关系操作符：in/ not in

逻辑运算符：and not or
四，元组的访问

下标操作；
For循环遍历访问。

Python字典类型

一,Python字典dict表示的数据：{key:value}

可根据关键字：键快速索引到对应的值；
字典是映射类型，键值对一一对应关系，不是序列；
字典元素是无序的；
字典是可迭代对象，是容器类型；
字典的创建：k = {}; k1={‘keyword’:object}; k2 = dict();
K3 = dict(mapping); dict=(iterable)

二，字典的访问：

通过key：k[‘key’]

修改key对应的值：K[‘key’] = value

For循环遍历出来的是key；

For循环键值对：for I in d.items():

For 循环enumerate: for k,v in enumerate(k1):

In/not in 成员关系查询键不支持查值

三，字典常用方法

get(key,de):获取值：k.get(key,de) //若不存在则默认输出de
pop(k,de):删除一个键值对，不存在输出de，未设置报错；
keys() :返回字典所有key组成的序列：list(k.keys()) [1,2,3];
values():返回字典所有value组成的序列：list(k.values())
items():返回键值对组成的元组为元素的序列：（类set）list(k.items())
update(e):更新字典：e可是字典或两元素组成的单位元素序列：e=[(5,6),(7,8)];
k.update(e)

clear():清空字典；
popitem()删除某个键值对，若字典为空则报错
() :浅拷贝
10, fromkeys(iterable,value=None):从可迭代对象创建字典

{}.fromkeys([1,2,3]) -----{1:None,2:None,3:None}

11,setdefault(k,d=None) :若key不存在则生成一个键值对

k.setdefault(‘keyword’)

Python 集合set

集合表示的数据：
多个元素的无序组合，集合是无序的，集合元素是唯一的；
字典的键是由集合实现的；
集合是可迭代对象
集合创建：s = {1,2}; s1 = set(); s2 = set(iterable)
集合元素的访问：
For 循环将集合所有元素全部访问一遍，不重复

常用方法：
add(object):s.add(‘hi’) 向集合添加一个元素
pop() :弹栈，集合为空则报错：删除任意一个元素；
clear():清空集合，返回一个空集合对象；
remove(object):删除一个元素，不存在和报错：s.remove(‘hi’)
update(集合)：更新另一个集合，元素不存在则不更新；
() :浅拷贝
集合的运算：
交集：s1&s2;
差集,补集：s1-s2;
并集：s1|s2;
Issubset():判断是否是子集：s1.issubset(s2) s1是否s2的集合子集
Issuperset():判断是否是父集：s1.issuperset()
不可变集合：
Frozenset():返回一个空的不可变集合对象

Frozenset(iterable):

S = frozenset(iterable)

Python序列类型共同特性

一,序列类型共同特性

python序列类型有:str字符串,list列表,tuple元组
都支持下标索引，切片操作；
下标都是从0开始，都可通过下标进行访问；
拥有相同的操作符
二，支持的函数：

len(obj):返回对象长度；
list(iterable):将可迭代对象转为列表；
tuple(iterable):将可迭代对象转为元组；
str(ojb):将任何对象转为字符串形式；
max(iterable): python3中元素要是同类型，python2中元素可异构：max([‘a’,1])
min(iterable):和max类似；
sum(iterable,star=0),求可迭代对象和，默认star为0，元素不能为字符串
sorted(iterable,key=None,reverse=False)
s=[(‘a’,3),(‘b’,2),(‘c’,9)]

sorted(s,key=lambda s:s[1]) //按照数字排序

reversed(sequence):翻转序列，返回迭代器
enumerate(iterable):返回enumerate对象,其元素都是一个元组（下标，值）
zip（iter1,iter2）: zip([1,2],[3,4]) ----[(1,3),(2,4)]

序列类型的切片操作：

Slice:

L[index]; 访问某个元素；

L[1:4]; 区间

L[star:stop:step]; 设置步长取区间元素

⑵ Python中如何动态往列表中添加字典

>>>keys=['a','b','c']
>>>values=[1,2,3]
>>>dictionary=dict(zip(keys,values))
>>>print(dictionary)
{'a':1,'b':2,'c':3}

⑶ python zip 是什么

zip就是把2个数组糅在一起
x=[1, 2, 3, 4, 5 ]
y=[6, 7, 8, 9, 10]
zip(x, y)就得到了
[(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]

比如你有2组坐标，你想两两对应的相加，那么zip函数就很有用了。
再比如，你有2个数组A,B，A存了班级里的人的名字，B是每个人的考试分数，你需要通过某个人的名字来查考试分数，那你需要一个字典，zip可以很方便地帮你建立字典：
>>> x=['bob','tom','kitty']
>>> y=[80,90,95]
>>>d=dict(zip(x,y))
[('bob', 80), ('tom', 90), ('kitty', 95)]
>>> d['bob']
返回80，多方便啊

⑷ python 中怎么把,list，字典dict转换为字符串

字典用values()函数转化成值的列表，用items转换成（key，value）的元组列表。
列表转换成字典，需要用2个列表转化成字典，一个是key，一个是value。比如：
>>>dict(zip(['a','b','c'], range(5)))
{'a': 0, 'c': 2, 'b': 1}

>>> a=[1,2,3]
>>> ''.join( [ str(x) for x in a])
'123'
>>> b={1:11, 2:22, 3:33}
>>> ''.join( [ str(x) for x in b.values()])
'112233'
>>> ''.join( [ str(x) for x in b])
'123'
>>> ''.join( [ str(x) for x in b.items()])
'(1, 11)(2, 22)(3, 33)'
>>>

⑸ Python中的dict怎么用

#字典的添加、删除、修改操作
dict={"a":"apple","b":"banana","g":"grape","o":"orange"}
dict["w"]="watermelon"
del(dict["a"])
dict["g"]="grapefruit"
printdict.pop("b")
printdict
dict.clear()
printdict
#字典的遍历
dict={"a":"apple","b":"banana","g":"grape","o":"orange"}
forkindict:
print"dict[%s]="%k,dict[k]
#字典items()的使用
dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
#每个元素是一个key和value组成的元组，以列表的方式输出
printdict.items()
#调用items()实现字典的遍历
dict={"a":"apple","b":"banana","g":"grape","o":"orange"}
for(k,v)indict.items():
print"dict[%s]="%k,v
#调用iteritems()实现字典的遍历
dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
printdict.iteritems()
fork,vindict.iteritems():
print"dict[%s]="%k,v
for(k,v)inzip(dict.iterkeys(),dict.itervalues()):
print"dict[%s]="%k,v


#使用列表、字典作为字典的值
dict={"a":("apple",),"bo":{"b":"banana","o":"orange"},"g":["grape","grapefruit"]}
printdict["a"]
printdict["a"][0]
printdict["bo"]
printdict["bo"]["o"]
printdict["g"]
printdict["g"][1]

dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
#输出key的列表
printdict.keys()
#输出value的列表
printdict.values()
#每个元素是一个key和value组成的元组，以列表的方式输出
printdict.items()
dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
it=dict.iteritems()
printit
#字典中元素的获取方法
dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
printdict
printdict.get("c","apple")
printdict.get("e","apple")
#get()的等价语句
D={"key1":"value1","key2":"value2"}
if"key1"inD:
printD["key1"]
else:
print"None"
#字典的更新
dict={"a":"apple","b":"banana"}
printdict
dict2={"c":"grape","d":"orange"}
dict.update(dict2)
printdict
#udpate()的等价语句
D={"key1":"value1","key2":"value2"}
E={"key3":"value3","key4":"value4"}
forkinE:
D[k]=E[k]
printD
#字典E中含有字典D中的key
D={"key1":"value1","key2":"value2"}
E={"key2":"value3","key4":"value4"}
forkinE:
D[k]=E[k]
printD
#设置默认值
dict={}
dict.setdefault("a")
printdict
dict["a"]="apple"
dict.setdefault("a","default")
printdict
#调用sorted()排序
dict={"a":"apple","b":"grape","c":"orange","d":"banana"}
printdict
#按照key排序
printsorted(dict.items(),key=lambdad:d[0])
#按照value排序
printsorted(dict.items(),key=lambdad:d[1])
#字典的浅拷贝
dict={"a":"apple","b":"grape"}
dict2={"c":"orange","d":"banana"}
dict2=dict.()
printdict2

#字典的深拷贝
import
dict={"a":"apple","b":{"g":"grape","o":"orange"}}
dict2=.deep(dict)
dict3=.(dict)
dict2["b"]["g"]="orange"
printdict
dict3["b"]["g"]="orange"
printdict

⑹ python为什么使用字典解析会出现值一样的结果

这是一个嵌套循环，由于dict不允许重复，最终每个key对应的value的值都是内层循环oldlist最后一项的值即3。要实现key和value一一对应的关系最好的方法是使用zip()函数：
i = dict(zip(thelist,oldlist))

⑺ 在python中，列表，字典的相互转换

列表、元组、集合、字典相互转换
一、列表元组转其他
1、列表转集合(去重)
list1
=
[6,
7,
7,
8,
8,
9]
set(list1)
#
{6,
7,
8,
9}
2、两个列表转字典
list1
=
['key1','key2','key3']
list2
=
['1','2','3']
dict(zip(list1,list2))
#
{'key1':
'1',
'key2':
'2',
'key3':
'3'}
3、嵌套列表转字典
list3
=
[['key1','value1'],['key2','value2'],['key3','value3']]
dict(list3)
#
{'key1':
'value1',
'key2':
'value2',
'key3':
'value3'}
4、列表、元组转字符串
list2
=
['a',
'a',
'b']
''.join(list2)
#
'aab'
tup1
=
('a',
'a',
'b')
''.join(tup1)
#
'aab'
二、字典转其他
1、
字典转换为字符串
dic1
=
{'a':1,'b':2}
str(dic1)
#
"{'a':
1,
'b':
2}"
2、字典key和value互转
dic2
=
{'a':
1,
'b':
2,
'c':
3}
{value:key
for
key,
value
in
a_dict.items()}
#
{1:
'a',
2:
'b',
3:
'c'}
三、字符串转其他
1、字符串转列表
s
=
'aabbcc'
list(s)
#
['a',
'a',
'b',
'b',
'c',
'c']
2、字符串转元组
tuple(s)
#
('a',
'a',
'b',
'b',
'c',
'c')
3、
字符串转集合
set(s)
#
{'a',
'b',
'c'}
4、字符串转字典
dic2
=
eval("{'name':'ljq',
'age':24}")
5、切分字符串
a
=
'a
b
c'
a.split('
')
#
['a',
'b',
'c']

⑻ 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'}

⑼ python列表中字典按指定相同的键值对合并到一个列表中

使用集合去重 + local动态变量设置 + exec 字符串解析 可实现，话不多说，代码在下面，格式有问题调整下空格：
list_msg = [{'date':'2019-08-17', 'type':'旅游', 'over_im':'12365'},
{'date':'2019-08-17', 'type':'haha', 'over_im':'12365'},
{'date':'2019-08-18', 'type':'娱乐', 'over_im':'11234'},{'date':'2019-08-19', 'type':'生活', 'over_im':'9532'},]

# 去除字典重复的data ，获取数据包含多少天内容
set_mark = {i['date'] for i in list_msg}
# 去除非法命名字符作为列表后缀：
ver_name = [i.replace('-','_') for i in set_mark]
# 给列表排序，确保按照顺序输出变量
ver_name.sort()
# 设置动态命名模板
list_name_template = 'list_data_'
# 创建local对象，准备创建动态变量
createver = locals()
# 循环遍历数据并创建动态列表变量接收
for mark in set_mark:
# 动态创建变量
createver[list_name_template + mark.replace('-','_')] \
= [dict_current for dict_current in list_msg if dict_current['date'] == mark]
for name in ver_name:
print(list_name_template + name + ':' ,end='\t') # 打印自动创建的变量名称，采用tab分隔
exec('print('+list_name_template + name +')') # 打印变量内容（列表）

'''
打印结果
list_data_2019_08_17: [{'date': '2019-08-17', 'type': '旅游', 'over_im': '12365'}, {'date': '2019-08-17', 'type': 'haha', 'over_im': '12365'}]
list_data_2019_08_18: [{'date': '2019-08-18', 'type': '娱乐', 'over_im': '11234'}]
list_data_2019_08_19: [{'date': '2019-08-19', 'type': '生活', 'over_im': '9532'}]
'''

⑽ Python中字典创建、遍历、添加等实用操作技巧合集

字段是Python是字典中唯一的键-值类型，是Python中非常重要的数据结构，因其用哈希的方式存储数据，其复杂度为O(1)，速度非常快。下面列出字典的常用的用途.
一、字典中常见方法列表
代码如下:
#方法
#描述
-------------------------------------------------------------------------------------------------
D.clear()
#移除D中的所有项
D.()
#返回D的副本
D.fromkeys(seq[,val])
#返回从seq中获得的键和被设置为val的值的字典。可做类方法调用
D.get(key[,default])
#如果D[key]存在，将其返回;否则返回给定的默认值None
D.has_key(key)
#检查D是否有给定键key
D.items()
#返回表示D项的(键，值)对列表
D.iteritems()
#从D.items()返回的(键，值)对中返回一个可迭代的对象
D.iterkeys()
#从D的键中返回一个可迭代对象
D.itervalues()
#从D的值中返回一个可迭代对象
D.keys()
#返回D键的列表
D.pop(key[,d])
#移除并且返回对应给定键key或给定的默认值D的值
D.popitem()
#从D中移除任意一项，并将其作为(键，值)对返回
D.setdefault(key[,default])
#如果D[key]存在则将其返回;否则返回默认值None
D.update(other)
#将other中的每一项加入到D中。
D.values()
#返回D中值的列表
二、创建字典的五种方法
方法一:
常规方法
代码如下:
#
如果事先能拼出整个字典，则此方法比较方便
>>>
D1
=
{'name':'Bob','age':40}
方法二:
动态创建

代码如下:
#
如果需要动态地建立字典的一个字段，则此方法比较方便
>>>
D2
=
{}
>>>
D2['name']
=
'Bob'
>>>
D2['age']
=
40
>>>
D2
{'age':
40,
'name':
'Bob'}
方法三:
dict--关键字形式
代码如下:
#
代码比较少，但键必须为字符串型。常用于函数赋值
>>>
D3
=
dict(name='Bob',age=45)
>>>
D3
{'age':
45,
'name':
'Bob'}
方法四:
dict--键值序列
代码如下:
#
如果需要将键值逐步建成序列，则此方式比较有用,常与zip函数一起使用
>>>
D4
=
dict([('name','Bob'),('age',40)])
>>>
D4
{'age':
40,
'name':
'Bob'}
或
代码如下:
>>>
D
=
dict(zip(('name','bob'),('age',40)))
>>>
D
{'bob':
40,
'name':
'age'}
方法五:
dict--fromkeys方法#
如果键的值都相同的话,用这种方式比较好，并可以用fromkeys来初始化

代码如下:
>>>
D5
=
dict.fromkeys(['A','B'],0)
>>>
D5
{'A':
0,
'B':
0}
如果键的值没提供的话，默认为None
代码如下:
>>>
D3
=
dict.fromkeys(['A','B'])
>>>
D3
{'A':
None,
'B':
None}
三、字典中键值遍历方法

代码如下:
>>>
D
=
{'x':1,
'y':2,
'z':3}
#
方法一
>>>
for
key
in
D:
print
key,
'=>',
D[key]
y
=>
2
x
=>
1
z
=>
3
>>>
for
key,
value
in
D.items():
#
方法二
print
key,
'=>',
value
y
=>
2
x
=>
1
z
=>
3
>>>
for
key
in
D.iterkeys():
#
方法三
print
key,
'=>',
D[key]
y
=>
2
x
=>
1
z
=>
3
>>>
for
value
in
D.values():
#
方法四
print
value
2
1
3
>>>
for
key,
value
in
D.iteritems():
#
方法五
print
key,
'=>',
value
y
=>
2
x
=>
1
z
=>
3
Note:用D.iteritems(),
D.iterkeys()的方法要比没有iter的快的多。
四、字典的常用用途之一代替switch
在C/C++/Java语言中，有个很方便的函数switch，比如:
代码如下:
public
class
test
{
public
static
void
main(String[]
args)
{
String
s
=
"C";
switch
(s){
case
"A":
System.out.println("A");
break;
case
"B":
System.out.println("B");
break;
case
"C":
System.out.println("C");
break;
default:
System.out.println("D");
}
}
}
在Python中要实现同样的功能，
方法一，就是用if,
else语句来实现，比如:

代码如下:
from
__future__
import
division
def
add(x,
y):
return
x
+
y
def
sub(x,
y):
return
x
-
y
def
mul(x,
y):
return
x
*
y
def
div(x,
y):
return
x
/
y
def
operator(x,
y,
sep='+'):
if
sep
==
'+':
print
add(x,
y)
elif
sep
==
'-':
print
sub(x,
y)
elif
sep
==
'*':
print
mul(x,
y)
elif
sep
==
'/':
print
div(x,
y)
else:
print
'Something
Wrong'
print
__name__
if
__name__
==
'__main__':
x
=
int(raw_input("Enter
the
1st
number:
"))
y
=
int(raw_input("Enter
the
2nd
number:
"))
s
=
raw_input("Enter
operation
here(+
-
*
/):
")
operator(x,
y,
s)
方法二，用字典来巧妙实现同样的switch的功能，比如:

代码如下:
#coding=gbk
from
__future__
import
division
x
=
int(raw_input("Enter
the
1st
number:
"))
y
=
int(raw_input("Enter
the
2nd
number:
"))
def
operator(o):
dict_oper
=
{
'+':
lambda
x,
y:
x
+
y,
'-':
lambda
x,
y:
x
-
y,
'*':
lambda
x,
y:
x
*
y,
'/':
lambda
x,
y:
x
/
y}
return
dict_oper.get(o)(x,
y)
if
__name__
==
'__main__':
o
=
raw_input("Enter
operation
here(+
-
*
/):
")
print
operator(o)