None

what is None?

None is used when there is no value. It is the simplest data structure in Python

I use assert methods to compare None with the other Python data structures to see what it is and what it is not

preview

In AssertionError, I used assertIsNone and assertIsNotNone to test_assertion_error_w_none, that experiment showed that

True is NOT None and NOT equal to None
False is NOT None and NOT equal to None
None is None and equal to None

Here are the tests I have by the end of the chapter

import unittest


class TestNone(unittest.TestCase):

    def test_what_is_none(self):
        self.assertIsNone(None)

    def test_is_none_a_boolean(self):
        self.assertIsNotNone(False)
        self.assertIsNotNone(True)
        self.assertIsInstance(False, bool)
        self.assertIsInstance(True, bool)
        self.assertNotIsInstance(None, bool)

    def test_is_none_an_integer(self):
        self.assertIsNotNone(-1)
        self.assertIsNotNone(0)
        self.assertIsNotNone(1)
        self.assertIsInstance(-1, int)
        self.assertIsInstance(0, int)
        self.assertIsInstance(1, int)
        self.assertNotIsInstance(None, int)

    def test_is_none_a_float(self):
        self.assertIsNotNone(-0.1)
        self.assertIsNotNone(0.0)
        self.assertIsNotNone(0.1)
        self.assertIsInstance(-0.1, float)
        self.assertIsInstance(0.0, float)
        self.assertIsInstance(0.1, float)
        self.assertNotIsInstance(None, float)

    def test_is_none_a_string(self):
        self.assertIsNotNone('')
        self.assertIsNotNone("text")
        self.assertIsInstance('', str)
        self.assertIsInstance("text", str)
        self.assertNotIsInstance(None, str)

    def test_is_none_a_tuple(self):
        self.assertIsNotNone(())
        self.assertIsNotNone((1, 2, 3, 'n'))
        self.assertIsInstance((), tuple)
        self.assertIsInstance((1, 2, 3, 'n'), tuple)
        self.assertNotIsInstance(None, tuple)

    def test_is_none_a_list(self):
        self.assertIsNotNone([])
        self.assertIsNotNone([1, 2, 3, 'n'])
        self.assertIsInstance([], list)
        self.assertIsInstance([1, 2, 3, 'n'], list)
        self.assertNotIsInstance(None, list)

    def test_is_none_a_set(self):
        self.assertIsNotNone(set())
        self.assertIsNotNone({1, 2, 3, 'n'})
        self.assertIsInstance({1, 2, 3, 'n'}, set)
        self.assertNotIsInstance(None, set)

    def test_is_none_a_dictionary(self):
        self.assertIsNotNone(dict())
        self.assertIsNotNone({'key': 'value'})
        self.assertIsInstance({}, dict)
        self.assertIsInstance({'key': 'value'}, dict)
        self.assertNotIsInstance(None, dict)


# NOTES
# None is NOT a dictionary
# None is NOT a set
# None is NOT a list
# None is NOT a tuple
# None is NOT a string
# None is NOT a float
# None is NOT an integer
# None is NOT a boolean
# None is None


# Exceptions seen
# AssertionError

questions about None

Here are questions you can answer after going through this chapter

What is None?
Is None a boolean?
Is None an integer?
Is None a float?
Is None a string?
Is None a tuple?
Is None a list?
Is None a set?
Is None a dictionary?
How can I test if something is None?
How can I test if something is NOT None?
How can I test if something is an instance of a class?
How can I test if something is NOT an instance of class

requirements

I name this project none
I open a terminal
then I make a directory for the project
```
mkdir none
```
the terminal goes back to the command line
```
.../pumping_python
```
I change directory to the project
```
cd none
```
the terminal shows I am now in the none folder
```
.../pumping_python/none
```
I make a folder for the source code
```
mkdir src
```
the terminal goes back to the command line
```
.../pumping_python/none
```
I use touch to make an empty file for the program in the src folder
```
touch src/none.py
```
on Windows without Windows Subsystem for Linux use New-Item src/none.py instead of touch src/none.py
```
New-Item src/none.py
```
the terminal goes back to the command line
```
.../pumping_python/none
```
I make a directory for the tests
```
mkdir tests
```
the terminal goes back to the command line
I use touch to make an empty file in the tests folder to tell Python that it is a Python package

