本文目录一览：
- 1、Python 字典（dic）操作
- 2、如何利用Python设计语言操作不同数据类型字典
- 3、Python中字典创建、遍历、添加等实用操作技巧合集
- 4、Python中的dict怎么用
- 5、python中字典的使用方法怎么样的？
- 6、如何利用Python语言对字典数据类型进行各种操作
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')
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就派上用场了。
如何利用Python设计语言操作不同数据类型字典
第一步，声明一个字典tree，赋值name和sale键，并打印字典值
第二步，添加字典键值对，字典是由键值对来构成的，声明一个字典hudi并赋值；再次利用该字典添加一个键值对，然后打印添加后的值
第三步，对添加的键值对进行修改键值，获取age这个键，然后重新赋值，打印修改后的结果
第四步，打印hudi字典，利用del删除字典color键值对，然后打印删除后的结果
第五步，再次打印hudi字典，利用clear()方法删除该字典所有的键值对
第六步，利用pop()方法对字典键值对进行删除，会先打印出删除的键值对！
Python中字典创建、遍历、添加等实用操作技巧合集
字段是Python是字典中唯一的键-值类型，是Python中非常重要的数据结构，因其用哈希的方式存储数据，其复杂度为O(1)，速度非常快。下面列出字典的常用的用途.
一、字典中常见方法列表
代码如下:
#方法
#描述
-------------------------------------------------------------------------------------------------
D.clear()
#移除D中的所有项
D.copy()
#返回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:
key,
'=',
D[key]
y
=
2
x
=
1
z
=
3
for
key,
value
in
D.items():
#
方法二
key,
'=',
value
y
=
2
x
=
1
z
=
3
for
key
in
D.iterkeys():
#
方法三
key,
'=',
D[key]
y
=
2
x
=
1
z
=
3
for
value
in
D.values():
#
方法四
value
2
1
3
for
key,
value
in
D.iteritems():
#
方法五
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
==
'+':
add(x,
y)
elif
sep
==
'-':
sub(x,
y)
elif
sep
==
'*':
mul(x,
y)
elif
sep
==
'/':
div(x,
y)
else:
'Something
Wrong'
__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(+
-
*
/):
")
operator(o)
Python中的dict怎么用
#字典的添加、删除、修改操作
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.copy()
print dict2
#字典的深拷贝
import copy
dict = {"a" : "apple", "b" : {"g" : "grape","o" : "orange"}}
dict2 = copy.deepcopy(dict)
dict3 = copy.copy(dict)
dict2["b"]["g"] = "orange"
print dict
dict3["b"]["g"] = "orange"
print dict
python中字典的使用方法怎么样的？
字典理解如下
另一个非常有用的 Python 内建数据类型是 字典 （参见 Mapping Types — dict ）。字典在某些语言中可能称为 联合内存 （ associative memories ）或 联合数组 （ associative arrays ）。序列是以连续的整数为索引，与此不同的是，字典以 关键字 为索引，关键字可以是任意不可变类型，通常用字符串或数值。如果元组中只包含字符串和数字，它可以作为关键字，如果它直接或间接的包含了可变对象，就不能当作关键字。不能用列表做关键字，因为列表可以用索引、切割或者 append() 和 extend() 等方法改变。
理解字典的最佳方式是把它看作无序的键： 值对 （key:value 对）集合，键必须是互不相同的（在同一个字典之内）。一对大括号创建一个空的字典： {} 。初始化列表时，在大括号内放置一组逗号分隔的键：值对，这也是字典输出的方式。
字典的主要操作是依据键来存储和析取值。也可以用 del 来删除键：值对（key:value）。如果你用一个已经存在的关键字存储值，以前为该关键字分配的值就会被遗忘。试图从一个不存在的键中取值会导致错误。
对一个字典执行 list(d.keys()) 将返回一个字典中所有关键字组成的无序列表（如果你想要排序，只需使用 sorted(d.keys()) ）。[2] 使用 in 关键字（指Python语法）可以检查字典中是否存在某个关键字（指字典）。
如何利用Python语言对字典数据类型进行各种操作
第一步，声明一个字典tree，赋值name和sale键，并打印字典值
第二步，添加字典键值对，字典是由键值对来构成的，声明一个字典hudi并赋值；再次利用该字典添加一个键值对，然后打印添加后的值
第三步，对添加的键值对进行修改键值，获取age这个键，然后重新赋值，打印修改后的结果
第四步，打印hudi字典，利用del删除字典color键值对，然后打印删除后的结果
第五步，再次打印hudi字典，利用clear()方法删除该字典所有的键值对
第六步，利用pop()方法对字典键值对进行删除，会先打印出删除的键值对！