Related introduction to python mapping types

The mapping type is a combination of iterable key-value data items, which provides methods for accessing data items and their keys and values. In python3, two unordered mapping types are supported: built-in dict and Collections.defaultdict type in the standard library.

After python3.1, an ordered mapping type was also introduced: collections.OrderedDict.

Related recommendations: "python video"

Features:

1. Only hashable objects can be used for keys in map types, therefore, built-in fixed data types They can all be used as keys in mapping types (all built-in fixed types can be hashed). The fixed data types currently exposed are: int, float, complex, bool, str, tuple, frozenset;

2. The value associated with each key can be any object;

3. The mapping type is also iterable (iterable).

4. Mapping types can be compared using comparison operators, membership operators in/not in and the built-in len() function.

1.dict (dictionary)

The dict data type is an unordered, variable combination data type that contains 0 -n key-value pairs, the key is a reference to a hashable object, and the value can point to a reference to any object. Because the key is a hashable object reference, the uniqueness of the key is guaranteed; because the dict is mutable, data items can be added and removed from the dict; because the dict is unordered, there is no index , nor can it be operated using the sharding operator.

Creation of dictionary

1.dict() can be called as a function, and an empty dict is created at this time:

>>> dict()
{}
>>>

dict() When a mapping type parameter is passed in, a dictionary based on the parameter will be returned, such as:

>>> d1 = {"key1":"value1","key2":"value2"}
>>> dict(d1)
{'key1': 'value1', 'key2': 'value2'}
>>>

dict() can also accept sequence type parameters, but only if each data item in the sequence itself is a sequence containing two objects, the first is used as a key, and the second is used as a value, such as:

>>> d1 = dict((("k1","v1"),("k2","v2")))   #使用元组创建
>>> d1
{'k1': 'v1', 'k2': 'v2'}
>>> 
>>> d1 = dict([("k1","v1"),("k2","v2")])   #使用序列创建
>>> d1
{'k1': 'v1', 'k2': 'v2'}
>>>

dict() can also be created with keyword parameters, where the key is used as a keyword, Value as the value of the keyword, such as:

>>> dict(id=1,name="zhangsan",age=23)
{'id': 1, 'name': 'zhangsan', 'age': 23}
>>>

Note: The keyword must be a valid python identifier

2. Use curly braces to create a dict, empty {} will create an empty dict , a non-empty dict consists of multiple items, each item is separated by a comma, each item is created in the form of K:V, such as:

>>> dict2 = {"name":"kobe","age":33,"num":24}
>>> dict2
{'name': 'kobe', 'age': 33, 'num': 24}
>>>

3. Use dictionary connotation to create a dictionary

defaultdict is a subclass of dict, which supports all operations and methods of dict. The difference from dict is that if the dict does not contain a certain key, a KeyError exception will occur when obtaining the value through dict[x], but if it is defaultdict, a new item will be created with the key as the key and the value as default value.

2.collections.defaultdict (default dictionary)

Create collections.defaultdict

Create collections.defaultdict, through collections.defaultdict(), there are two ways to create according to the parameters:

* 1. Use the parameter type to create:

>>> import collections
>>> cd1 = collections.defaultdict(int)
>>> cd2 = collections.defaultdict(list)
>>> cd3 = collections.defaultdict(str)
>>> cd1["x"]
0
>>> cd2["x"]
[]
>>> cd3["x"]
''
>>>

Here, int, list, str, their default values ​​are 0, [], "

* 2. Use the function name to create:

>>> def name():
    return 'zhangsan'
>>> cd4 = collections.defaultdict(name)
>>> cd4["x"]
'zhangsan'
>>>

In this way, you can make the default value of the default dictionary More flexible.

It should be noted that collections.defaultdict() can pass in no parameters or None, but if so, the default value is not supported, such as:

>>> cd5 = collections.defaultdict()
>>> cd5["x"]
Traceback (most recent call last):
  File "<pyshell#254>", line 1, in <module>
    cd5["x"]
KeyError: &#39;x&#39;
>>>

Yes collections.defaultdict can replace the get(k,v) and setdefault() methods in dict.

##3.collections.OrderedDict

OrderedDict is a dict subclass that supports all dict methods, remembering the order in which keys were inserted. If a new entry overwrites an existing entry, the original insertion position remains unchanged. Deleting an entry and reinserting it will move it to the end.

class collections.OrderedDict([items])

Because they are ordered, two OrderedDicts are the same only when the order is the same. However, when comparing OrderedDict with an ordinary dict, the order will be ignored.

from collections import OrderedDict
d = {'banana': 3, 'apple': 4}
od1 = OrderedDict({'banana': 3, 'apple': 4})
od2 = OrderedDict({'apple': 4, 'banana': 3})
print(od1 == od2)
print(od1 == d)

Running results

FalseTrue

3. Key method

OrderedDict.popitem(last=True)

This method of ordinary dict does not accept parameters and can only delete the last entry; OrderedDict is more flexible than dict and accepts a last parameter: when When last=True, it is the same as the ordinary method, conforming to LIFO order; when last=False, the first element is deleted, conforming to FIFO order.

from collections import OrderedDict
od1 = OrderedDict({'banana': 3, 'apple': 4})
od1.popitem(False)
print(od1)

Running results

OrderedDict([('apple', 4)])

4. Simple enhancement

OrderedDict just maintains the order of insertion. When the entry is modified, the order will not be modified.

od1 = OrderedDict({'banana': 3, 'apple': 4})
od1['banana'] = 5print(od1)

Running results

OrderedDict([('banana', 5), ('apple', 4)])

But sometimes we need to modify and insert the same The effect can be simply enhanced by rewriting the __setitem__() method to first delete the element and then insert it when modifying.

class EnhancedOrderedDict(OrderedDict):
    def __setitem__(self, key, value):        
        if key in self:
           del self[key]
       OrderedDict.__setitem__(self, key, value)

Test

eod = EnhancedOrderedDict({'banana': 3, 'apple': 4})print(eod)
eod['banana'] = 5print(eod)

Running result

EnhancedOrderedDict([('banana', 3), ('apple', 4)])
EnhancedOrderedDict([('apple', 4), ('banana', 5)])

The above is the detailed content of Related introduction to python mapping types. For more information, please follow other related articles on the PHP Chinese website!