Attention

use 2 underscores (__) before and after init for __init__.py not _init_.py
```
touch tests/__init__.py
```
on Windows without Windows Subsystem for Linux use New-Item tests/__init__.py instead of touch tests/__init__.py
```
New-Item tests/__init__.py
```
the terminal goes back to the command line
I make an empty file for the actual test
```
touch tests/test_none.py
```
on Windows without Windows Subsystem for Linux use New-Item tests/test_none.py instead of touch tests/test_none.py
```
New-Item tests/test_none.py
```
the terminal goes back to the command line
I open test_none.py in the editor of the Integrated Development Environment (IDE)
Tip

I can open a file from the terminal in Visual Studio Code by typing code and the name of the file with
```
code tests/test_none.py
```
test_none.py opens up in the editor

I add the first failing test to test_none.py

import unittest

class TestNone(unittest.TestCase):

    def test_failure(self):
        self.assertFalse(True)

I make a virtual environment in the terminal
```
python3 -m venv .venv
```
on Windows without Windows Subsystem for Linux use python3 -m venv .venv instead of python3 -m venv .venv
```
python -m venv .venv
```
the terminal takes some time then goes back to the command line
I activate the virtual environment
```
source .venv/bin/activate
```
on Windows without Windows Subsystem for Linux use .venv/bin/activate.ps1 instead of source .venv/bin/activate
```
.venv/scripts/activate.ps1
```
the terminal shows
```
(.venv) .../pumping_python/none
```
I upgrade the Python package manager (pip) to the latest version
```
python3 -m pip install --upgrade pip
```
the terminal shows pip being uninstalled then installs the latest version or shows that it is already the latest version
I make a requirements.txt file for the Python programs my project needs
```
echo "pytest-watch" > requirements.txt
```
the terminal goes back to the command line
I use pip to use the requirements file to install pytest-watch
```
python3 -m pip install --requirement requirements.txt
```
on Windows without Windows Subsystem for Linux use python -m pip install --requirement requirements.txt instead of python3 -m pip install --requirement requirements.txt
```
python -m pip install --requirement requirements.txt
```
the terminal shows pip downloads and installs the Python programs that pytest-watch needs to run

I use pytest-watch to run the test

pytest-watch

the terminal shows

================================ FAILURES ================================
_________________________ TestNone.test_failure __________________________

self = <tests.test_none.TestNone testMethod=test_failure>

    def test_failure(self):
>       self.assertFalse(True)
E       AssertionError: True is not false

tests/test_none.py:7: AssertionError
======================== short test summary info =========================
FAILED tests/test_none.py::TestNone::test_failure - AssertionError: True is not false
=========================== 1 failed in X.YZs ============================

I hold ctrl (Windows/Linux) or option or command (MacOS) on the keyboard and use the mouse to click on tests/test_none.py:7 to open it in the editor

I add AssertionError to the list of Exceptions seen in test_none.py

        self.assertFalse(True)


# Exceptions seen
# AssertionError

then I change True to False in the assertion
```
7        self.assertFalse(False)
```
the test passes

test_what_is_none

We need a way to represent nothing or the absence of a value. In mathematics we use 0 to represent no quantity. In some languages or domains we use null, in forms we use N/A when the options do not apply. In Python we use None

RED: make it fail

I change test_failure to test_what_is_none

class TestNone(unittest.TestCase):

    def test_what_is_none(self):
        self.assertIsNotNone(None)

the terminal shows AssertionError

AssertionError: unexpectedly None

assertIsNotNone checks that what is in the parentheses is NOT None

GREEN: make it pass

I change the assertIsNotNone to assertIsNone, which checks if what it gets in parentheses is None

        self.assertIsNone(None)

the test passes

REFACTOR: make it better

I add a note

# NOTES
# None is None


# Exceptions seen
# AssertionError

so far this is a repetition of AssertionError

test_is_none_a_boolean

RED: make it fail

I add another failing test to see if None is a boolean

        self.assertIsNone(None)

    def test_is_none_a_boolean(self):
        self.assertIsNone(False)

# NOTES

the terminal shows AssertionError

AssertionError: False is not None

