10python dictionary - Programmer All (2023)

The difference between the list and dictionary is that the list can access the value through the index, and the dictionary can access each value through the name.

The data structure of the dictionary is calledMaping (MAPPING)The dictionary is the only internal mapping type in Python. The value is not arranged in order, but the storage and then under the key.
Among them, the key can be numbers, string or meta -group, etc.Unchangedtype of data.

The purpose of the dictionary

The name of the dictionary pointed out the purpose of this data structure. The dictionaries in daily life and dictionaries in Python can easily obtain its defined value through words (keys).

• Indicates the distribution of the chessboard, and each key is a meta -group composed of coordinates
• The storage file modification time, the key in which is the file name
• Digital phone/address book

Find data through the list:

>>> >>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']>>> numbers = ['2341', '9102', '3158', '0142', '5551'] >>> Numbers [names.index ('CECIL')] # To find the CEIL number, it is troublesome to pass the list method'3158'>>>

Create and use dictionary

If you find the phone number above, you can achieve it by creating a dictionary.

>>> phonebook = {'Alice': '2314', 'Beth': '9102', 'Cecil': '3258'}>>> phonebook['Alice']'2314'>>>

Dictionary (Dict)Depend onKey (key)CorrespondinglyValueComposition, this key-value symmetricalItem (item)。

In the above example, the key is the name and the value of the mobile phone number.

Between each key and the values, the colon (:) is separated, the comma is separated by the items, and the entire dictionary is placed in the bracket.

Empty dictionary (no item) is represented by two large brackets, similar to it {}。

In the dictionary (and other mapping types), the key must be unique, and the value in the dictionary has no requirements.

You can use the function DICT to create a dictionary from other mapping (such as other dictionaries) or key values:

>>> >>> items = [('name', 'Gubmy'), ('age', 42)]>>> d = dict(items) >>> d{'name': 'Gubmy', 'age': 42}>>> d['name']'Gubmy'>>>>>> >>> D = Dict (name = 'Gumby', Age = 42) # Use keywords to create dictionaries>>> d{'name': 'Gumby', 'age': 42}>>>

Basic dictionary operation

The basic behavior of the dictionary is similar to the sequence in many aspects.

• len(d)Return to the dictionary (key value pair) number
• d[k]Return andkAssociated value
• d[k] = vValuevAssociated to the keyk
• del d[k]Delete key tokItem
• k in dCheck the dictionarydWhether to include a key positionkItem

There are some differences in dictionary and lists.

• Type of key: The key in the dictionary can be an integer, and the single is not an integer. The keys in the dictionary can be any unchanged type, such as floating -point numbers (real numbers), string, and tuples.—— The main advantage of the dictionary

• Automatically add: Even if there is no key in the dictionary, it can be assigned to him, which will create a new item in the dictionary; but if you are not applicable to APPEND or other similar methods, you cannot assign the elements not in the list in the list.

• Member qualification: Expression k in d(in dIt is a dictionary) Finding is a key, not a value, but an expression v in l(in lIt is a list) Finding is value rather than index. In fact, the keys in the dictionary can be understood as the index in the list, so here is different. Check whether the efficiency contains the key in the checklist is higher than the value in the checklist, which also shows thatThe larger the data structure, the greater the efficiency gap。

  >>> >>> x = [] >>> x [42] = 'Foobar' # Because there is no index 42 in the empty list, an error will be reported. [None]*43 must be used when definedTraceback (most recent call last): File "<stdin>", line 1, in <module>IndexError: list assignment index out of range>>>>>> x = {} >>> x [42] = 'Foobar' #>> can be assigned to the key that is not available, which will generate a new item>>> x{42: 'Foobar'}>>>

Create a telephone book database code example

# A simple database # Putting a person's name as a key dictionary, everyone is represented by a dictionary # Dictionary contains key 'phone' and 'addr', which are associated with phone numbers and addresses, respectivelypeople = { 'Alice': { 'phone': '2341', 'addr': 'Foo driver 23' }, 'Beth': { 'phone': '9102', 'addr': 'Bar street 42' }, 'Cecil': { 'phone': '3158', 'addr': 'Baz avenue 90' }} # Telephone number and address descriptive label for printing and outputlabels = { 'phone': 'phone number', 'addr': 'address'}name = input('Name: ') # To find the phone number or addressrequest = input('Phone number (p) or address (a) ? ') # Use the correct keyif request == 'p': key = 'phone'if request == 'a': key = 'addr' # When the name is the key contained in the dictionary, print the informationif name in people: print("{}'s {} is {}.".format(name, labels[key], people[name][key])) # OutputName: BethPhone number (p) or address (a) ? pBeth's phone number is 9102.

Formatal reference dictionary

