---

---

---

truth table: Nullary and Unary Operations

---

preview

These are the tests I have at the end of the chapters

import src.truth_table
import unittest


class TestNullaryOperations(unittest.TestCase):

    def test_logical_true(self):
        self.assertTrue(src.truth_table.logical_true())

    def test_logical_false(self):
        self.assertFalse(src.truth_table.logical_false())


class TestUnaryOperations(unittest.TestCase):

    def test_logical_identity(self):
        self.assertTrue(src.truth_table.logical_identity(True))
        self.assertFalse(src.truth_table.logical_identity(False))

    def test_logical_negation_aka_not(self):
        self.assertFalse(src.truth_table.logical_negation(True))
        self.assertTrue(src.truth_table.logical_negation(False))


# Exceptions seen
# AssertionError
# AttributeError
# TypeError

---

questions about Nullary and Unary Operations

Questions to think about as I go through the chapter

• what are the Nullary Operations?

• How many inputs do Nullary Operations take?

• what are the Unary Operations?

• How many inputs do Unary Operations take?

• what is a function that returns its input as output?

• what is a function that returns the negation of its input?

• how can I return the opposite of a boolean?

---

requirements

truth table

---

Nullary Operations

There are 2 Nullary operations - Logical True and Logical False. They do not take input and always return True or False

---

test_logical_true

---

RED: make it fail

---

• I open the Explorer to change the name of test_truth_table.py

• I right click on test_truth_table.py select Rename then change it to test_nullary_unary.py

• I change the names of the class and method in test_nullary_unary.py

  import src.truth_table
  import unittest
  
  
  class TestNullaryOperations(unittest.TestCase):
  
      def test_logical_true(self):
          self.assertTrue(src.truth_table.logical_true())
  
  
  # Exceptions seen
  

  the terminal is my friend, and shows AttributeError

  AttributeError: module 'src.truth_table' has no attribute 'logical_true'
  

  because I have not added a definition for logical_true to truth_table.py in the src folder

---

GREEN: make it pass

---

• I add AttributeError to the list of Exceptions seen in test_nullary_unary.py

  # Exceptions seen
  # AssertionError
  # AttributeError
  

• I use the Explorer to open truth_table.py from the src folder in the editor of my Integrated Development Environment (IDE)

• I add a function to truth_table.py

  def logical_true():
      return None
  

  the terminal is my friend, and shows AssertionError

  AssertionError: None is not true
  

  because the function returns None and the test expects True

• I change None to True in the return statement

  def logical_true():
      return True
  

  the test passes

logical_true does not take any input and always returns True

---

test_logical_false

---

RED: make it fail

---

I add another test to test_nullary_unary.py

class TestNullaryOperations(unittest.TestCase):

    def test_logical_true(self):
        self.assertTrue(src.truth_table.logical_true())

    def test_logical_false(self):
        self.assertFalse(src.truth_table.logical_false())


# Exceptions seen

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.truth_table' has no attribute 'logical_false'. Did you mean: 'logical_true'?

because I have not added a definition for logical_false to truth_table.py, I only added one for logical_true

---

GREEN: make it pass

---

• I add a function to truth_table.py

  def logical_true():
      return True
  
  
  def logical_false():
      return True
  

  the terminal is my friend, and shows AssertionError

  AssertionError: True is not false
  

  because the function returns True and the test expects False

• I change True to False in the return statement

  def logical_false():
      return False
  

  the test passes

Note

• logical_true always returns True

• logical_false always returns False

• both Nullary Operations do not take input

return	operation
True	logical_true
False	logical_false

---

Unary Operations

There are 2 unary operations: Logical Identity and Logical Negation, they each take one input and return True or False

---

test_logical_identity

---

RED: make it fail

---

I add a new TestCase for Unary Operations with a test for logical_identity when it gets True as input

input	output
True	True