GREEN: make it pass

I make the assertion True with the assertIsNotNone method

        self.assertIsNotNone(False)

the test passes

REFACTOR: make it better

I add a note
```
13# NOTES
14# False is NOT None
15# None is None
```
Still a repetition of what I learned in AssertionError

I add another failing assertion for the other boolean

        self.assertIsNotNone(False)
        self.assertIsNone(True)

the terminal shows AssertionError

AssertionError: True is not None

I make the assertion True with assertIsNotNone
```
11        self.assertIsNotNone(True)
```
the test passes

I add a note

# NOTES
# True is NOT None
# False is NOT None
# None is None

more repetition

how to test if something is an instance of a class

The unittest.TestCase class has 2 methods I can use to test if an object is a child/instance of a class or not - assertIsInstance and assertNotIsInstance

I add the assertNotIsInstance method to test if False is a boolean
```
11        self.assertIsNotNone(True)
12        self.assertNotIsInstance(False, bool)
```
- assertNotIsInstance checks if the first item it is given is NOT a child/instance of the second item. It is like asking the question is False NOT a child of the bool class?. Okay, this is new
- bool is the class for booleans
the terminal shows AssertionError
```
AssertionError: False is an instance of <class 'bool'>
```
False is a boolean
I make the assertion True with the assertIsInstance method which checks if the first item it is given is a child/instance of the second item. It is like asking the question is False a child of the bool class?
```
12        self.assertIsInstance(False, bool)
```
the test passes

I add a failing line for the other boolean with assertNotIsInstance

        self.assertIsInstance(False, bool)
        self.assertNotIsInstance(True, bool)

the terminal shows AssertionError

AssertionError: True is an instance of <class 'bool'>

True is a boolean

I make the statement True with assertIsInstance
```
13        self.assertIsInstance(True, bool)
```
the test passes

I add assertIsInstance to test if None is a child/instance of the bool class

        self.assertIsInstance(True, bool)
        self.assertIsInstance(None, bool)

the terminal shows AssertionError

AssertionError: None is not an instance of <class 'bool'>

None is NOT a boolean

I make the line True with assertNotIsInstance

    def test_is_none_a_boolean(self):
        self.assertIsNotNone(False)
        self.assertIsNotNone(True)
        self.assertIsInstance(False, bool)
        self.assertIsInstance(True, bool)
        self.assertNotIsInstance(None, bool)


# NOTES

the test passes

Since this is about None, I change the last 2 notes I added
```
17# NOTES
18# None is NOT a boolean
19# None is None
```

I know two new assert methods

assertIsInstance to see if something is an instance of a class
assertNotIsInstance to see if something is NOT an instance of a class

Caution

the naming of the assert methods can be confusing, there is

assertIsNotNone

where Not comes after Is and then there is

assertNotIsInstance

where Is comes after Not. Maybe assertIsNotInstance would have been better, since assertNotIsNone does not sound better than assertIsNotNone. Naming things is its own challenge

test_is_none_an_integer

RED: make it fail

I add a test to see if None is an integer (a whole number)

        self.assertNotIsInstance(None, bool)

    def test_is_none_an_integer(self):
        self.assertIsNone(-1)

the terminal shows AssertionError

AssertionError: -1 is not None

GREEN: make it pass

I make the statement True with assertIsNotNone

        self.assertIsNotNone(-1)

the test passes

REFACTOR: make it better

I add a new failing line with assertIsNone

        self.assertIsNotNone(-1)
        self.assertIsNone(0)

the terminal shows AssertionError

AssertionError: 0 is not None

I make the statement True with assertIsNotNone

        self.assertIsNotNone(0)

the test passes

I add another assertion

        self.assertIsNotNone(0)
        self.assertIsNone(1)

the terminal shows AssertionError

AssertionError: 1 is not None

I change the line to make it True

        self.assertIsNotNone(1)

the test passes

I add a new failing line with assertNotIsInstance
```
19        self.assertIsNotNone(1)
20        self.assertNotIsInstance(-1, int)
```
int is the class for integers, the terminal shows AssertionError
```
AssertionError: -1 is an instance of <class 'int'>
```
I use -1 for all the integers (whole numbers) that are smaller than 0
I make the line True with assertIsInstance
```
20        self.assertIsInstance(-1, int)
```
the test passes

