@extends('template')

@section('title')
    Lab 10, Part 1: Simple dictionaries
@stop

@section('content')

# Lab 10, Part 1: Simple dictionaries

{{--
<iframe width="560" height="315" src="https://www.youtube.com/embed/X9UDfAOauww" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
--}}

## Cheat sheet: lists vs. dictionaries

This table shows key operations for lists and dictionaries:

<table style="background-color: #fafad2; padding: 6pt;">
<thead>
<tr>
  <th>Operation</th>
  <th>For list <code>L</code></th>
  <th>For dictionary <code>D</code></th>
  <th>Notes</th>
</tr>
</thead>
<tbody>
<tr>
  <td>check # of items</td>
  <td><code>len(L)</code></td>
  <td><code>len(D)</code></td>
  <td>Dictionaries have exactly one value per key.</td>
</tr>
<tr>
  <td>add an item</td>
  <td><code>L.append(item)</code>, or <code>L.insert(index, item)</code></td>
  <td><code>D[key]&nbsp;=&nbsp;value</code></td>
  <td>Dictionary requires both a key and a value.</td>
</tr>
<tr>
  <td>replace an item</td>
  <td><code>L[index]&nbsp;=&nbsp;value</code></td>
  <td><code>D[key]&nbsp;=&nbsp;value</code></td>
  <td>Same syntax as creating a new key for a dictionary.</td>
</tr>
<tr>
  <td>remove an item</td>
  <td><code>L.pop(index)</code></td>
  <td><code>D.pop(key)</code></td>
  <td>Pop without argument works for lists (removes last item) but not dicts.</td>
</tr>
<tr>
  <td>check presence of an item</td>
  <td><code>item&nbsp;in&nbsp;L</code></td>
  <td><code>key&nbsp;in&nbsp;D</code></td>
  <td>To check for a value in a dictionary, use <code>value&nbsp;in&nbsp;D.values()</code></td>
</tr>
<tr>
  <td>retrieve an item</td>
  <td><code>x&nbsp;=&nbsp;L[index]</code></td>
  <td><code>x&nbsp;=&nbsp;D[key]</code>, or <code>x&nbsp;=&nbsp;D.get(key)</code></td>
  <td><code>.get</code> will return <code>None</code> if the key is missing instead of causing a <code>KeyError</code>.</td>
</tr>
<tr>
  <td>index loop</td>
  <td><pre class="hljs language-py python">
<code>for i in range(len(L)):
    ...</code></pre></td>
  <td><pre class="hljs language-py python">
<code>for key in D:
    ...</code></pre></td>
  <td>Order of a dictionary is based on the order in which keys were added.</td>
</tr>
<tr>
  <td>value loop</td>
  <td><pre class="hljs language-py python">
<code>for item in L:
    ...</code></pre></td>
  <td><pre class="hljs language-py python">
<code>for value in D.values():
    ...</code></pre></td>
  <td>There's no good way to retrieve the key based on a dictionary value. If you need the key, use an index loop instead.</td>
</tr>
</tbody>
</table>


<a id='cs111dict'> </a>

<!--## Task 1: Create a **name:year** cs111 dictionary
-->
<img src="keyValue.png" style='max-height:45px;' alt="Text reads Task 1: Create a name:year cs111 dictionary with green annotated script over the name:year part that reads key:value">

<div class='partnerA'>Partner A</div>

In your `lab10` folder there is a file called `nameYear.py` 
that contains a list of 107 fictitious CS111 students and their corresponding graduation year.

Here is a snapshot of what the **list** looks like (you can open the file in Thonny). Note that it is a **list** of **lists**.

```py
# nameYear.py
nameYear = [
      ...
    ['Sarah', '2024'],
    ['Preedah', '2023'],
       ...
    ['Yujue', '2022'],
    ['Shan', '2024'],

]
```

Your first task is to create a Python **dictionary** from this data where the **`key` is the student names** and the **`value` is the corresponding years**.

Make a new file called `simpleDictionaries.py`. At the top of the file, import the provided `nameYear` data:

```py
from nameYear import *
```

Then, do the following:

1. Create an empty dictionary called `cs111dict`.
2. For each list (student) in `nameYear`, create a dictionary entry in the `cs111dict` where the `key` is the student's name and the `value` is their year.

Check the results of your work by invoking `len(cs111dict)`&mdash; there should be **101** entries.

<img src="confusedBear.jpg" max-width="300px" alt="A confused bear.">Wait a second. Why are there only **101** entries? There are **107** students  in our fictitious `nameYear.py` list! What happened? 
<!-- hint: Lauren x 3, Angela x 2, Hannah x 2, Rebecca x 2, Sarah x 2 -->
Once your `cs111dict` is built, try out the following statements and describe/discuss the results with your partner:

- `list(cs111dict.items())`
- `list(cs111dict.keys())`
- `list(cs111dict.values())`
- `cs111dict['Annabel']`
- `cs111dict['BugsBunny']`
- `cs111dict['2022']`
- `'Annabel' in cs111dict`
- `'WonderWoman' in cs111dict`


## Task 2: Create a **year:[names]** CS111 dictionary

<div class='partnerB'>Partner B</div>

Now, using the same `nameYear` variable, write a function called `makeYearDict` that returns a dictionary where the **keys** are the year of graduation and the **values** are lists of students who will graduate in that year. 


Let's say you want to build your dictionary from scratch and we want to add these students:
```py
['Andy', '2025'], ['Sohie', '2024'], ['Peter', '2025']
```