The most commonly used method for character production formatting isformat。

You can also store a series of naming values ​​in the dictionary, which can make the format settings easier. When extraction, you only need to extract the required information in the format string, useformat_mapLet's point out that you will provide the required information through a mapping.

>> >>> phonebook = {'Alice': '2314', 'Beth': '9102', 'Cecil': '3258'}>>> "Cecil's phone number is {Cecil}.".format_map(phonebook)"Cecil's phone number is 3258.">>>>>> >>> # As long as all field names are included in the dictionary key, you can specify the conversion instructions of any amount. as follows: template = '''<html> <head> <title> {title} </title> </head> <body> <h1> {title} </h1> <p> {text} </p> </body></html>'''data = {'title': 'My Home Page', 'text': 'Welcome to my home page!'}print(template.format_map(data))# Output'''<html> <head> <title> My Home Page </title> </head> <body> <h1> My Home Page </h1> <p> Welcome to my home page! </p> </body></html>'''

Dictionary

Like other built -in types, the dictionary also has methods. The dictionary method is very useful. Introduce several commonly used dictionary methods.

• clear

Methods Clear delete all dictionary items.

>>> >>> d = {}>>> d['name'] = 'Gumby'>>> d['age'] = 42>>> d{'name': 'Gumby', 'age': 42}>>> returned_value = d.clear()>>> d{}>>> print(returned_value) None>>> >>> # Scenario 1: "Clear" X by assigning an empty dictionary to X, but does not affect Y. This method is very useful.>>> x = {}>>> y = x>>> x['key'] = 'value'>>> y{'key': 'value'}>>> x{'key': 'value'}>>> x = {}>>> y{'key': 'value'}>>> x{}>>> >>> # Scenario 2: Clear the clear method to delete the elements in x and y at the same time. This method is very useful>>> x = {}>>> y = x>>> x['key'] = 'value'>>> y{'key': 'value'}>>> x{'key': 'value'}>>> x.clear()>>> y{}>>> x{}>>>

• copy

Methods Copy returned a new dictionary, which contained the key value as the same as the original dictionary (this method executesShallow reproductionBecause the value itself is the original, not a copy).

Shallow reproductionThe obtained copy, replacing the value in the copy, the original is not affected, but the value in the modified copy will also modify the value in the original, because the original point is also the value of the modified value.

DeepenThis problem can be avoided.

>>> >>> x = {'username': 'admin', 'machines': ['foo', 'bar', 'baz']} >>> y = x.copy () #>>>>> y['username'] = 'mlh'>>> y['machines'].remove('bar')>>> y{'username': 'mlh', 'machines': ['foo', 'baz']}>>> x {'Username': 'admin', 'Machines': ['foo', 'baz']} #>>>>>>>>> >>> from copy import deepcopy>>> d = {}>>> d['name'] = ['Alfred', 'Berthand']>>> c = d.copy() >>> dc = deepcopy (d) # Deep copy>>> d['name'].append('Clive')>>> c {'name': ['Alfred', 'Berthand', 'Clive']} #>>> dc{'name': ['Alfred', 'Berthand']}>>>

• fromkeys

Method FROMKEYS creates a new dictionary, which contains the specified key, and the corresponding value of each key is None.

# Create another dictionary from the empty dictionaryd = {}df = d.fromkeys(['name', 'age']) print(df) # {'name': None, 'age': None} # Use DICT to create a dictionary directly (DICT is the type of all dictionaries)df = dict.fromkeys(['name', 'key'])print(df) # {'name': None, 'age': None} # 值df1 = dict.fromkeys(['name', 'age'], '(unknown)')print(df1) # {'name': '(unknown)', 'age': '(unknown)'}

• get

Methods GET provides a loose environment for access dictionary items. Because the items that are usually not in the dictionary will occur errors.

>>> >>> d = {} >>> d ['name'] #>>>>>>Traceback (most recent call last): File "<stdin>", line 1, in <module>KeyError: 'name'>>> >>> Print (d.Get ('name')) #The return to None through the get methodNone>>> >>> D.Get ('name', 'n/a') # specify the default value (if you have value, return, return to the silent value)'N/A'>>>>>> d['name'] = 'Eric'>>> d {'name': 'Eric'} >>> D.Get ('name') # When accessing, it is worth it'Eric'

Optimize the code with the get method:

