In real life, almost everyone expresses their thoughts using phrases like **"Yes or No"**, **"Definitely Not"**, **"Yes, yes and yes!"**. Python language permits you to do almost the same, but it uses more formal phrases based on the statements `and`, `or`, and `not`.

`X` and `Y` can be any logical statement (`True` or `False`): 

|**Statement**|**Syntax**|**Purpose**|
|---|---|---|
|`and`|`X and Y`|Returns `True` only if `X` and `Y` are both `True`|
|`or`|`X or Y`|Returns `True` in all cases, except if `X` and `Y` are both `False`|
|`not`|`not X`|If `X` is `True`, it changes it to `False`, and vice versa|

Let's look at the table below to understand the logic of each operator: 

|**X**|**Y**|**X or Y**|**X and Y**|**not X**|
|---|---|---|---|---|
|`True`|`True`|`True`|`True`|`False`|
|`True`|`False`|`True`|`False`|`False`|
|`False`|`True`|`True`|`False`|`True`|
|`False`|`False`|`False`|`False`|`True`|

import unittest
import sys
from io import StringIO

class TestUserCode(unittest.TestCase):
    def test_statement1_correct(self):
        self._testMethodName = 'statement1 equals True'
        import user_code
        self.assertTrue(hasattr(user_code, 'statement1'), "Expected statement1 to be defined.")
        self.assertEqual(user_code.statement1, True, f"Expected statement1 to equal True, but got {user_code.statement1}.")

    def test_statement2_correct(self):
        self._testMethodName = 'statement2 equals False'
        import user_code
        self.assertTrue(hasattr(user_code, 'statement2'), "Expected statement2 to be defined.")
        self.assertEqual(user_code.statement2, False, f"Expected statement2 to equal False, but got {user_code.statement2}.")


if __name__ == '__main__':
    unittest.main()

test_main.py

This course is going to help you dive deeper into data types and try to work with them. Here you will learn basic operations and all ins and outs of numbers, boolean data type, and strings. This course consists of a lot of practical tasks after which you will become a skillful programmer.

Numeric data types are crucial in Python, so it is important to start with them. Here you will work with simple math operations and find out the purposes of learning different types of numerical data.

The main goal of this section is to clarify the boolean data types; it's a sub type of numeric data, but indeed it is more challenging. Since it is always better to excel in the more difficult topics, this section is a valuable part of your curriculum.

Strings are a way for us to implement your phrases in Python, that is, to give instructions to users who are the target audience of your program. Indeed, it is always better to be able to work with strings because they should be used in your code. You'll understand why soon.

This chapter consists of practical tasks that combine all the examined topics together with a bit of theory.

Statement	Syntax	Purpose
`and`	`X and Y`	Returns `True` only if `X` and `Y` are both `True`
`or`	`X or Y`	Returns `True` in all cases, except if `X` and `Y` are both `False`
`not`	`not X`	If `X` is `True`, it changes it to `False`, and vice versa

X	Y	X or Y	X and Y	not X
`True`	`True`	`True`	`True`	`False`
`True`	`False`	`True`	`False`	`False`
`False`	`True`	`True`	`False`	`True`
`False`	`False`	`False`	`False`	`True`

Statement	Syntax	Purpose
`and`	`X and Y`	Returns `True` only if `X` and `Y` are both `True`
`or`	`X or Y`	Returns `True` in all cases, except if `X` and `Y` are both `False`
`not`	`not X`	If `X` is `True`, it changes it to `False`, and vice versa

X	Y	X or Y	X and Y	not X
`True`	`True`	`True`	`True`	`False`
`True`	`False`	`True`	`False`	`False`
`False`	`True`	`True`	`False`	`True`
`False`	`False`	`False`	`False`	`True`

Data Types in Python

And, Or, Not Operators

Lösung

And, Or, Not Operators

Lösung