class TestNullaryOperations(unittest.TestCase):

    def test_logical_true(self):
        self.assertTrue(src.truth_table.logical_true())

    def test_logical_false(self):
        self.assertFalse(src.truth_table.logical_false())


class TestUnaryOperations(unittest.TestCase):

    def test_logical_identity(self):
        reality = src.truth_table.logical_identity(True)
        self.assertTrue(reality)


# Exceptions seen

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.truth_table' has no attribute 'logical_identity'

because I need to add a definition for logical_identity to truth_table.py

---

GREEN: make it pass

---

• I add the function to truth_table.py

  def logical_false():
      return False
  
  
  def logical_identity():
      return False
  

  the terminal is my friend, and shows TypeError

  TypeError: logical_identity() takes 0 positional arguments but 1 was given
  

  because the test called the logical_identity function with 1 argument and this definition only takes calls with 0 arguments

• I add TypeError to the list of Exceptions seen in test_nullary_unary.py

  # Exceptions seen
  # AssertionError
  # AttributeError
  # TypeError
  

• I add a name in parentheses for logical_identity to take calls with 1 input, in truth_table.py

  def logical_identity(the_input):
      return False
  

  the terminal is my friend, and shows AssertionError

  AssertionError: False is not true
  

  because the function returns False and the test expects True

• I change the return statement to give the test what it wants

  def logical_identity(the_input):
      return True
  

  the test passes

---

REFACTOR: make it better

---

• I add another assertion to test_logical_identity in test_nullary_unary.py for the case when it gets False as input

  input	output
  False	False

      def test_logical_identity(self):
          reality = src.truth_table.logical_identity(True)
          self.assertTrue(reality)
          reality = src.truth_table.logical_identity(False)
          self.assertFalse(reality)
  
  
  # Exceptions seen
  

  the terminal is my friend, and shows AssertionError

  AssertionError: True is not false
  

  because the function returns True and the test expects False

• I change the return statement of logical_identity in truth_table.py

  def logical_identity(the_input):
      return False
  

  the terminal is my friend, and shows AssertionError

  AssertionError: False is not true
  

  because the assertion that was passing before, expects True and the function now returns False

• I change the return statement of the function

  def logical_identity(the_input):
      return the_input
  

  the test passes.

  Tip

  the_input is a name, I can use any name.

  This is what happens when the logical_identity function is called

  • it returns True if the input is True

  • it returns False, if the input is False

  • it returns the input as output

  input	output
  True	True
  False	False

---

test_logical_negation

---

RED: make it fail

---

I add a test for logical_negation with an assertion for when it gets True as input, to test_nullary_unary.py

input	output
True	False

    def test_logical_identity(self):
        reality = src.truth_table.logical_identity(True)
        self.assertTrue(reality)
        reality = src.truth_table.logical_identity(False)
        self.assertFalse(reality)

    def test_logical_negation(self):
        reality = src.truth_table.logical_negation(True)
        self.assertFalse(reality)


# Exceptions seen

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.truth_table' has no attribute 'logical_negation'

there is no definition for logical_negation in truth_table.py

---

GREEN: make it pass

---

• I add the function to truth_table.py

  def logical_identity(the_input):
      return the_input
  
  
  def logical_negation(the_input):
      return the_input
  

  the terminal is my friend, and shows AssertionError

  AssertionError: True is not false
  

  because the function returned True and the test expects False

• I change the return statement to give the test what it wants

  def logical_negation(the_input):
      return False
  

  the test passes

---

REFACTOR: make it better

---

• I add another assertion to test_logical_negation for when logical_negation gets False as input, in test_nullary_unary.py

  input	output
  False	True

      def test_logical_negation(self):
          reality = src.truth_table.logical_negation(True)
          self.assertFalse(reality)
          reality = src.truth_table.logical_negation(False)
          self.assertTrue(reality)
  
  
  # Exceptions seen
  

  the terminal is my friend, and shows AssertionError

  AssertionError: False is not true
  

  because the function returns False and the new assertion expects True