I add another failing line with assertNotIsInstance

        self.assertIsInstance(-1, int)
        self.assertNotIsInstance(0, int)

the terminal shows AssertionError

AssertionError: 0 is an instance of <class 'int'>

0 is an integer

I change the statement to make it True
```
21        self.assertIsInstance(0, int)
```
the test passes

I add another failing line with assertNotIsInstance

        self.assertIsInstance(0, int)
        self.assertNotIsInstance(1, int)

the terminal shows AssertionError

AssertionError: 1 is an instance of <class 'int'>

I use 1 for all the integers (whole numbers) that are bigger than 0

I make the failing line True with assertIsInstance
```
22        self.assertIsInstance(1, int)
```
the test passes

I add one more failing line with to test if None is an integer with assertIsInstance

        self.assertIsInstance(1, int)
        self.assertIsInstance(None, int)

the terminal shows AssertionError

AssertionError: None is not an instance of <class 'int'>

I make the line True with assertNotIsInstance

    def test_is_none_an_integer(self):
        self.assertIsNotNone(-1)
        self.assertIsNotNone(0)
        self.assertIsNotNone(1)
        self.assertIsInstance(-1, int)
        self.assertIsInstance(0, int)
        self.assertIsInstance(1, int)
        self.assertNotIsInstance(None, int)


# NOTES

the test passes

I add a new note

# NOTES
# None is NOT an integer
# None is NOT a boolean
# None is None

test_is_none_a_float

RED: make it fail

I add a test to see if None is a float (floating point decimal number)

        self.assertNotIsInstance(None, int)

    def test_is_none_a_float(self):
        self.assertIsNone(-0.1)

# NOTES

the terminal shows AssertionError

AssertionError: -0.1 is not None

GREEN: make it pass

I make the statement True with assertIsNotNone

        self.assertIsNotNone(-0.1)

the test passes

REFACTOR: make it better

I add another failing line with assertIsNone

        self.assertIsNotNone(-0.1)
        self.assertIsNone(0.0)

the terminal shows AssertionError

AssertionError: 0.0 is not None

I make the statement True with assertIsNotNone

        self.assertIsNotNone(0.0)

the test passes

I add a failing line with assertIsNone

        self.assertIsNotNone(0.0)
        self.assertIsNone(0.1)

the terminal shows AssertionError

AssertionError: 0.1 is not None

I make the statement True with assertIsNotNone

        self.assertIsNotNone(0.1)

the test passes

time for instance tests. I add a failing line with assertNotIsInstance
```
28        self.assertIsNotNone(0.1)
29        self.assertNotIsInstance(-0.1, float)
```
float is the class for floating point numbers. The terminal shows AssertionError
```
AssertionError: -0.1 is an instance of <class 'float'>
```
I use -0.1 for all the floating point numbers that are smaller than 0.0
I make the statement True with assertIsInstance
```
29        self.assertIsInstance(-0.1, float)
```
the test passes

I add the next instance test with assertNotIsInstance

        self.assertIsInstance(-0.1, float)
        self.assertNotIsInstance(0.0, float)

the terminal shows AssertionError

AssertionError: 0.0 is an instance of <class 'float'>

0.0 is a floating point number

I make the statement True with assertIsInstance
```
30        self.assertIsInstance(0.0, float)
```
the test passes

I add a failing line with assertNotIsInstance

        self.assertIsInstance(0.0, float)
        self.assertNotIsInstance(0.1, float)

the terminal shows AssertionError

AssertionError: 0.1 is an instance of <class 'float'>

I use 0.1 for all the floating point numbers that are bigger than 0.0

I make the statement True with assertIsInstance
```
31        self.assertIsInstance(0.1, float)
```
the test passes

I add one more failing line with the assertIsInstance method

        self.assertIsInstance(0.1, float)
        self.assertIsInstance(None, float)

the terminal shows AssertionError

AssertionError: None is not an instance of <class 'float'>

I make the statement True with the assertNotIsInstance method

    def test_is_none_a_float(self):
        self.assertIsNotNone(-0.1)
        self.assertIsNotNone(0.0)
        self.assertIsNotNone(0.1)
        self.assertIsInstance(-0.1, float)
        self.assertIsInstance(0.0, float)
        self.assertIsInstance(0.1, float)
        self.assertNotIsInstance(None, float)


