# Make Game FLASH CARD

## FLASH CARD TESTER <a href="#section-2.flashcardtester" id="section-2.flashcardtester"></a>

Ever need to memorize something? Flash cards can really do the trick! So we're going to build a command line flash card tester application. Let's get started.

Imagine you want to learn the capitals of countries in the Middle East. Let's make some flashcards.

By the end of this chapter you will be able to:

1. Read a file with python3
2. Parse data from a **JSON** format into a python **dictionary**
3. Iterate over an array
4. Take user input from the command line

MARK AS COMPLETE

## GETTING STARTED <a href="#section-gettingstarted" id="section-gettingstarted"></a>

Flash Cards will be made out of just one python file. You can tell if a file is python code if it ends in the `.py` document type.

If you don't already have one, navigate to the root of your computer, to the `~` directory, and make a new directory called `code`, then in that directory make a new directory called `cli-games`. We'll put all the games we make in this tutorial in this folder. In that directory make a new directory called `flash-cards` and in that directory make two files, one called `flashcards.py` and one called `me-capitals.json` (where we will put our flash card data of "Middle Eastern Capitals").

Make your initial project folder and two main files:

```
$ cd ~
$ mkdir code
$ cd code
$ mkdir cli-games
$ cd cli-games
$ mkdir flash-cards
$ cd flash-cards
$ touch flashcards.py
$ touch me-capitals.json
```

Now your folder should look like this:

```
| cli-games
  | flash-cards
    |- flashcards.py
    |- me-capitals.json
  ...
```

It is important to keep your coding projects organized on your computer. Having a centralized folder called `code` or `dev` where you put all projects is a great pattern to follow.MARK AS COMPLETE

## OPEN THE DIRECTORY IN ATOM <a href="#section-openthedirectoryinatom" id="section-openthedirectoryinatom"></a>

Now let's get started coding. To code we will use the code editor Atom. If you don't already have this code editor, head over to the [Atom website](https://atom.io/) and download and install it.

You can use Atom like any other word processor you are used to, but you can also use it from the command line to open a single file or a whole project folder.

Let's try using the command line command `atom .` to open the directory we are currently in. Make sure you have navigated to the `flash-cards` directory, then type the following:

```
(flash-cards)$ atom .
```

**Clarification** - The period (`.`) in `atom .` means "this directory". You can also open a project using a path, e.g. from the root `~` type the command `$ atom code/cli-games`MARK AS COMPLETE

## MAKE A PLAN <a href="#section-makeaplan" id="section-makeaplan"></a>

Software engineers always start any work by writing up a plan for how they will work on a project. This tutorial will provide you with this plan to start off with:

We have basically five steps:

1. Setup the cards data that we want to quiz ourselves with
2. Write code that reads the cards data and parses it into a python dictionary
3. Write code that iterates over the cards
4. Get the users's input for each question
5. Check the users input against the answer
6. Display "Correct!" or "Incorrect!"

MARK AS COMPLETE

## SETTING UP CARD DATA <a href="#section-settingupcarddata" id="section-settingupcarddata"></a>

Let's imagine we have a list of Middle Eastern countries and their capitals. Let's write those into a format called JSON.

Go into your `me-capitals.json` file and let's add a little bit of JSON.

```
{
  "cards": [
    {
      "q": "What is the capital of Syria?",
      "a": "Damascus"
    }
  ]
}
```

This bit of JSON has one root key called `cards`, and the value associated with `cards` is an array of cards. Each element in the array `[]` is an object `{}` with two keys `q` for "question" and `a` for "answer".

JSON is a very popular way to store and transmit data in the internet. It is a great format for data because it is easy for computers and humans to read it and write it. JSON's basic structure is comma-delimited **Key-Value Pairs** surrounded by curly-bracies `{}`. Notice that keys are strings, and values can be any form of data, including arrays `[]`, and objects `{}`. By having arrays and objects as values gives JSON a nested tree structure. As you use JSON more you will become very familiar with its structure.MARK AS COMPLETE

## READ A FILE <a href="#section-readafile" id="section-readafile"></a>

A python script `.py` can read files around it using file system commands native to python.

Let's use these commands to read the `me-capitals.json` file and parse the JSON into a data format python can manipulate: a **Dictionary**. (Python can't work with JSON itself, it has to change it into an equivalent structure that it understands).

Now we need to read this file and print its contents.

```python
# flashcards.py

# import the json module from python3
import json

# open the file and parse the JSON
with open('me-capitals.json', 'r') as f:
    data = json.load(f)
    print(data)
```

