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

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

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

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

修改字典中相应的键对应的值：字典变量名[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