# NOTES

the test passes

I add a new note

# NOTES
# None is NOT a float
# None is NOT an integer
# None is NOT a boolean
# None is None

test_is_none_a_string

RED: make it fail

I add a test to see if None is a string (anything inside quotes)

        self.assertNotIsInstance(None, float)

    def test_is_none_a_string(self):
        self.assertIsNone('')

# NOTES

the terminal shows AssertionError

AssertionError: '' is not None

the empty string ('') is NOT None

GREEN: make it pass

I make the statement True with assertIsNotNone

        self.assertIsNotNone('')

the test passes

REFACTOR: make it better

I add another failing line with assertIsNone

        self.assertIsNotNone('')
        self.assertIsNone("text")

the terminal shows AssertionError

AssertionError: 'text' is not None

I change the assert method to make the statement True

        self.assertIsNotNone("text")

the test passes

I add a failing line with assertNotIsInstance

        self.assertIsNotNone("text")
        self.assertNotIsInstance('', str)

str is the class for strings. The terminal shows AssertionError

AssertionError: '' is an instance of <class 'str'>

because anything in quotes is a string

I change the assert method

        self.assertIsInstance('', str)

the test passes

I add another assertion

        self.assertIsInstance('', str)
        self.assertNotIsInstance("text", str)

the terminal shows AssertionError

AssertionError: 'text' is an instance of <class 'str'>

because anything in quotes is a string

I change the assert method
```
38        self.assertIsInstance("text", str)
```
A string is anything in single, double or triple quotes, for example
- 'single quotes'
- '''triple single quotes'''
- "double quotes"
- """triple double quotes"""
see quotes for more

I add another failing line with assertIsInstance

        self.assertIsInstance("text", str)
        self.assertIsInstance(None, str)

the terminal shows AssertionError

AssertionError: None is not an instance of <class 'str'>

I change the assert method

    def test_is_none_a_string(self):
        self.assertIsNotNone('')
        self.assertIsNotNone("text")
        self.assertIsInstance('', str)
        self.assertIsInstance("text", str)
        self.assertNotIsInstance(None, str)


# NOTES

the test passes

I add a note

# NOTES
# None is NOT a string
# None is NOT a float
# None is NOT an integer
# None is NOT a boolean
# None is None

test_is_none_a_tuple

RED: make it fail

I add a test to see if None is a tuple (anything in parentheses (())), pronounced two-pull

        self.assertNotIsInstance(None, str)

    def test_is_none_a_tuple(self):
        self.assertIsNone(())

# NOTES

the terminal shows AssertionError

AssertionError: () is not None

GREEN: make it pass

I make the statement True

        self.assertIsNotNone(())

the test passes

REFACTOR: make it better

I add a failing assertion

        self.assertIsNotNone(())
        self.assertIsNone((1, 2, 3, 'n'))

the terminal shows AssertionError

AssertionError: (1, 2, 3, 'n') is not None

I make the statement True

        self.assertIsNotNone((1, 2, 3, 'n'))

the test passes

I add a failing line with assertNotIsInstance

        self.assertIsNotNone((1, 2, 3, 'n'))
        self.assertNotIsInstance((), tuple)

the terminal shows AssertionError

AssertionError: () is an instance of <class 'tuple'>

because anything in parentheses (()) in Python is a tuple

I make the statement True

        self.assertIsInstance((), tuple)

the test passes

I add another failing line

        self.assertIsInstance((), tuple)
        self.assertNotIsInstance((1, 2, 3, 'n'), tuple)

the terminal shows AssertionError

AssertionError: (1, 2, 3, 'n') is an instance of <class 'tuple'>

because anything in parentheses (()) in Python is a tuple

I change the assert method to make the statement True

        self.assertIsInstance((1, 2, 3, 'n'), tuple)

the test passes

I add one more instance test

        self.assertIsInstance((1, 2, 3, 'n'), tuple)
        self.assertIsInstance(None, tuple)

the terminal shows AssertionError

AssertionError: None is not an instance of <class 'tuple'>

