dict字典学习记录

---恢复内容开始---

dict字典是python内置的一种映射（mapping），key：value的格式，key只能用不能改变的序列（元组tuple，string）或者数字表示。key：value 被称为字典的一项item

1、初始化字典

>>> a = dict()
>>> a
{}

也可以写成a = {} 直接初始化一个空的字符串

2、空的字典是可以插入键值对的，但是list不可以，

>>> a = dict()
>>> a
{}
>>> a['name']='Beth'
>>> a
{'name': 'Beth'}

>>> a=dict([("name","Beth"),("age",43)])##dict 可以接受一个可迭代的参数，如list，tuple
>>> a
{'name': 'Beth', 'age': 43}

也可以直接赋值

a = {'name': 'Beth', 'age': 43}

>>> b = [] ###空的list里是没有元素的，插入元素会提示下标index超出范围；对于有值的list，如果插入的下标index超出范围，也会提示这个错误
>>> b[0]=1
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
b[0]=1
IndexError: list assignment index out of range

3、len()方法，返回字典item的数量

>>> a
{'name': 'Beth', 'age': 43}
>>> len(a)
2

4、dict[key],返回k对应的值

>>> a = {'name': 'Beth', 'age': 43}

>>> a['name']
'Beth'

5、key in dict ，in成员检查方法，返回值是布尔值，是返回true，不是返回false；字典的成员检测只能用key值，不能用value值；n in list,n不是list的下标而是元素；

>>> a = {'name': 'Beth', 'age': 43}

>>> 'name' in a
True
>>> 'addr' in a
False

>>> 'Beth' in a ###字典的成员检测只能用key值，不能用value值
False

####在字典中判断key的成员资格，比在list中判断元素成员资格要高效，数据越大，越明显

6、dict[k]=v,如果字典dict中没有k值，则字典增加k：v项，如果字典中有k，则将k原对应的值，修改成k

>>> a = {'name': 'Beth', 'age': 43}

>>> a['addr'] = '北京' ###增加项
>>> a
{'name': 'Beth', 'age': 43, 'addr': '北京'}
>>> a['age']=44 ###修改key对应的值
>>> a
{'name': 'Beth', 'age': 44, 'addr': '北京'}

7、字典的格式化字符串%s--->%(key)s,宽度精度，符号也是适用的放在%(key)符号宽度.精度s，

>>> "this is %(mode)s time"%{'mode':'beautiful'}
'this is beautiful time'

>>> "this is %(mode)10.3s time"%{'mode':'beautiful'}
'this is bea time'
>>> "this is %(mode)-10.3s time"%{'mode':'beautiful'}
'this is bea time'

实例：

template = '''
<html>
    <head><title>%(title)s</title></head>
    <body>
        <h1>%(title)s</h1>
        <p>%(text)s</p>
    </body>
</html>

'''

data = {'title':'My Home Page','text':'Welcome to my home page!'}

print(template % data)

8、clear（），清除dict里的所有项，改变原字典，没有返回值

>>> a
{'name': 'Beth', 'age': 44, 'addr': '北京'}
>>> a.clear()
>>> a
{}

##############

>>> a = {'name': 'Beth', 'age': 44, 'addr': '北京'}

>>> b=a

>>> b
{'name': 'Beth', 'age': 44, 'addr': '北京'}

并不是b复制了字典a,得到一个字典a的副本，而是a和b都指向了内容{'name': 'Beth', 'age': 44, 'addr': '北京'}，a和b任意一个修改字典，另一个也会改变

>>> b['addr']="上海"
>>> b
{'name': 'Beth', 'age': 44, 'addr': '上海'}
>>> a
{'name': 'Beth', 'age': 44, 'addr': '上海'}

>>> del a['name'] ###del 删除字典的某一项
>>> a
{'age': 44, 'addr': '上海'}
>>> b
{'age': 44, 'addr': '上海'}

9、copy方法，可以复制一个字典的副本出来，但是这个函数属于‘浅复制’，副本删除或者增加项或者替换key对应的value值都不会影响原字典；但是如果值为list或者tuple，修改他们，原字典也会跟着改变；

>>> x = {'username':'admin','machines':['foo','bar','baz']}
>>> y = x.copy()
>>> y
{'username': 'admin', 'machines': ['foo', 'bar', 'baz']}