First we import the `json` module and then we use the use the `open` built-in function, and pass it two arguments:

1. The name of the file: `me-capitals.json`
2. An option—in this case `'r'`, which just means "read"

The `as f:` part means that the contents of the file is passed into the `open` function as the variable f.

So finally we use the `json` module we imported above to `.load(f)` that is to load the contents of the file and parse it from json into a python dictionary called `data`.

Always test your code after each step by running it and checking that the step you just completed is working. Run your project with this command:

```python
$ python3 flashcards.py
```

When you run this, you should see the contents of the file:

```python
{'cards': [{'q': 'What is the capital of Syria?', 'a': 'Damascus'}]}
```

The only difference between JSON and a python dictionary is the keys have `''` single quotes whereas the JSON has `""` double-quotes. Now that you are an engineer, you should be aware and focus on tiny differences like that because they matter to the computer.MARK AS COMPLETE

## FOR LOOP ITERATOR <a href="#section-forloopiterator" id="section-forloopiterator"></a>

We've completed the first two steps, so next we have to iterate over the `cards` array:

1. DONE - Setup the data
2. DONE - Write code that reads the data file and parses it into a python dictionary
3. Write code that iterates over the data
4. Get the users's input for each question
5. Check the users input against the answer and display "Correct!" or "Incorrect!"

**Iterating** over something in code is like a teacher calling roll. The teacher calls out a name in their list of students. Each student responds present if they are present, and there is no response if they are absent. In code, you could say the teacher **iterates** through the array of students and calls a function that returns “present” if the student is present, otherwise it returns "<>".

We will use what is called a For Loop iterator to iterate over all the cards. The For Loop has this structure:

```python
for <<ITEM>> in <<LIST or ARRAY>>
```

Let's add a for loop to our flashcards:

```python
# flashcards.py

# import the json module from python3
import json

# open the file and parse the JSON
with open('me-capitals.json', 'r') as f:
    data = json.load(f)

for i in data["cards"]:
    print(i)
```

`data["cards"]` is the way to access a value in a key-value pair inside a python dictionary. Since the structure looks like this:

```python
{'cards': [{'q': 'What is the capital of Syria', 'a': 'Damascus'}]}
```

We need to access the `cards` key, to get back its array value `[{'q': 'What is the capital of Syria', 'a': 'Damascus'}]`.

Run the program again using `python3 flashcards.py` and make sure you get output as described aboveMARK AS COMPLETE

## A FEW MORE QUESTIONS <a href="#section-afewmorequestions" id="section-afewmorequestions"></a>

We're using learning the capitals of countries in the middle east for our cards.

Let's add a few more capitals to our `me-capitals.json` file:

```python
{
  "cards": [
    {
      "q": "What is the capital of Syria?",
      "a": "Damascus"
    },
    {
      "q": "What is the capital of Lebanon?",
      "a": "Beirut"
    },
    {
      "q": "What is the capital of Israel?",
      "a": "Jerusalem"
    },
    {
      "q": "What is the capital of Jordan?",
      "a": "Amman"
    },
    {
      "q": "What is the capital of Iraq?",
      "a": "Baghdad"
    }
  ]
}
```

Now rerun the program and see if your iterator prints out each questionMARK AS COMPLETE

## GETTING CLI INPUT <a href="#section-gettingcliinput" id="section-gettingcliinput"></a>

Ok now we need to get the user to actually try to answer each question. To access the question in each object, we'll do so using the same way we accessed `cards` inside of data: `i["q"]`. And we'll use the `input` built-in function to prompt the user to enter an input.

Update `flashcards.py` to the following:

```python
# flashcards.py

# import the json module from python3
import json

# open the file and parse the JSON
with open('me-capitals.json', 'r') as f:
    data = json.load(f)

for i in data["cards"]:
    guess = input(i["q"] + " > ")
    print(guess)
```

Run this program and see that you can see your guess printed out.MARK AS COMPLETE

## CHECK FOR CORRECT ANSWER <a href="#section-checkforcorrectanswer" id="section-checkforcorrectanswer"></a>

So now we've done four of our five steps we set out to do, so all we have now is to check if the answer is right:

1. DONE - Setup the data
2. DONE - Write code that reads the data file and parses it into a python dictionary
3. DONE - Write code that iterates over the data
4. DONE - Get the users's input for each question
5. Check the users input against the answer and display "Correct!" or "Incorrect!"

We'll check correct and incorrect using the equality operator: `==`.

