Python 字典

Dict 数据类型

一、创建一个字典

>>> a = {'name': 'gm', 'age': 18}
>>> a
{'age': 18, 'name': 'gm'}

二、查看字典

# 获取字典a的值
>>> a
{'age': 18, 'name': 'gm'}

# 获取特定key的值
>>> a.['name']'gm'
>>> a.['age']18

三、查看列表可进行的操作

>>> dir(a)
['clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

dict 函数方法

class dict(object):
    """
    dict() -> new empty dictionary
    dict(mapping) -> new dictionary initialized from a mapping object's
        (key, value) pairs
    dict(iterable) -> new dictionary initialized as if via:
        d = {}
        for k, v in iterable:
            d[k] = v
    dict(**kwargs) -> new dictionary initialized with the name=value pairs
        in the keyword argument list.  For example:  dict(one=1, two=2)
    """
    def clear(self): # real signature unknown; restored from __doc__
        """ D.clear() -> None.  Remove all items from D. """
        pass

    def copy(self): # real signature unknown; restored from __doc__
        """ D.copy() -> a shallow copy of D """
        pass

    @staticmethod # known case
    def fromkeys(*args, **kwargs): # real signature unknown
        """ Create a new dictionary with keys from iterable and values set to value. """
        pass

    def get(self, *args, **kwargs): # real signature unknown
        """ Return the value for key if key is in the dictionary, else default. """
        pass

    def items(self): # real signature unknown; restored from __doc__
        """ D.items() -> a set-like object providing a view on D's items """
        pass

    def keys(self): # real signature unknown; restored from __doc__
        """ D.keys() -> a set-like object providing a view on D's keys """
        pass

    def pop(self, k, d=None): # real signature unknown; restored from __doc__
        """
        D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
        
        If the key is not found, return the default if given; otherwise,
        raise a KeyError.
        """
        pass

    def popitem(self, *args, **kwargs): # real signature unknown
        """
        Remove and return a (key, value) pair as a 2-tuple.
        
        Pairs are returned in LIFO (last-in, first-out) order.
        Raises KeyError if the dict is empty.
        """
        pass

    def setdefault(self, *args, **kwargs): # real signature unknown
        """
        Insert key with a value of default if key is not in the dictionary.
        
        Return the value for key if key is in the dictionary, else default.
        """
        pass

    def update(self, E=None, **F): # known special case of dict.update
        """
        D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
        If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
        If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
        In either case, this is followed by: for k in F:  D[k] = F[k]
        """
        pass

    def values(self): # real signature unknown; restored from __doc__
        """ D.values() -> an object providing a view on D's values """
        pass

    def __class_getitem__(self, *args, **kwargs): # real signature unknown
        """ See PEP 585 """
        pass

    def __contains__(self, *args, **kwargs): # real signature unknown
        """ True if the dictionary has the specified key, else False. """
        pass

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __eq__(self, *args, **kwargs): # real signature unknown
        """ Return self==value. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, y): # real signature unknown; restored from __doc__
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __ge__(self, *args, **kwargs): # real signature unknown
        """ Return self>=value. """
        pass

    def __gt__(self, *args, **kwargs): # real signature unknown
        """ Return self>value. """
        pass

    def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
        """
        dict() -> new empty dictionary
        dict(mapping) -> new dictionary initialized from a mapping object's
            (key, value) pairs
        dict(iterable) -> new dictionary initialized as if via:
            d = {}
            for k, v in iterable:
                d[k] = v
        dict(**kwargs) -> new dictionary initialized with the name=value pairs
            in the keyword argument list.  For example:  dict(one=1, two=2)
        # (copied from class doc)
        """
        pass

    def __ior__(self, *args, **kwargs): # real signature unknown
        """ Return self|=value. """
        pass

    def __iter__(self, *args, **kwargs): # real signature unknown
        """ Implement iter(self). """
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    def __le__(self, *args, **kwargs): # real signature unknown
        """ Return self<=value. """
        pass

    def __lt__(self, *args, **kwargs): # real signature unknown
        """ Return self<value. """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __ne__(self, *args, **kwargs): # real signature unknown
        """ Return self!=value. """
        pass

    def __or__(self, *args, **kwargs): # real signature unknown
        """ Return self|value. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __reversed__(self, *args, **kwargs): # real signature unknown
        """ Return a reverse iterator over the dict keys. """
        pass

    def __ror__(self, *args, **kwargs): # real signature unknown
        """ Return value|self. """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __sizeof__(self): # real signature unknown; restored from __doc__
        """ D.__sizeof__() -> size of D in memory, in bytes """
        pass

    __hash__ = None

四、常用的字典操作

• 插入新的键值

# 插入新的键值
>>> a
{'age': 18, 'name': 'gm'}
>>> a['job'] = '运维'
>>> a
{'age': 18, 'job': '运维', 'name': 'gm'}

• 修改字典某键的值

# 修改字典某键的值
>>> a
{'age': 18, 'name': 'gm'}
>>> a['name']='root'
>>> a
{'age': 18, 'name': 'root'}

• 获取字典某元素的值

# 获取字典某元素的值
>>> a
{'age': 18, 'job': '运维', 'name': 'gm'}
>>> a['gender']
Traceback (most recent call last):
  File "<pyshell#51>", line 1, in <module>
    a['gender']
KeyError: 'gender'

>>> a.get('gender')
>>> a.get('gender',-1)
-1
>>> a.get('name',-1)
'gm'

• 删除字典某元素

# 删除字典某元素
>>> a
{'age': 18, 'job': '运维', 'name': 'gm'}
>>> a.pop('job')
'运维'
>>> a
{'age': 18, 'name': 'gm'}

# 获取字典删除的元素的值
>>> a
{'age': 18, 'job': '运维', 'name': 'gm'}
>>> c = a.pop('job')
>>> c
'运维'
>>> a
{'age': 18, 'name': 'gm'}

• keys()、values()、items()方法

# Python3中字典的keys()、values()、items()方法的区别
>>> a.keys()       # 以列表返回字典所有的键
dict_keys(['age', 'job', 'name'])

>>> a.values()     # 以列表返回字典中的所有值
dict_values([18, '运维', 'gm'])

>>> a.items()      # 以列表返回字典可遍历的(键, 值) 元组数组
dict_items([('age', 18), ('job', '运维'), ('name', 'gm')])

五、字典练习

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，
将所有大于 66 的值保存至字典的第一个key中，
将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66 , 'k2': 小于66}

b = {}
a = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90, ]

for i in a:
    if i > 66:
        if 'k1' in b.keys():
            b['k1'].append(i)
        else:
            b['k1']= [i, ]
    else:
        if 'k2' in b.keys():
            b['k2'].append(i)
        else:
            b['k2']= [i, ]

print(b)
print(b['k1'])
print(b['k2'])

• 运行结果

{'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]}

[77, 88, 99, 90]
[11, 22, 33, 44, 55, 66]