>>> y['username']='user' ###替换username对应的值，原字典未变
>>> y
{'username': 'user', 'machines': ['foo', 'bar', 'baz']}
>>> x
{'username': 'admin', 'machines': ['foo', 'bar', 'baz']}

>>> y['machines']=['A','B'] ####替换machines对应的list的值，原字典不改变
>>> y
{'username': 'admin', 'machines': ['A', 'B']}
>>> x
{'username': 'admin', 'machines': ['foo', 'bar', 'baz']}

>>> x ={'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
>>> y = x.copy()
>>> y
{'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
>>> y['machines'][1]='sun' ####修改machines对应list的某个元素，原字典也跟着改变
>>> y
{'username': 'admin', 'machines': ['foo', 'sun', 'baz']}
>>> x
{'username': 'admin', 'machines': ['foo', 'sun', 'baz']}

>>> y['machines'].append('test') ####machines对应的lis增加元素，原字典也跟着改变
>>> y
{'username': 'admin', 'machines': ['foo', 'sun', 'baz', 'test']}
>>> x
{'username': 'admin', 'machines': ['foo', 'sun', 'baz', 'test']}

>>> y['machines'].remove('foo') ####删除machines对应的list的某个元素，原字典也跟着改变
>>> y
{'username': 'admin', 'machines': ['sun', 'baz', 'test']}
>>> x
{'username': 'admin', 'machines': ['sun', 'baz', 'test']}

10、deepcopy 深复制，修改值对应的list，原字典也不会改变

from copy import deepcopy

>>> a = {'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
>>> b = deepcopy(a)
>>> b
{'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
>>> b['machines'].remove('foo')
>>> b
{'username': 'admin', 'machines': ['bar', 'baz']}

>>> a
{'username': 'admin', 'machines': ['foo', 'bar', 'baz']}

11、fromkeys（iterable，value=None）用iterable创建key，如果未指定默认值，则默认值为None

>>> {}.fromkeys(('name','age'))
{'name': None, 'age': None}
>>> {}.fromkeys(('name','age'),'N/A')
{'name': 'N/A', 'age': 'N/A'}
>>> dict.fromkeys(['name','age',(1,)])
{'name': None, 'age': None, (1,): None}

12、get（key，defalut=None），有点类似dict[key],有一点不同如果访问的key值不存在dict中，dict[key]就会报错，而dict.get(key)则不报错返回None，也可以指定返回的内容

>>> b={'username': 'admin', 'machines': ['bar', 'baz']}
>>> b['username']
'admin'
>>> b.get('username')
'admin'
>>> b.get('age','not available') ####指定访问的key不存在时，返回‘not available’
'not available'

实例：

# 根据客户输入的名字和命令，输出客户的电话或者地址
# 建立people库
people = {
    'alice':{
        'phone':'2341',
        'addr':'Foo driver 23'
    },
    'Beth':{
        'phone':'9120',
        'addr':'Bar street 42'
    },
    'cecil':{
        'phone':'3158',
        'addr':'Baz avenue 90'
    }
}

# 方便获取客户命令
lable = {'p':'phone','d':'addr'}
# 获取客户输入的名字
name = input('Name:')
# 选择要获取的信息
key = input('Phone number(p) or address(a)?')

###如果name在people中，根据客户命令输出 
if name in people:
    print("%s's %s is:%s "%(name,lable[key],people[name][lable[key]]))
else:
    print("%s is not here"%name)

##如果name存在people中但是客户输入的命令不是我们提供的p和a，系统就会报错，程序的容错性不好，只考虑了name不存在的情况

####用get（）方法改写上面的程序

person = people.get(name,{})##name存在则正常返回值，不存在则返回{}
request=lable.get(key,key)##考虑到客户输入的命令对错都要输出所以，key存在则正常返回命令，错误返回客户输入的命令
result = person.get(request,'not available')###客户输入的key对应的request存在，则返回对应的值，不在则提示not available
print("%s's %s is %s"%(name,request,result))

13、keys(),返回一个dict_keys对象，是一种like_set对象，可以遍历取值；python2是直接返回keys组成的列表

>>> d={'phone': 'phone number', 'addr': 'address'}
>>> d.keys()
dict_keys(['phone', 'addr']) ####这是一个对象

>>> for key in d.keys(): ###遍历dict_keys对象
　　　　print(key)

phone
addr
>>> b = [key for key in d.keys()] ##使用列表推导式，将遍历得到的key值，存放到一个新的列表中
>>> b
['phone', 'addr']

14、items（）、values（）方法和keys（）方法一致，items（）方法返回dict_items对象，values（）返回dict_values对象

>>> I = [item for item in d.items()]
>>> I
[('phone', 'phone number'), ('addr', 'address')]
>>> V = [value for value in d.values()]
>>> V
['phone number', 'address']

15、pop（k[,d]）方法删除指定k，并返回k对应的value值；如果删除的k不存在，怎返回d（如果给了参数d），如果没有给参数d，k也不存在则抛出KeyError

>>> d = {'phone': 'phone number', 'addr': 'address'}
>>> d.pop('age','age is not available') ###删除的key值不存在，d='age is not available'
'age is not available'
>>> d.pop('addr','addr not available') ###删除的key值存在，则返回k对应的v
'address'
>>> d
{'phone': 'phone number'}
>>> d.pop('age') ####删除的k值不存在，d未给定，raise KeyError；
Traceback (most recent call last):
File "<pyshell#48>", line 1, in <module>
d.pop('age')
KeyError: 'age'

16、popitem(),没有参数值，删除dict中的某个item，并返回该item（k，v），但是这个删除是随机的，因为字典是无序的。

>>> d = {'phone': 'phone number', 'addr': 'address'}
>>> d.popitem()
('addr', 'address')

17、setdefault(self, key, default=None, /) 如果字典中没有这个key值，这个函数就插入key值和它对应的default的值，修改字典；如果这个key已经存在则返回key对应的value值，不修改字典；setdefault（）是不接受关键字参数的，用关键字参数会报错

>>> d
{'phone': 'phone number'}
>>> d.setdefault('addr',None) ####无关键字参数，第二个参数可以自己指定
>>> d
{'phone': 'phone number', 'addr': None}

>>> d.setdefault('age',default=None) ###关键字参数
Traceback (most recent call last):
File "<pyshell#54>", line 1, in <module>
d.setdefault('age',default=None)
TypeError: setdefault() takes no keyword arguments

>>> d.setdefault('phone','telephone') ###key值已存在字典中，返回字典中key对应的value，不改变字典
'phone number'
>>> d
{'phone': 'phone number', 'addr': None}

17、 D.update([E, ]**F) -> None. Update D from dict/iterable E 或 F.；这个函数只接受一个参数E或F

　　##用字典F更新字典D，如果key值重复，则覆盖D字典的值；key值不重复，则添加到字典D中

　　　　>>> d = {'phone':'phone number','addr':'address'}
　　　　>>> f = {'phone':'telephone','Home':'Beijng'}
　　　　>>> d.update(f)
　　　　>>> d
　　　　　　{'phone': 'telephone', 'addr': 'address', 'Home': 'Beijng'}　　

　　###用可迭代的键/值对来更新字典，不能直接使用元素会报错

　　　　>>> d = {'phone':'phone number','addr':'address'}

　　　　>>> e = [('age',18),('home','Beijing')] ####list中存放元组
　　　　>>> d.update(e)
　　　　>>> d
　　　　　　{'phone': 'phone number', 'addr': 'address', 'age': 18, 'home': 'Beijing'}

　　　　>>> d = {'phone':'phone number','addr':'address'}
　　　　>>> e = ('gentle','男') ###update函数是取元素里的键值对，直接用元组会把第一个元素当成要执行的键值对来对待，放到list就可以了
　　　　>>> d.update(e)
　　　　Traceback (most recent call last):
　　　　File "<pyshell#98>", line 1, in <module>
　　　　d.update(e)
　　　　ValueError: dictionary update sequence element #0 has length 6; 2 is required

　　　　关键字参数替换　　　　

　　　　>>> d = {'phone':'phone number','addr':'address'}
　　　　>>> d.update(age=18) ###不能写成‘age’=18 这个是表达式，不是关键字参数
　　　　>>> d
　　　　　　{'phone': 'phone number', 'addr': 'address', 'age': 18}

　　　　>>> d.update('home'='beijing')
　　　　SyntaxError: keyword can't be an expression

---恢复内容结束---

猜你喜欢