Gain insights into Python by exploring basic to advanced concepts, including loops, classes, and GUIs with Tkinter. Delve into testing and become a productive Python programmer.

complete.tar.gz

InputN-copy

Error-copy

In this course, you will get a comprehensive overview of Python. You will start by laying the foundation and learning the introductory topics like operators, conditional statements, functions, loops, assignment statements, and more. You will then move onto more advanced topics such as classes and inheritance, iterators, list comprehensions, and dictionaries. Along with this, you will also get to explore the concept of testing and take a look at how GUI applications can be designed using Tkinter, Python's standard GUI library. 

By the time you're done, you'll be able to hit the ground running and be equipped with the tools that will allow you to be productive in Python.

Python 3: From Beginner to Advanced

# Introduction and structure of unit testing

A **unit test** tests the methods in a single class. A **test case** tests the response of a single method to a particular set of inputs. 

To do unit testing, you have to do the following:

* `import unittest`
* `import fileToBeTested`   or
  `from fileToBeTested import *`
    > **Reminder**: If you use `from file import *` you don't have to precede every function call with the name of the file it was imported from.
* Write a `class SomeName(unittest.TestCase)`. Within the class:
    * Define methods `setUp(self)` and `tearDown(self)`, if desired. These are both optional.
    * Provide one or more `testSomething(self)` methods. You may include other methods, but the names of test methods must begin with `test`.
* At the end of the test file, put `unittest.main()`.

# Role each component of unit testing play

Here's what the `unittest.main()` does. For each and every method whose name begins with `test`, the `unittest.main` method calls `setUp()` if you have provided one. Then, it  calls the test method and the `tearDown()` method if you have provided one. So, every test is sandwiched between `setUp` and `tearDown`.

The purpose of the `setUp` method is to make sure everything is in a known, pristine state before calling the test method. This way, you can make sure that the results of running one test do not affect the results of a later test.

The purpose of `tearDown` is to remove artifacts (such as files) that may have been created. It is used much less frequently than `setUp`.

Each test method should typically test only one function, though it may call that function many times. You can write multiple tests for the same function.

Here is a trivial example of a test method:
```python
def test_add(self):
    self.assertEqual(4, add(2, 2))
    self.assertEqual(0, add(2, -2))
```

# Assertions

If any assertion in a test method fails, the test fails and the remaining assertions in that method are not tested. Therefore, test methods should not become too long.

If the method to be tested is in a class `C` and you used `import C` rather than `from C import *`, you need to also use the class name, for example, `self.assertEqual(4, C.add(2, 2))`. The convention is to put the expected result (**4**) first and the function call (`add`) last.

Here are the most commonly used assertion methods:
* `self.assertEqual(expected, actual)`
* `self.assertAlmostEqual(expected, actual)` for floating point numbers
* `self.assertTrue(boolean)` and `assertFalse(boolean)`.

More assertion methods are given in an appendix.

# The `assertRaises` function

You can test whether a function raises an exception when it is supposed to, but this method has a special form. This is necessary because arguments to a function are evaluated before the function is called. For example, if you said the following:
```python
self.assertRaises(ZeroDivisionError, 5/0)
```
The argument `5/0` would be evaluated and would raise the exception _**before**_ `assertRaises` can be called.

The solution is to pass the function name in separate from its arguments:
```python
self.assertRaises(exception, function_name, arguments)
```

This allows the `assertRaises` function to call the function to be tested within a `try-except` block and handle it appropriately.

# Common practices

When testing is **not being done**, a common idiom is to put a call to the main function as the last line in the code file, for example, `main()`. This causes the `main` method to run immediately after the file is loaded. When doing unit testing, this is undesirable. Instead, replace that line with the following:
```python
if __name__ == '__main__':
    main()
```
And put the following code at the end of the test file:
```python
unittest.main()
```

This way, the **program will be run** if loaded from the program file, and the **tests will be run** if loaded from the test file.

# Unit test example

If provided with an `int` or a `string`, the following section of code returns a list of digits from it:

You’ll learn about the concept of unit testing in Python in this lesson.

Introduction

The Absolute Bare Minimum

Better Tools

Classes

Getting Fancy

Testing

Graphical User Interfaces

Modules

Appendix

I Guess We're Doing Python Now Exam

Unit Testing

Introduction and structure of unit testing

Role each component of unit testing play