023 Python初学笔记--字典：字典的内置函数和内置方法的使用和举例

一、字典：字典是python中唯一的映射类型。

1. 简单的创建字典：变量名={key1:value1,key2=values,...}

2. 访问字典相应的键所对应的值：字典变量名[key]

3. 修改字典中相应的键对应的值：字典变量名[key]=value,若修改的键不存在，则将其键值加入字典中

>>> #创建空字典
>>> dict1={}

>>> #创建字典：字典变量名={key1:value1,key2:value2,...}
>>> dict2={1:'one','李宁':'一切皆有可能'}

>>> #访问字典中的键所对应的值
>>> dict2['李宁']
'一切皆有可能'

>>> #修改字典中的键值
>>> dict2[1]='hello'
>>> #当字典中所对应的键不存在时
>>> dict2['特步']='永不止步'
>>> dict2
{1: 'hello', '李宁': '一切皆有可能', '特步': '永不止步'}

二、用python的工厂函数（dict函数）创建字典 

函数	功能	用法	英文解释
dict()	创建空字典	dict()	new empty dictionary
dict(mapping)	通过映射方式创建字典	dict(((key1,value),(key2,value)...))或dict(zip([key1,key2...],[value1,value2...]))	new dictionary initialized from a mapping object's (key, value) pairs
dict(iterable)	通过可迭代对象的方式创建字典	dict([(key1,value1),(key2,value2)...])	new dictionary initialized as if via:       d = {}       for k, v in iterable:           d[k] = v
dict(**kwargs)	通过传入关键字的方式创建字典	dict(key1=value1,key2=value2...)	new dictionary initialized with the name=value pairs in the keyword argument list.  For example:  dict(one=1, two=2)

>>> #创建空字典：dict()
>>> dict()
{}

>>> #通过映射方式创建字典1：dict(((key1,value),(key2,value)...))
>>> dict(((1,'one'),(2,'two'),(3,'three')))
{1: 'one', 2: 'two', 3: 'three'}
>>> #通过映射方式创建字典2:dict(zip([key1,key2...],[value1,value2...]))
>>> dict(zip(['a','b','c'],['A','B','C']))
{'a': 'A', 'c': 'C', 'b': 'B'}

>>> #通过可迭代对象的方式创建字典：dict([(key1,value1),(key2,value2)...])
>>> dict([('I','love you'),('you','handsom'),('he','haha')])
{'I': 'love you', 'you': 'handsom', 'he': 'haha'}

>>> #通过传入关键字的方式创建字典：dict(key1=value1,key2=value2...)
>>> dict(a='AA',b='BB',c='CC')
{'a': 'AA', 'c': 'CC', 'b': 'BB'}

三、字典中的内置函数和方法：

1.字典的内置函数和使用举例：

内置函数	函数功能
len(dict)	计算字典中的元素个数，即键的总数
str(dict)	以可打印字符串的形式输出字典
type(variable)	返回变量的类型

>>> dict1={1:'one',2:'two',3:'three'}
>>> #len(dict)：计算字典中的元素个数,即键的总数
>>> len(dict1) 
3

>>> #str(dict)：输出字典，以可打印的字符串表示
>>> str(dict1)
"{1: 'one', 2: 'two', 3: 'three'}"

>>> #type(variable) 返回变量类型
>>> type(dict1)

2.字典中的内置方法和使用举例:

内置方法	使用	功能
clear()	dict1.clear()	清空字典
copy()	dict1.copy()	返回一个字典的浅复制
fromkeys()	dict.fromkeys(seq[,value])	创建一个新字典，序列seq中的元素做字典的键，value为字典所有的键所对应的初始值，若不设置value,默认所有的键所对应的值为None
keys()	dict1.keys()	访问字典中所有的键,返回值为一个列表
values()	dict1.values()	访问字典中所有的值,返回值为一个列表
items()	dict1.items()	访问字典中的键和值，并返回一个列表
get()	get(key[,formation])	返回字典中指定的键key所对应的值,为当所访问的键不存在时，返回的信息formation。若不设置返回信息，默认返回None；如果所访问的键存在，则返回相应的值。
setdefault()	setdefault(key[,value])	向字典中添加一对键key和值value，并返回value。若未给出value，默认设置并返回默认值None。若要添加的键已存在，则返回该建所对应的值
in，not in	key1 in dict1	判断键是否在字典中
update()	dict1.update(dict2)	利用字典dict2扩展字典dict1
pop()	pop(key)	删除字典中指定的键值对，返回被删除的值。
popitem()	popitem()	随机删除并返回字典中的一对键和值

