python 字典操作

1、直接创建字典

info = {'Name': 'sara', 'Age': 7, 'Sex': 'F'}

print(info)
print(info['Sex'])

2.使用dict()生成字典

 

items = [('Name','sara'), ('Age', 30), ('Sex','F')]
print(items)

info = dict(items)
print('info:', info)

 

3.使用关键字生成字典

info = dict(Name='sara', Age=30, Sex='F')
print('info:',info)

4.引用字典里面的value值

info = dict(Name='sara', Age=30, Sex='F')
print('info:', info)

print('my name is %(Name)s.' % info)

　二.字典方法

clear函数：清除字典中的所有项

info = dict(Name='sara', Age=30, Sex='F')
print('info:', info)

info.clear()
print(info)　　

　下面两个列子：

　NO1：

info = {}
info1 =info
info['one'] = 1
info['two'] = 2
print(info1)
info = {}
print('info:', info)  #info:{}
print('info1:', info1)#info1:{'one': 1, 'two': 2}

　　NO2：

info = {}
info1 =info
info['one'] = 1
info['two'] = 2
print(info1)
info.clear()
print('info:', info) #info: {}
print('info1:', info1)#info1: {}

　总结：

　两个唯一不同的是在对字典d的清空处理上，NO1将info关联到一个新的空字典上，这种方式对字典info1是没有影响的，所以在字典info被置空后，字典info1里面的值仍旧没有变化。但是在NO2中clear方法清空字典d中的内容，clear是一个原地操作的方法，使得info中的内容全部被置空，这样info1所指向的空间也被置空。

copy0函数：更改第一层数据

info = {'one': 1, 'two': 2, 'three': 3, 'test':['a','b','c']}
print('初始info字典：%s', info)
print('info复制到info1：')
info1 = info.copy()
print('info1字典：%s' % info1)
info['one'] = 100
print('info1 %s:' % info1)
print('info %s:' % info)


运算结果：
info1 {'one': 1, 'two': 2, 'three': 3, 'test': ['a', 'b', 'c']}:
info {'one': 100, 'two': 2, 'three': 3, 'test': ['a', 'b', 'c']}:

　更改第二层数据：

info = {'one': 1, 'two': 2, 'three': 3, 'test':['a','b','c']}
print('初始info字典：%s', info)
print('info复制到info1：')
info1 = info.copy()

info1['test'].insert(1,'f')
print('info1 %s:' % info1)
print('info %s:' % info)

运算结果：
info1 {'one': 1, 'two': 2, 'three': 3, 'test': ['a', 'f', 'b', 'c']}:
info {'one': 1, 'two': 2, 'three': 3, 'test': ['a', 'f', 'b', 'c']}:

　copy对于一个复杂对象的子对象并不会完全复制，什么是复杂对象的子对象呢？就比如序列里的嵌套序列，字典里的嵌套序列等都是复杂对象的子对象。对于子对象，python会把它当作一个公共镜像存储起来，所有对他的复制都被当成一个引用，所以说当其中一个引用将镜像改变了之后另一个引用使用镜像的时候镜像已经被改变了。　

origin = [1, 2, [3, 4]]
cop1 = copy.copy(origin)
cop2 = copy.deepcopy(origin)
print(cop1 == cop2)
print(cop1 is cop2)
origin[2][0] = 'sara'
print('origin:', origin)
print('cop1:', cop1)
print('cop2:', cop2)

运算结果：

True
False
origin: [1, 2, ['sara', 4]]
cop1: [1, 2, ['sara', 4]]
cop2: [1, 2, [3, 4]]

　　引用来自：http://www.cppcns.com/jiaoben/python/236422.html

 四.fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None

info = dict.fromkeys(['one', 'two'])
print(info)

运行结果：
{'one': None, 'two': None}

 

 或者指定默认值

 

info = dict.fromkeys(['one', 'two'], 'know')
print(info)

运行结果：
{'one': 'know', 'two': 'know'}

　　五：get函数(注：get函数可以访问字典中不存在的键，当该键不存在是返回None)

info = dict.fromkeys(['one', 'two'], 'know')
print(info.get('one'))

运行结果：
know

　　

　　1.添加key，value值

dict.setdefault('Adderss','故宫')

注意：如果使用

dict['Address'] = '故宫'，会提示This dictionary creation could be rewritten as a dictionary literal 
因为系统检测在程序之前有定义dict，所以不需要分行写，可以直接写到一行

2.访问字典里面的值

print(dict['Name']) 如果写了不存在的值会报错

print(dict.get('Name')) 如果写了不存在的值，返回None

print(dict.get('Name','not find ')) 如果找不到存在的值，返回 “not find”

 

六：update函数：用一个字典更新另外一个字典

 

info = {'Name': 'sara', 'Age': 7,  'Sex': 'F'}

name = {'Name':'john'}
info.update(name)
print(info)

运行结果：
{'Name': 'john', 'Age': 7, 'Sex': 'F'}

 

 

七：访问字典里面的值：

for key in info:
    print(key, info[key])

运行结果：
Name sara
Age 7
Sex F

 

八 字典的内置函数和方法

 

Python字典包含了以下内置函数：
1、cmp(dict1, dict2)：比较两个字典元素。(python3后不可用)
2、len(dict)：计算字典元素个数，即键的总数。
3、str(dict)：输出字典可打印的字符串。
4、type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型。

Python字典包含了以下内置方法：
1、radiansdict.clear()：删除字典内所有元素
2、radiansdict.copy()：返回一个字典的浅复制
3、radiansdict.fromkeys()：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4、radiansdict.get(key, default=None)：返回指定键的值，如果值不在字典中返回default值
5、radiansdict.has_key(key)：如果键在字典dict里返回true，否则返回false
6、radiansdict.items()：以列表返回可遍历的(键, 值) 元组数组
7、radiansdict.keys()：以列表返回一个字典所有的键
8、radiansdict.setdefault(key, default=None)：和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
9、radiansdict.update(dict2)：把字典dict2的键/值对更新到dict里
10、radiansdict.values()：以列表返回字典中的所有值