I change the statement to make it True

    def test_is_none_a_tuple(self):
        self.assertIsNotNone(())
        self.assertIsNotNone((1, 2, 3, 'n'))
        self.assertIsInstance((), tuple)
        self.assertIsInstance((1, 2, 3, 'n'), tuple)
        self.assertNotIsInstance(None, tuple)


# NOTES

the test passes

I add a note

# NOTES
# None is NOT a tuple
# None is NOT a string
# None is NOT a float
# None is NOT an integer
# None is NOT a boolean
# None is None

it looks like None is None and not anything else

test_is_none_a_list

RED: make it fail

I add a new test to see if None is a list (anything in square brackets ([]))

        self.assertNotIsInstance(None, tuple)

    def test_is_none_a_list(self):
        self.assertIsNone([])

# NOTES

the terminal shows AssertionError

AssertionError: [] is not None

GREEN: make it pass

I change the assertion to make the statement True

        self.assertIsNotNone([])

the test passes

REFACTOR: make it better

I add another failing line

        self.assertIsNotNone([])
        self.assertIsNone([1, 2, 3, 'n'])

the terminal shows AssertionError

AssertionError: [1, 2, 3, 'n'] is not None

I make the statement True

        self.assertIsNotNone([1, 2, 3, 'n'])

the test passes

I add a failing instance test

        self.assertIsNotNone([1, 2, 3, 'n'])
        self.assertNotIsInstance([], list)

the terminal shows AssertionError

AssertionError: [] is an instance of <class 'list'>

because anything in square brackets ([]) in Python is a list

I make the statement True

        self.assertIsInstance([], list)

the test passes

I add another failing line with assertNotIsInstance

        self.assertIsInstance([], list)
        self.assertNotIsInstance([1, 2, 3, 'n'], list)

the terminal shows AssertionError

AssertionError: [1, 2, 3, 'n'] is an instance of <class 'list'>

because anything in square brackets ([]) in Python is a list

I change the assert method

    self.assertIsInstance([1, 2, 3, 'n'], list)

the test passes

I add one more failing line with the assertIsInstance method

    self.assertIsInstance([1, 2, 3, 'n'], list)
    self.assertIsInstance(None, list)

the terminal shows AssertionError

AssertionError: None is not an instance of <class 'list'>

I make the statement True

    def test_is_none_a_list(self):
        self.assertIsNotNone([])
        self.assertIsNotNone([1, 2, 3, 'n'])
        self.assertIsInstance([], list)
        self.assertIsInstance([1, 2, 3, 'n'], list)
        self.assertNotIsInstance(None, list)


# NOTES

the test passes

I add a new note

# NOTES
# None is NOT a list
# None is NOT a tuple
# None is NOT a string
# None is NOT a float
# None is NOT an integer
# None is NOT a boolean
# None is None

test_is_none_a_set

RED: make it fail

I want to see if None is a set

        self.assertNotIsInstance(None, list)

    def test_is_none_a_set(self):
        self.assertIsNone(set())

the terminal shows AssertionError

AssertionError: set() is not None

GREEN: make it pass

I make the statement True

            self.assertIsNotNone(set())

the test passes

REFACTOR: make it better

I add another assertion

        self.assertIsNotNone(set())
        self.assertIsNone({1, 2, 3, 'n'})

the terminal shows AssertionError

AssertionError: {1, 2, 3, 'n'} is not None

I make the statement True

        self.assertIsNotNone({1, 2, 3, 'n'})

the test passes

I add an instance test

        self.assertIsNotNone({1, 2, 3, 'n'})
        self.assertNotIsInstance({1, 2, 3, 'n'}, set)

the terminal shows AssertionError

AssertionError: {1, 2, 3, 'n'} is an instance of <class 'set'>

I make the statement True

        self.assertIsInstance({1, 2, 3, 'n'}, set)

the test passes

I add another instance test

        self.assertIsInstance({1, 2, 3, 'n'}, set)
        self.assertIsInstance(None, set)

the terminal shows AssertionError

AssertionError: None is not an instance of <class 'set'>

I make the statement True

    def test_is_none_a_set(self):
        self.assertIsNotNone(set())
        self.assertIsNotNone({1, 2, 3, 'n'})
        self.assertIsInstance({1, 2, 3, 'n'}, set)
        self.assertNotIsInstance(None, set)


