@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>

## Task 1: Create a **name:year** cs111 dictionary
In your `lab10` folder there is a file called `nameYear.py` that contains a list of current CS111 students and their corresponding graduation year.

Here is a snapshot of what the list looks like:

```py
# nameYear.py
nameYear = [
    ['Sophia', '2022'],
    ['Emily', '2021'],
       ...
    ['Rebecca', '2021'],
    ['Alexandra', '2023'],

]
```

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 **86** entries.

<img src="confusedBear.jpg" max-width="300px">Wait a second. Why are there only **86** entries? There are **93** students enrolled in CS111 this semester! What happened? 
<!-- hint: Irene, Becky, Sara, Elizabeth, Katherine, Sophia -->
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['Anna']`
- `cs111dict['BugsBunny']`
- `cs111dict['2022']`
- `'Anna' in cs111dict`
- `'WonderWoman' in cs111dict`


## Task 2: Create a **year:[names]** CS111 dictionary
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', '2021'], ['Sohie', '2020'], ['Cibele', '2021']
```

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

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

```py
yearDict = {'2021': ['Andy'] }
```
Now we add in Sohie, who has a different year, so that means a new key:value pair.
```py
yearDict = {'2021': ['Andy'],
            '2020': ['Sohie']
              }
```
And now we add in Cibele. Cibele will graduate in 2021, so we can add her name to the list associated with the key '2021':
```py
yearDict = {'2021': ['Andy', 'Cibele'],
            '2020': ['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())
# ['2020', '2022', '2023', '2021']  # remember order doesn't matter
yearDict['2020'] 
# ['Olivia','Stephanie', 'Sandra', 'Jing', "Lydia', 'Megan']
yearDict['2021'] 
#['Alexandria', 'Courtney', 'Alexa ', 'Nia', 'Sara', 'Hope',
#  'Sophia', 'Carson', 'Fatima', 'Meghan'] 
# Test 2022 and 2023 too!
```


<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