• I change the return statement of the logical_negation function in truth_table.py

  def logical_negation(the_input):
      return True
  

  the terminal is my friend, and shows AssertionError

  AssertionError: True is not false
  

  the test fails for the assertion that passed before, because the function now returns True and that assertion expects False

• I make the function return its input again

  def logical_negation(the_input):
      return the_input
  

  the terminal is my friend, and shows AssertionError

  AssertionError: True is not false
  

  this means the expectation of the test is that the logical_negation function

  • returns True if the input is False

  • returns False if the input is True

  • returns the opposite of the input it gets

---

how to return the opposite of a boolean

---

• I can use the “not” keyword to return the opposite of the boolean after it. I add it to the return statement

  def logical_negation(the_input):
      return not the_input
  

  the test passes. This is what happens when the logical_identity function is called

  • it returns False, if the input is True

  • it returns True if the input is False

  • it returns the opposite of the input, as output

• I add to the name of the test

      def test_logical_identity(self):
          reality = src.truth_table.logical_identity(True)
          self.assertTrue(reality)
          reality = src.truth_table.logical_identity(False)
          self.assertFalse(reality)
  
      def test_logical_negation_aka_not(self):
          reality = src.truth_table.logical_negation(True)
          self.assertFalse(reality)
          reality = src.truth_table.logical_negation(False)
          self.assertTrue(reality)
  
  
  # Exceptions seen
  

logical_negation also known as not returns the opposite of its input

input	output
True	False
False	True

---

REFACTOR: make it better

---

• I can call the logical_negation function directly in the test, I do not need the reality variables because they are only used once for each assertion

      def test_logical_negation_aka_not(self):
          reality = src.truth_table.logical_negation(True)
          # self.assertFalse(reality)
          self.assertFalse(src.truth_table.logical_negation(True))
          reality = src.truth_table.logical_negation(False)
          # self.assertTrue(reality)
          self.assertTrue(src.truth_table.logical_negation(False))
  
  
  # Exceptions seen
  

  the test is still green

• I remove the commented lines and unused variables

      def test_logical_negation_aka_not(self):
          self.assertFalse(src.truth_table.logical_negation(True))
          self.assertTrue(src.truth_table.logical_negation(False))
  
  
  # Exceptions seen
  

• I call the logical_identity function directly, in its test

      def test_logical_identity(self):
          reality = src.truth_table.logical_identity(True)
          # self.assertTrue(reality)
          self.assertTrue(src.truth_table.logical_identity(True))
          reality = src.truth_table.logical_identity(False)
          # self.assertFalse(reality)
          self.assertFalse(src.truth_table.logical_identity(False))
  
      def test_logical_negation_aka_not(self):
  

  still green

• I remove the commented lines and unused variables from test_logical_identity

      def test_logical_identity(self):
          self.assertTrue(src.truth_table.logical_identity(True))
          self.assertFalse(src.truth_table.logical_identity(False))
  
      def test_logical_negation_aka_not(self):
  

---

close the project

• I close test_nullary_unary.py and truth_table.py in the editor

• I click in the terminal, then use q on the keyboard to leave the tests. The terminal goes back to the command line

• I change directory to the parent of truth_table

  cd ..
  

  the terminal shows

  .../pumping_python
  

  I am back in the pumping_python directory

---

review

I ran these tests for Nullary Operations which take no input

• test_logical_true

• test_logical_false

and for Unary operations which take 1 input

• test_logical_identity

• test_logical_negation

the truth table for Unary Operations is

return	True	False	operation
the_input	True	False	logical_identity
not the_input	False	True	logical_negation (NOT)

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 for the Truth Table?

---

what is next?

Would you like to test binary operations? they take 2 inputs

---

rate pumping python

If this has been a 7 star experience for you, please CLICK HERE to leave a 5 star review of pumping python. It helps other people get into the book too

---

CLICK HERE to leave a 5 star review of pumping python, if this has been a 7 star experience for you