A dictionary is like a list, but more general. In a list, the index positions have to be integers; in a dictionary, the indices can be (almost) any type.<\/p>\n
You can think of a dictionary as a mapping between a set of indices (which are called keys) and a set of values. Each key maps to a value. The association of a key and a value is called a key-value pair or sometimes an item.<\/p>\n
As an example, we'll build a dictionary that maps from English to Spanish words, so the keys and the values are all strings.<\/p>\n
The function The curly brackets, This line creates an item that maps from the key This output format is also an input format. For example, you can create a new dictionary with three items.<\/p>\n Since Python 3.7x the order of key-value pairs is the same as their input order, i.e. dictionarys are now orderd structures.<\/p>\n But that doesn't really matter because the elements of a dictionary are never indexed with integer indices. Instead, you use the keys to look up the corresponding values:<\/p>\n The key If the key isn't in the dictionary, you get an exception:<\/p>\n The The To see whether something appears as a value in a dictionary, you can use the method The Exercise 1:<\/strong> Download a copy of the file<\/p>\n https:\/\/www.py4e.com\/code3\/words.txt<\/a><\/p>\n Write a program that reads the word in words.txt and store them as keys in a dictionary. It doesn't matter what the values are. Then you can use the Suppose you are given a string and you want to count how many times each letter appears. There are several ways you could do it:<\/p>\n You could create 26 variables, one for each letters of the alphabet. The you could traverse the string and, for each character, increment the corresponding counter, probably using a chained conditional.<\/p>\n<\/li>\n You could create a list with 26 elements. Then you could convert each character to number (using the build-in function You could create a dictionary with character as keys and counters as the corresponding values. The first time you see a character, you would add an item to the dictionary. After that you would increment the value of an existing item.<\/p>\n<\/li>\n<\/ol>\n Each of these options performs the same computation; but each of them implements that computation in a different way.<\/p>\n An implementation is a away of performing a computation; some implementations are better than others. For example, an advantage of the dictionary implementation is that we don't have to know ahead of time which letters appear in the string and we only have to make room for the letters that do appear.<\/p>\n Here is what the code might look like:<\/p>\n We are effectively computing a histogram, Which is a statistical term for a set of counters(or frequencies).<\/p>\n The Here's the output of the program:<\/p>\n The histogram indicates that the letters "a" and "b" appear once; "o" appears twice, and so on.<\/p>\n Dictionary has a method called We can use The use of the Once of the common uses of a dictionary is to count the occurence of words in a file with some written text. Let's start with a very simple file of words taken from the text of Romeo and Juliet.<\/p>\n For the first set of examples, we will use a shortened and simplified version of the text with no punctuation. Later we will work with the text of the scene with punctuation inclued.<\/p>\n We will write a Python program to read through the lines of the file, break each line into a list of words, and thehn loop through each of the words in the line and count each word using a dictionary.<\/p>\n You will see that we have two Because the inner loop executes all of its iterations each time the outer loop makes a single iteration, we think of the inner loop as iterating "more quickly" and the outer loop as iterating more slowly.<\/p>\n The combination of the two nested loops ensures that we will count every word on every line of the iput file.<\/p>\ndict<\/code> creates a new dictionary with no items. Because dict<\/code> is the name of a built-in function, you should avoid using it as a variable name.<\/p>\n>>> eng2sp = dict()\n>>> print(eng2sp)\n{}<\/code><\/pre>\n{}<\/code>, represent an empty dictionary. To add items to the dictionary, you can use square brackets:<\/p>\n>>> eng2sp['one'] = 'uno'<\/code><\/pre>\n'one'<\/code> to the value "uno". If we print the dictionary again, we see a key-value pair with a colon between the key and value:<\/p>\n>>> print(eng2sp)\n{'one': 'uno'}<\/code><\/pre>\n>>> eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n>>> print(eng2sp)\n{'one': 'uno', 'two': 'dos', 'three': 'tres'}<\/code><\/pre>\n>>> print(eng2sp['two'])\n'dos'<\/code><\/pre>\n'two'<\/code> always maps to the value "dos" so the order of the items doesn't matter.<\/p>\n>>> print(eng2sp['four'])\nKeyError: 'four'<\/code><\/pre>\nlen<\/code> function works on dictionaries; it returns the number of key-value pairs:<\/p>\n>>> len(eng2sp)\n3<\/code><\/pre>\nin<\/code> operator works on dictionary; it tells you whether something appears as a key in the dictionary (appearing as a value is not good enough)<\/p>\n>>> 'one' in eng2sp\nTrue\n>>> 'uno' in eng2sp\nFalse<\/code><\/pre>\nvalues<\/code>, which returns the values as a type that can be converted to a list, and then use the in<\/code> operator:<\/p>\n>>> vals = list(eng2sp.values())\n>>> 'uno' in vals\nTrue<\/code><\/pre>\nin<\/code> operator uses different algorithms for lists and dictionaries. For lists, it uses a linear search algorithm. As the list gets longer, the search tiem gets longer in direct proportion to the length of the list. For dictionaries, Python uses an algorithm called hash table that has a remarkable property: the in<\/code> operator takes about the same amount of time to no matter how many items there are in a dictionary. I won't explain why hash functions are so magical, but you cna read more about it at https:\/\/wikipedia.org\/wiki\/Hash_table<\/a>.<\/p>\nin<\/code> operator as a fast way to check whether a string is in the dictionary.<\/p>\nfhand = open('words.txt', encoding='utf-8')\ndic = dict()\nfor line in fhand:\n words = line.split()\n for word in words:\n dic[word] = 1\nletter = 'laptops'\nif letter in dic:\n print(letter, 'is in the dictionary')<\/code><\/pre>\nDictionary as a set of counters<\/h3>\n
\n
ord<\/code>), use the number as an index into the list, and increment the appropriate counter.<\/p>\n<\/li>\nword = 'brontosaurus'\nd = dict()\nfor c in word:\n if c not in d:\n d[c] = 1\n else:\n d[c] = d[c] + 1\nprint(d)<\/code><\/pre>\nfor<\/code> loop traverses the string. Each time through the loop, if the character c<\/code> is not in the dictionary, we create a new item with the key c<\/code> and the initial value 1 (since we have seen this letter once). If c<\/code> is already in the dictionary we increment d['c']<\/code>.<\/p>\n{'b': 1, 'r': 2, 'o': 2, 'n': 1, 't': 1, 's': 2, 'a': 1, 'u': 2}<\/code><\/pre>\nget<\/code> that takes a key and a default value. If the key appears in the dictionary, get<\/code> returns the corresponding value; otherwise it returns the default value. For example:<\/p>\n>>> counts = { 'chuck' : 1 , 'annie' : 42, 'jan': 100}\n>>> print(counts.get('jan', 0))\n100\n>>> print(counts.get('tim', 0))\n0<\/code><\/pre>\nget<\/code> to write our histogram loop more concisely. Because the get<\/code> method automatically handles the case where a key is not in a dictionary, we can reduce four lines down to one and eliminate the if<\/code> statement.<\/p>\nword = 'brontosaurus'\nd = dict()\nfor c in word:\n d[c] = d.get(c,0) + 1\nprint(d)<\/code><\/pre>\nget<\/code> method to simplify this counting loop ends up being a very commonly used "idiom" in Pythond and we will use it many times in the rest of the book. So you should take a moment and compare the loop using the if<\/code> statement and in<\/code> operator with the loop using the get<\/code> method. They do exactly the same thing, but one is more succinct.<\/p>\nDictionaries and files<\/h3>\n
But soft what light through yonder window breaks\nIt is the east and Juliet is the sun\nArise fair sun and kill the envious moon\nWho is already sick and pale with grief<\/code><\/pre>\nfor<\/code> loops. The outer loop is reading the lines of the file and inner loop is iterating through each of the words on that particular line. This is an example of a pattern called nested loops because one of the loops is the outer loop and the other loop is the inner loop.<\/p>\n\nfname = input('Enter the file name: ')\ntry:\n fhand = open(fname)\nexcept:\n print('File cannot be opened:', fname)\n exit()\n\ncounts = dict()\nfor line in fhand:\n words = line.split()\n for word in words:\n if word not in counts:\n counts[word] = 1\n else:\n counts[word] += 1\n\nprint(counts)<\/code><\/pre>\n