At this point, our dictionary is empty:
```py
yearDict = { }
```

Let's take Andy first. His year is 2025. After we add Andy to the dictionary, it looks like this:

```py
yearDict = {'2025': ['Andy'] }
```
Now we add in Sohie, who has a different year, so that means a new key:value pair.
```py
yearDict = {'2025': ['Andy'],
            '2024': ['Sohie']
           }
```
And now we add in Peter. Peter will graduate in 2025, so we can add their name to the list associated with the key '2025':
```py
yearDict = {'2025': ['Andy', 'Peter'],
            '2024': ['Sohie']
           }
```

Hint: remember that each **key** in a dictionary must be unique. So if the key already exists in your dictionary, then add the name to list associated with that key.

Here is some sample testing code:
```py
# Create the year dictionary
yearDict = makeYearDict(nameYear)
list(yearDict.keys())
# ['2024', '2022', '2023', '2025']  # remember order doesn't matter
yearDict['2022'] 
# ['Angela', 'Rumi', 'Helen', 'Lisa', 'Yujue', 'Maya', 'Ting']
yearDict['2025'] 
# ['Lena', 'Andrea', 'Amal', 'Ronghao', 'Alexandra', 'Rebecca', 'Rebecca', 'Jocelyn', 'Bryant', 'Claire']
len(yearDict['2024'])
# 57
len(yearDict['2023']) 
# 33

```


{{--
<iframe width="560" height="315" src="https://www.youtube.com/embed/cG6xGbnm6_U" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
--}}

<!-- commenting this out, takes too much time for not enough yield.
Will add some more finger exercises at beginning
-->
<!--
## Task 2: A simple word dictionary
Next, you'll build a function that converts a list of words into a dictionary.

Start by importing the provided `wordlist` data at the top of your file:

```py
from wordlist import *
```

This will give you access to the following three lists of words:

```py
smallWordList = ['waist','body','board','bad','or','wit','as']
mediumWordList = ["age", "all", "and", ..., "with", "wow", "zoo"]
bigWordList = ["10th", "1st", "2nd", ..., "zucchini", "zurich", "zygote"]
```

Now write a fruitful function **makeDictionary** that...

+ Expects a *list* of Strings as a parameter
+ Returns a *dictionary* containing all the words from the file.

<br>
The structure of the dictionary should be such that for each element, **both the key and the value should be a word from the given list of words**. (It doesn’t actually matter what the `value` is for the `key:value` pairs for this example, because we only use the keys as a fast way to check whether a string is in the dictionary.)

Example:
```py
if __name__ == '__main__':
    smallDict = makeDictionary(smallWordList)
    print(smallDict)
    # {'board': 'board', 'waist': 'waist', [...], 'or': 'or', 'as': 'as'}

    print(len(smallDict)) # 7
```

Notes:
+ Start testing with the smaller list and work your way up to the big one.
+ The bigWordList contains strings recognized by the Unix operating system, so it contains some single letters and strings that you might not typically consider words.

## Task 3: Use your dictionary to spell-check sentences

Write a function called `checkSentence` that takes two parameters: a sentence and a dictionary and returns
True if all the words in the sentence are in the dictionary, and False if not. If the function returns False,
it will indicate the first word in the sentence that does not appear in the dictionary.


First, there are two important things to note:

1. Let's assume you have created three different dictionaries from the given word lists:
```py
smallDict = makeDictionary(smallWordList)
medDict = makeDictionary(mediumWordList)
bigDict = makeDictionary(bigWordList)
```
2. You can break a sentence into separate words by using `split`. `split` stashes the words in a list.
Here is the [python documentation for split](https://docs.python.org/2/library/stdtypes.html#str.split), and here is a [simple split example](http://www.pythonforbeginners.com/dictionary/python-split).
```py
In []: "This sentence can be split into separate words".split()
Out[]: ['This', 'sentence', 'can', 'be', 'split', 'into', 'separate', 'words']
```


Here are some examples of how your `checkSentence` should work:

```py
In []: checkSentence("lawn", smallDict)
Oops: 'lawn' is not found in my dictionary
Out[]: False

In []: checkSentence("lawn", medDict)

Out[]: True

In []: checkSentence("her duck is yellow", smallDict)
Oops: 'Her' is not found in my dictionary
Out[]: False

In []: checkSentence("her duck is yellow", medDict)
Oops: 'yellow' is not found in my dictionary
Out[]: False

In []: checkSentence("her duck is yellow", bigDict)
Out[]: True

In []: checkSentence("her duck ate the spoon from the zoo", medDict)
Oops: 'the' is not found in my dictionary
Out[]: False

In []: checkSentence("her duck ate the spoon from the zoo", bigDict)
Out[]: True

In []: checkSentence("her magenta duck got 2nd place in the pie contest", medDict)
Oops: 'magenta' is not found in my dictionary
Out[]: False

In []: checkSentence("her magenta duck got 2nd place in the pie contest", bigDict)
Out[]: True

In []: checkSentence("imagine how surprised we were when the duck won", bigDict)
Oops: 'surprised' is not found in my dictionary
Out[]: False

```

## Note: Spell checking 
We are using dictionaries with our spell-checker to make it fast (it checks each word against the 25,104 words in the `bigDict`).
It's a rather crude spell-checker. An even better version would return a list of all the misspelled words in a given sentence, control for upper/lower case and ignore punctuation. 
-->

@include('/labs/lab10/_toc')

@stop