# NOTES

the test passes

I add a note

# NOTES
# None is NOT a set
# None is NOT a list
# None is NOT a tuple
# None is NOT a string
# None is NOT a float
# None is NOT an integer
# None is NOT a boolean
# None is None

test_is_none_a_dictionary

RED: make it fail

One last test to see if None is a dictionary

        self.assertNotIsInstance(None, set)

    def test_is_none_a_dictionary(self):
        self.assertIsNone(dict())

# NOTES

the terminal shows AssertionError

AssertionError: {} is not None

wait a minute! Python uses {} for sets. it also uses them for dictionaries with a difference.

GREEN: make it pass

I make the statement True

        self.assertIsNotNone(dict())

the test passes

REFACTOR: make it better

I add another failing line

        self.assertIsNotNone(dict())
        self.assertIsNone({'key': 'value'})

the terminal shows AssertionError

AssertionError: {'key': 'value'} is not None

I make the statement True

        self.assertIsNotNone({'key': 'value'})

the test passes

I add a failing instance test

        self.assertIsNotNone({'key': 'value'})
        self.assertNotIsInstance({}, dict)

dict is the class for dictionaries, the terminal shows AssertionError

AssertionError: {} is an instance of <class 'dict'>

{} is the empty dictionary

I change the assert method

        self.assertIsInstance({}, dict)

the test passes

I add another instance test
```
64        self.assertIsInstance({}, dict)
65        self.assertNotIsInstance({'key': 'value'}, dict)
```
the terminal shows AssertionError
```
AssertionError: {'key': 'value'} is an instance of <class 'dict'>
```
{'key': 'value'} is a dictionary with : separating the key on the left from the value on the right, I can add more key-value pairs separating them with commas. sets do NOT have key-value pairs.

I make the statement True

        self.assertIsInstance({'key': 'value'}, dict)

the test passes

I add the last failing instance test with assertIsInstance

        self.assertIsInstance({'key': 'value'}, dict)
        self.assertIsInstance(None, dict)

the terminal shows AssertionError

AssertionError: None is not an instance of <class 'dict'>

I make the statement True with assertNotIsInstance

    def test_is_none_a_dictionary(self):
        self.assertIsNotNone(dict())
        self.assertIsNotNone({'key': 'value'})
        self.assertIsInstance({}, dict)
        self.assertIsInstance({'key': 'value'}, dict)
        self.assertNotIsInstance(None, dict)


# NOTES

the test passes

I add the last note

# NOTES
# None is NOT a dictionary
# None is NOt a set
# None is NOT a list
# None is NOT a tuple
# None is NOT a string
# None is NOT a float
# None is NOT an integer
# None is NOT a boolean
# None is None

close the project

I close the file(s) I have open in the editor(s)
I click in the terminal and exit the tests with ctrl+c on the keyboard
I deactivate the virtual environment
```
deactivate
```
the terminal goes back to the command line, (.venv) is no longer on the left side
```
.../pumping_python/none
```
I change directory to the parent of none
```
cd ..
```
the terminal shows
```
.../pumping_python
```
I am back in the pumping_python directory

review

I used assert methods to test what None is and what it is NOT. I used 2 that were say_hellod in AssertionError

assertIsNone - which tests if the thing in parentheses is None
assertIsNotNone - which tests if the thing in parentheses is not None

and 2 new assert methods

assertIsInstance which checks if something is an instance of a given class
assertNotIsInstance which checks if something is NOT an instance of a given class

I also showed the basic Python data structures

None - the simplest
integers - whole numbers, negative and positive
floats - floating point decimal numbers
strings - anything inside quotes
booleans - True and False
tuples - anything in parentheses (()) separated by commas
lists - anything in square brackets ([]) separated by commas
sets - anything in curly braces ({}) separated by commas but NOT key-value pairs
dictionaries - key-value pairs in curly braces ({})

How many questions can you answer after going through this chapter?

code from the chapter

Do you want to see all the CODE I typed in this chapter?

what is next?

so far you have covered

Would you like to test what is True and False in Python?

please leave a review

data structures

how tos