>>> dict1={1:'one',2:'two',3:'three'}
>>> #clear()清空字典
>>> dict1.clear()
>>> dict1
{}

>>> #copy():返回一个字典的浅复制
>>> dict2={1:'one',2:'two',3:'three'}
>>> dict3=dict2.copy()
>>> dict3
{1: 'one', 2: 'two', 3: 'three'}

>>> #fromkeys(seq[,value]) 创建一个新字典，序列seq中的元素做字典的键，value为字典多有的键所对应的初始值
>>> dict4=dict.fromkeys((1,2,3))
>>> dict4
{1: None, 2: None, 3: None}
>>> dict5=dict.fromkeys((1,2,3),'number')
>>> dict5
{1: 'number', 2: 'number', 3: 'number'}
 
>>> #访问字典的方法：keys(),values(),items()
>>> dict1={1:'one',2:'two',3:'three'}
>>> keys()
>>> for i in dict1.keys():
	print(i)

	
1
2
3
>>> dict1.keys()
[1, 2, 3]
>>> #values()
>>> dict1.values()
['one', 'two', 'three']
>>> #items()
>>> dict1.items()
[(1, 'one'), (2, 'two'), (3, 'three')]
>>> for each in dict1.items():
	print(each)

	
(1, 'one')
(2, 'two')
(3, 'three')

>>> #get(key[,value])：返回字典中指定的键key所对应的值,value为当所访问的键不存在时，返回的信息。默认返回None；如果所访问的键存在，则返回相应的值。
>>> dict1={1:'one',2:'two',3:'three'}
>>> print(dict1.get(4,'不存在'))
不存在
>>> print(dict1.get(2,'不存在'))
two
>>> print(dict1.get(5))   #默认返回None
None

>>> #setdefault(key[,value]):向字典中添加一对键key和值value，并返回value。若未给出value，默认设置并返回默认值None。若要添加的键已存在，则返回改建所对应的值
>>> dict1={'name':'Rubby','university':'Shandong'}
>>> dict1.setdefault('sex')
>>> dict1.setdefault('baby','Swan')
'Swan'
>>> dict1
{'name': 'Rubby', 'university': 'Shandong', 'sex': None, 'baby': 'Swan'}
>>> print(dict1.setdefault('sex','male'))
None

>>> #in，not in判断键是否在字典中
>>> dict1={1:'one',2:'two',3:'three'}
>>> 1 in dict1
True
>>> 5 not in dict1
True

>>> #dict1.update(dict2):利用字典dict2扩展字典dict1
>>> a={1: 'one', 'name': 'Sam'}
>>> c={'adress':'China'}
>>> a.update(c)
>>> a
{1: 'one', 'name': 'Sam', 'adress': 'China'}

>>> #pop(key)删除字典中相应的键值对，并返回被删除的值。
>>> a={'name':'Ursula','sex':'female'}
>>> a.pop('sex')
'female'
>>> a
{'name': 'Ursula'}

>>> #popitem():随机删除并返回字典中的一对键值
>>> a={1:'one','a':'AA','name':'cat'}
>>> a.popitem()
('name', 'cat')
>>> a
{1: 'one', 'a': 'AA'}

注： 

1.不要使用fromkeys()试图给字典中的键批量赋值

dict1=dict.fromkeys((1,2,3),('one','two','three'))
>>> dict1
{1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}

2.使用fromkeys()关键字试图修改字典中的值也是不能实现的,系统会重新创建一个字典 

>>> dict1.fromkeys((1,2),'num')
{1: 'num', 2: 'num'}

 3.为什么不直接访问字典中的键值，而要使用get?

因为如果直接访问字典中不存在的键，系统会报错，使用get方法可以避免这样的错误。

4.清空字典的方法为clear,那么dict1={}与dict1.clear()方法有什么不同呢?

clear()方法是将字典中的内容清空。而dict1={}是重新创建了一个空字典，原来字典里的内容依然存在，这样的操作并不利于数据的安全，用户还是可以通过其他途径访问到字典中的数据。

>>> dict2=dict1;dict3=dict1
>>> dict1={}
>>> dict2
{'a': 'A', 'b': 'B'}
>>> dict1.clear()
>>> dict2
{'a': 'A', 'b': 'B'}
>>> dict2.clear()
>>> dict3
{}

5.copy方法和直接赋值有什么不同?

copy方法是重新创建了一个字典，并将原来字典中的内容复制过来。而dict2=dict1的赋值方法，是给原来的字典重新取了一个名字而已。

>>> dict1={'a':'A','b':'B'}
>>> dict2=dict1;dict3=dict1.copy()
>>> id(dict1);id(dict2);id(dict3)
2387017617912
2387017617912
2387017618200