Update your for loop in `flashcards.py` to the following:

```python
# flashcards.py

import json

with open('me-capitals.json', 'r') as f:
    data = json.load(f)

for i in data["cards"]:
    guess = input(i["q"] + " > ")

    if guess == i["a"]:
        print("Correct!")
    else:
        print("Incorrect!")
```

A note on **Clear Variable Naming**. Variables can be named almost anything, so it is important to pick names that are logical and semantic. We named the user's input "guess" because in terms of this program, that is what it is, the user's input is a guess at what the flashcard's answer is. Always consider carefully what to name a variable and pick a logical and clear name.MARK AS COMPLETE

## ADDING THE CORRECT ANSWER WHEN INCORRECT <a href="#section-addingthecorrectanswerwhenincorrect" id="section-addingthecorrectanswerwhenincorrect"></a>

Now let's polish up the user experience by display the correct answer when someone get's the answer wrong.

```python
# flashcards.py

import json

with open('me-capitals.json', 'r') as f:
    data = json.load(f)

for i in data["cards"]:
    guess = input(i["q"] + " > ")

    if guess == i["a"]:
        print("Correct!")
    else:
        print("Incorrect! The correct answer was", i["a"])
```

Run the program and see how this looks. Pretty good?MARK AS COMPLETE

## CASE SENSITIVITY <a href="#section-casesensitivity" id="section-casesensitivity"></a>

Notice right now that if you enter "jerusalem" instead of "Jerusalem" you get the answer wrong. We could remove this, but capitals are capitalized aren't they.

But what if we want to make other cards for biology or French words? Capitalizing the answer exactly will be annoying.

To fix this we can use the `string.lower()` string function to lowercase the whole word before we compare them.

```python
...

if guess.lower() == i["a"].lower():

...
```

Now the comparison is only between all lowercase text no matter what. You can try this out by changing the code in `flashcards.py` if you want to see it in action.MARK AS COMPLETE

## BRAINSTORM NEW FEATURES <a href="#section-brainstormnewfeatures" id="section-brainstormnewfeatures"></a>

What else could you add to this program? Here are some ideas:

1. As them if they want to play again at the end.
2. Randomize the order of questions.
3. Keep playing until the player gets all the questions right at least once.
4. Keep playing until the player answers correctly 10 in a row.
5. Create various `data` files that are different sets of questions and let people pick which one they want to do.
6. Let people enter their own cards and save those as libraries of questions and answers.

As a **stretch challenge** now or later, come back and try to implement one of these. But let's do one of them right now.MARK AS COMPLETE

## KEEPING TRACK OF SCORE <a href="#section-keepingtrackofscore" id="section-keepingtrackofscore"></a>

Let's use a variable called `score` to keep track of score with each answer.

Update `flashcards.py` to the following:

```python
# flashcards.py
import json

with open('me-capitals.json', 'r') as f:
    data = json.load(f)

# initialize total as the length of the cards array
total = len(data["cards"])
# initialize score as 0
score = 0

for i in data["cards"]:
    guess = input(i["q"] + " > ")

    if guess == i["a"]:
        # increment score up one
        score += 1
        # interpolate score and total into the response
        print(f"Correct! Current score: {score}/{total}")
    else:
        print("Incorrect! The correct answer was", i["a"])
        print(f"Current score: {score}/{total}")
```

Examine the code above and look at the comments. You can see that we have made 4 changes:

1. We initialized `total` as the length of the cards array using the `len(array)` built-in function.
2. We initialized `score` as 0 because everyone starts with 0 correct answers.
3. Next when they get a right answer we **increment** `score` by 1 using `+= 1`
4. Finally we use a new feature of Python 3.6 called **f-strings** to interpolate `{score}` and `{total}` to our response in the correct and incorrect messages.

Check and see if yours works and troubleshoot any errors.

### Stretch Challenge: f-strings

Can you use **f-strings** to change how we do string interpolations throughout this program?MARK AS COMPLETE

## IN REVIEW: YOU CAN ... <a href="#section-inreview-youcan..." id="section-inreview-youcan..."></a>

So in review here's what you did and what you can do now:

1. You can read a file with python3
2. You can parse data from a **JSON** format into a python **dictionary**
3. You can access elements in a python dictionary
4. You can iterate over an array
5. You can take user input from the command line

Reference : [https://www.makeschool.com/academy/track/standalone/make-games-with-python-soy/flash-cards](https://www.makeschool.com/academy/track/standalone/make-games-with-python-soy/flash-cards)