# A simple database using get () can ensure that even if the input value is wrong, it can be output normally # Putting a person's name as a key dictionary, everyone is represented by a dictionary # Dictionary contains key 'phone' and 'addr', which are associated with phone numbers and addresses, respectivelypeople = { 'Alice': { 'phone': '2341', 'addr': 'Foo driver 23' }, 'Beth': { 'phone': '9102', 'addr': 'Bar street 42' }, 'Cecil': { 'phone': '3158', 'addr': 'Baz avenue 90' }} # Telephone number and address descriptive label for printing and outputlabels = { 'phone': 'phone number', 'addr': 'address'}name = input('Name: ') # To find the phone number or addressrequest = input('Phone number (p) or address (a)? ') # Use the correct key Key = request # If request is neither 'p' nor 'a'if request == 'p': key = 'phone'if request == 'a': key = 'addr' # Use GET to provide the default valueperson = people.get(name, {})label = labels.get(key, key)result = person.get(key, 'not available') # # 才print("{}'s {} is {}.".format(name, label, result))

• items

Method ITEMS returns a list containing all dictionary items, where each element is displayed in the form (key, value). The sorting is uncertain.

The return value belongs to a nameDictionary viewSpecial types, iterative and checked length. The dictionary view will not copy the original dictionary after generating, even if the original dictionary is modified.

You can use List to convert the dictionary view into a list.

>>> >>> d = {'title': 'Python Web Site', 'url': 'http://www.python.org', 'span': 0}>>> d.items() DICT_ITEMS ([('title', 'python web site'), ('url', 'http://www.python.org'), ('span', 0)] #) The return value belongs to a name. The special type of the dictionary view, iterative, the check length>>>>>> it = d.items()>>> len(it)3>>> ('span', 0) in itTrue>>> >>> D ['span'] = 1 # Modification Dictionary D does not affect the dictionary view IT>>> ('span', 0) in itFalse>>> d['span'] = 0 >>> ('span', 0) in itTrue>>> >>> l = list (d.Items ()) # Use the list method to convert the dictionary view to a list>>> l[('title', 'Python Web Site'), ('url', 'http://www.python.org'), ('span', 0)]>>> 

• keys

Methods keys return oneDictionary view, Includes the keys in the specified dictionary.

>>> >>> d = {'title': 'Python Web Site', 'url': 'http://www.python.org', 'span': 0}>>> d.keys() dict_keys(['title', 'url', 'span'])>>>

• values

Method Values ​​returned a dictionary view consisting of a value in the dictionary. Different from the method Keys, the view returned by method Values ​​may contain duplicate values.

>>> >>> d = {}>>> d[1] = 1>>> d[2] = 2 >>> d[3] = 3 >>> d[4] = 1 >>> d{1: 1, 2: 2, 3: 3, 4: 1}>>> d.values()dict_values([1, 2, 3, 1])>>>

• pop

Method POP can be used to obtain the value associated with the specified key, and delete the key value to the dictionary.

>>> >>> d = {'x': 1, 'y': 2, 'z': 3}>>> d.pop('x')1>>> d{'y': 2, 'z': 3}>>>

• popitem

Methods Popitem is similar to list.pop, but the last element of list.pop pops up, and Popitem ejects a dictionary item randomly (because the order of the dictionary item is uncertain, all the concepts of "last element '), so the dictionary dictionary There is no method of APPEND in a similar list, which is meaningless.

This method can delete and process all dictionary items one by one, because there is no need to get the dictionary list first.

>>>>>> d = {'title': 'Python Web Site', 'url': 'http://www.python.org', 'span': 0}>>> d.popitem()('span', 0)>>> d{'title': 'Python Web Site', 'url': 'http://www.python.org'}>>>

• setdefault

Methods Setdefault is a bit like get. Get the value when there is a key, but you can add a key value pair when there is no key

>>> >>> d = {'title': 'Python Web Site', 'url': 'http://www.python.org', 'span': 0}>>> d.setdefault('title')'Python Web Site'>>> d{'title': 'Python Web Site', 'url': 'http://www.python.org', 'span': 0} >>> D.Setdefault ('name', 'n/a') # setdefault specified when the value specified does not exist, return the specified value and update the dictionary;'N/A'>>> d{'title': 'Python Web Site', 'url': 'http://www.python.org', 'span': 0, 'name': 'N/A'}>>> d.setdefault('type', 'Python') 'Python'>>> d{'title': 'Python Web Site', 'url': 'http://www.python.org', 'span': 0, 'name': 'N/A', 'type': 'Python'}>>>

• update

Method UPDATE uses items in a dictionary to update another dictionary. If it is not added, it will be updated if there is.

>>> >>> d = {'title': 'Python Web Site', 'url': 'http://www.python.org', 'spam': 0} >>> x = {'title': 'Python Language Website'} >>> D.Update (X) # Here to understand, it is to call the UPDATE method to the dictionary D, so it should be used to update the contents of the dictionary D instead of changing the contents of the dictionary X>>> d{'title': 'Python Language Website', 'url': 'http://www.python.org', 'spam': 0}>>>