22118 - User contributions [en]

Beginning unit test

2026-04-14T16:37:28Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

=== Installation of pytest ===
If you are using an anaconda python installation pytest is included. You can test in your python has pytest.
# On command line both should work or none
python3 -c "import pytest"
which pytest
# It is pretty clear if you fail. Success can be more obscure.
# Here is a fail test, so you can compare
python3 -c "import yptest"
which yptest
To install pytest, you need to be root/administrator.
# An install on a basic system
pip install -U pytest
# or maybe (depending on your system)
sudo pip install -U pytest
# Using ubuntu, which is also WSL in this situation, there is a package
apt install python3-pytest

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive for how the search path works. Try to run the test from a different folder (unittest), like "pytest test/normalize_test.py" to see how vulnerable just using the path is. 
# You hopefully remember the '''MyMath''' class you made in exercise 1 & 2 in [[Beginning classes]]. Make a folder ''classes'' in your ''unittest/src'' folder and put the ''MyMath'' class in a file ''MyMath.py'' in ''unittest/src/classes''. Now make a unit test file ''MyMath_factorial_test.py'' in ''unittest/test'' that - surprise - tests your factorial method. Test it with at least these input: 12, 2, 1, 0, -1, 3.0, 3.4, "3", "3.1.", "ABC". Parametrize at least the tests that should succeed. Bonus for parametrizing the exceptions. 
# ''MyMath'' class also contains the ''supply'' method. Make unit tests for that method in the file ''unittest/test/MyMath_supply_test.py''. Make the "usual" tests, which are the same as you did in the first exercise. 
# Now make unit tests for the ''average'' method in '''MyMath'''. Make the tests in the file ''unittest/test/MyMath_average_test.py''. Notice how that interacts with the ''supply'' unit tests because ''average'' depends on correct working of ''supply''. Sometimes you won't even find the flaw in one method before you test another that depends on it. I am not going to tell you this time what unit tests you should make. You should know by now.

== Exercises for extra practice ==

Beginning unit test

2026-04-14T16:36:12Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

=== Installation of pytest ===
If you are using an anaconda python installation pytest is included. You can test in your python has pytest.
# On command line both should work or none
python3 -c "import pytest"
which pytest
# It is pretty clear if you fail. Success can be more obscure.
# Here is a fail test, so you can compare
python3 -c "import yptest"
which yptest
To install pytest, you need to be root/administrator.
# An install on a basic system
pip install -U pytest
# or maybe (depending on your system)
sudo pip install -U pytest
# Using ubuntu, which is also WSL in this situation, there is a package
apt install python3-pytest

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive for how the search path works. Try to run the test from a different folder, like "pytest test/normalize_test.py" to see how vulnerable just using the path is. 
# You hopefully remember the '''MyMath''' class you made in exercise 1 & 2 in [[Beginning classes]]. Make a folder ''classes'' in your ''unittest/src'' folder and put the ''MyMath'' class in a file ''MyMath.py'' in ''unittest/src/classes''. Now make a unit test file ''MyMath_factorial_test.py'' in ''unittest/test'' that - surprise - tests your factorial method. Test it with at least these input: 12, 2, 1, 0, -1, 3.0, 3.4, "3", "3.1.", "ABC". Parametrize at least the tests that should succeed. Bonus for parametrizing the exceptions. 
# ''MyMath'' class also contains the ''supply'' method. Make unit tests for that method in the file ''unittest/test/MyMath_supply_test.py''. Make the "usual" tests, which are the same as you did in the first exercise. 
# Now make unit tests for the ''average'' method in '''MyMath'''. Make the tests in the file ''unittest/test/MyMath_average_test.py''. Notice how that interacts with the ''supply'' unit tests because ''average'' depends on correct working of ''supply''. Sometimes you won't even find the flaw in one method before you test another that depends on it. I am not going to tell you this time what unit tests you should make. You should know by now.

== Exercises for extra practice ==

Beginning unit test

2026-04-14T14:54:42Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

=== Installation of pytest ===
If you are using an anaconda python installation pytest is included. You can test in your python has pytest.
# On command line both should work or none
python3 -c "import pytest"
which pytest
# It is pretty clear if you fail. Success can be more obscure.
# Here is a fail test, so you can compare
python3 -c "import yptest"
which yptest
To install pytest, you need to be root/administrator.
# An install on a basic system
pip install -U pytest
# or maybe (depending on your system)
sudo pip install -U pytest
# Using ubuntu, which is also WSL in this situation, there is a package
apt install python3-pytest

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive. 
# You hopefully remember the '''MyMath''' class you made in exercise 1 & 2 in [[Beginning classes]]. Make a folder ''classes'' in your ''unittest/src'' folder and put the ''MyMath'' class in a file ''MyMath.py'' in ''unittest/src/classes''. Now make a unit test file ''MyMath_factorial_test.py'' in ''unittest/test'' that - surprise - tests your factorial method. Test it with at least these input: 12, 2, 1, 0, -1, 3.0, 3.4, "3", "3.1.", "ABC". Parametrize at least the tests that should succeed. Bonus for parametrizing the exceptions. 
# ''MyMath'' class also contains the ''supply'' method. Make unit tests for that method in the file ''unittest/test/MyMath_supply_test.py''. Make the "usual" tests, which are the same as you did in the first exercise. 
# Now make unit tests for the ''average'' method in '''MyMath'''. Make the tests in the file ''unittest/test/MyMath_average_test.py''. Notice how that interacts with the ''supply'' unit tests because ''average'' depends on correct working of ''supply''. Sometimes you won't even find the flaw in one method before you test another that depends on it. I am not going to tell you this time what unit tests you should make. You should know by now.

== Exercises for extra practice ==

Beginning unit test

2026-04-14T14:52:37Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

=== Installation of pytest ===
If you are using an anaconda python installation pytest is included. You can test in your python has pytest.
# On command line both should work or none
python3 -c "import pytest"
which pytest
# It is pretty clear if you fail. Success can be more obscure.
# Here is a fail test, so you can compare
python3 -c "import yptest"
which yptest
To install pytest, you need to be root/administrator.
# An install on a basic system
pip install -U pytest
# or maybe (depending on your system)
sudo pip install -U pytest
# Using ubuntu, which is also WSL in this situation, there is a package
apt install python3-pytest

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive. 
# You hopefully remember the '''MyMath''' class you made in exercise 1 & 2 in [[Beginning classes]]. Make a folder ''classes'' in your ''unittest/src'' folder and put the ''MyMath'' class in a file ''MyMath.py'' in ''unittest/src/classes''. Now make a unit test file ''MyMath_factorial_test.py'' in ''unittest/test'' that - surprise - tests your factorial method. Test it with at least these input: 12, 2, 1, 0, -1, 3.0, 3.4, "3", "3.1.", "ABC". Parametrize at least the tests that should succeed. Bonus for parametrizing the exceptions. 
# ''MyMath'' class also contains the ''supply'' method. Make unit tests for that method in the file ''unittest/test/MyMath_supply_test.py''. Make the "usual" tests, which are the same as you did in the first exercise. 
# Now make unit tests for the ''average'' method in '''MyMath'''. Use the file ''unittest/test/MyMath_average_test.py''. Notice how that interacts with the ''supply'' unit tests because ''average'' depends on correct working of ''supply''. Sometimes you won't even find the flaw in one method before you test another that depends on it.

== Exercises for extra practice ==

Beginning unit test

2026-04-14T14:50:46Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

=== Installation of pytest ===
If you are using an anaconda python installation pytest is included. You can test in your python has pytest.
# On command line both should work or none
python3 -c "import pytest"
which pytest
# It is pretty clear if you fail. Success can be more obscure.
# Here is a fail test, so you can compare
python3 -c "import yptest"
which yptest
To install pytest, you need to be root/administrator.
# An install on a basic system
pip install -U pytest
# or maybe (depending on your system)
sudo pip install -U pytest
# Using ubuntu, which is also WSL in this situation, there is a package
apt install python3-pytest

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive. 
# You hopefully remember the '''MyMath''' class you made in exercise 1 & 2 in [[Beginning classes]]. Make a folder ''classes'' in your ''unittest/src'' folder and put the ''MyMath'' class in a file ''MyMath.py'' in ''unittest/src/classes''. Now make a unit test file ''MyMath_factorial_test.py'' in ''unittest/test'' that - surprise - tests your factorial method. Test it with at least these input: 12, 2, 1, 0, -1, 3.0, 3.4, "3", "3.1.", "ABC". Parametrize at least the tests that should succeed. Bonus for parametrizing the exceptions. 
# ''MyMath'' class also contains the ''supply'' method. Make unit tests for that method in the file ''unittest/test/MyMath_supply_test.py''. Make the "usual" tests, which are the same as you did in the first exercise. 
# Now make unit tests for the ''average'' method in ''MyMath''. Use the file ''unittest/test/MyMath_average_test.py''. Notice how that interacts with the ''supply'' unit tests because ''average'' depends on correct working of ''supply''. Sometimes you won't even find the flaw in one method before you test another dependency.

== Exercises for extra practice ==

Beginning unit test

2026-04-14T14:50:20Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

=== Installation of pytest ===
If you are using an anaconda python installation pytest is included. You can test in your python has pytest.
# On command line both should work or none
python3 -c "import pytest"
which pytest
# It is pretty clear if you fail. Success can be more obscure.
# Here is a fail test, so you can compare
python3 -c "import yptest"
which yptest
To install pytest, you need to be root/administrator.
# An install on a basic system
pip install -U pytest
# or maybe (depending on your system)
sudo pip install -U pytest
# Using ubuntu, which is also WSL in this situation, there is a package
apt install python3-pytest

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive. 
# You hopefully remember the '''MyMath''' class you made in exercise 1 & 2 in [[Beginning classes]]. Make a folder ''classes'' in your ''unittest/src'' folder and put the ''MyMath'' class in a file ''MyMath.py'' in ''unittest/src/classes''. Now make a unit test file ''MyMath_factorial_test.py'' in ''unittest/test'' that - surprise - tests your factorial method. Test it with at least these input: 12, 2, 1, 0, -1, 3.0, 3.4, "3", "3.1.", "ABC". Parametrize at least the tests that should succeed. Bonus for parametrizing the exceptions.
# ''MyMath'' class also contains the ''supply'' method. Make unit tests for that method in the file ''unittest/test/MyMath_supply_test.py''. Make the "usual" tests, which are the same as you did in the first exercise.
# Now make unit tests for the ''average'' method in ''MyMath''. Use the file ''unittest/test/MyMath_average_test.py''. Notice how that interacts with the ''supply'' unit tests because ''average'' depends on correct working of ''supply''. Sometimes you won't even find the flaw in one method before you test another dependency.

== Exercises for extra practice ==

Beginning unit test

2026-04-14T14:39:24Z

WikiSysop: /* Installation of pytest */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

=== Installation of pytest ===
If you are using an anaconda python installation pytest is included. You can test in your python has pytest.
# On command line both should work or none
python3 -c "import pytest"
which pytest
# It is pretty clear if you fail. Success can be more obscure.
# Here is a fail test, so you can compare
python3 -c "import yptest"
which yptest
To install pytest, you need to be root/administrator.
# An install on a basic system
pip install -U pytest
# or maybe (depending on your system)
sudo pip install -U pytest
# Using ubuntu, which is also WSL in this situation, there is a package
apt install python3-pytest

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive. 
# You hopefully remember the '''MyMath''' class you made in exercise 1 & 2 in [[Beginning classes]]. Make a folder ''classes'' in your ''unittest/src'' folder and put the ''MyMath'' class in a file ''MyMath.py'' in ''unittest/src/classes''. Now make a unit test file ''MyMath_factorial_test.py'' in ''unittest/test'' that - surprise - tests your factorial method. Test it with at least these input: 12, 2, 1, 0, -1, 3.0, 3.4, "3", "3.1.", "ABC". Parametrize at least the tests that should succeed. Bonus for parametrizing the exceptions.

== Exercises for extra practice ==

Intermediate unit test

2026-04-14T14:35:42Z

WikiSysop: /* Exercises for extra practice */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Beginning unit test]]
|Next: [[Runtime evaluation]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Unit test - start of reverse polish notation class]] 
Blog: [https://www.joelonsoftware.com/2000/04/30/top-five-wrong-reasons-you-dont-have-testers/ On testing], by the founder of StackExchange. 

== Subjects covered ==
Unit test using pytest framework. 
Files, test data 
Setting up real projects 

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated.
# Follow the file structure of having a ''code'' (or ''src'') folder for programs, a ''test'' folder for tests, and now a ''testdata'' folder for files containing test data. Now make unit tests and appropriate test data files for your '''fasta''' class from last week. In this exercise you just need to make unit test for the method '''load'''. You need to hand in both tests and test data. 
# Add unit tests for the method '''save''' in your '''fasta''' class. Hand in same way as above. 
# Add unit tests for the method '''delete''' in your '''fasta''' class. Hand in same way as above. 
I would not be surprised if you find errors in your '''fasta''' class based on these tests. I found flaws in my code.

== Exercises for extra practice ==
# Add unit tests for all methods in your '''fasta''' class. That will be a bit of work.

Beginning unit test

2026-04-14T14:35:31Z

WikiSysop: /* Exercises for extra practice */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

=== Installation of pytest ===
If you are using an anaconda python installation pytest is included. You can test in your python has pytest.
# On command line both should work or none
python3 -c "import pytest"
which pytest
# It is pretty clear if you fail. Success can be more obscure.
# Here is a fail test, so you can compare
python3 -c "import yptest"
which yptest
To install pytest, you need to be root/administrator.
pip install -U pytest
# or maybe (depending on your system)
sudo pip install -U pytest

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive. 
# You hopefully remember the '''MyMath''' class you made in exercise 1 & 2 in [[Beginning classes]]. Make a folder ''classes'' in your ''unittest/src'' folder and put the ''MyMath'' class in a file ''MyMath.py'' in ''unittest/src/classes''. Now make a unit test file ''MyMath_factorial_test.py'' in ''unittest/test'' that - surprise - tests your factorial method. Test it with at least these input: 12, 2, 1, 0, -1, 3.0, 3.4, "3", "3.1.", "ABC". Parametrize at least the tests that should succeed. Bonus for parametrizing the exceptions.

== Exercises for extra practice ==

Beginning unit test

2026-04-14T14:32:23Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

=== Installation of pytest ===
If you are using an anaconda python installation pytest is included. You can test in your python has pytest.
# On command line both should work or none
python3 -c "import pytest"
which pytest
# It is pretty clear if you fail. Success can be more obscure.
# Here is a fail test, so you can compare
python3 -c "import yptest"
which yptest
To install pytest, you need to be root/administrator.
pip install -U pytest
# or maybe (depending on your system)
sudo pip install -U pytest

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive. 
# You hopefully remember the '''MyMath''' class you made in exercise 1 & 2 in [[Beginning classes]]. Make a folder ''classes'' in your ''unittest/src'' folder and put the ''MyMath'' class in a file ''MyMath.py'' in ''unittest/src/classes''. Now make a unit test file ''MyMath_factorial_test.py'' in ''unittest/test'' that - surprise - tests your factorial method. Test it with at least these input: 12, 2, 1, 0, -1, 3.0, 3.4, "3", "3.1.", "ABC". Parametrize at least the tests that should succeed. Bonus for parametrizing the exceptions.

== Exercises for extra practice ==
# Add unit tests for all methods in your '''fasta''' class. That will be a bit of work.

Beginning unit test

2026-04-14T14:32:02Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

=== Installation of pytest ===
If you are using an anaconda python installation pytest is included. You can test in your python has pytest.
# On command line both should work or none
python3 -c "import pytest"
which pytest
# It is pretty clear if you fail. Success can be more obscure.
# Here is a fail test, so you can compare
python3 -c "import yptest"
which yptest
To install pytest, you need to be root/administrator.
pip install -U pytest
# or maybe (depending on your system)
sudo pip install -U pytest

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive. 
# You hopefully remember the '''MyMath''' class you made in exercise 1 & 2 in [[Beginning classes]]. Make a folder ''classes'' in your ''unittest/src'' folder and put the ''MyMath'' class in a file ''MyMath.py'' in 'unittest/src/classes''. Now make a unit test file ''MyMath_factorial_test.py'' in ''unittest/test'' that - surprise - tests your factorial method. Test it with at least these input: 12, 2, 1, 0, -1, 3.0, 3.4, "3", "3.1.", "ABC". Parametrize at least the tests that should succeed. Bonus for parametrizing the exceptions.

== Exercises for extra practice ==
# Add unit tests for all methods in your '''fasta''' class. That will be a bit of work.

Beginning unit test

2026-04-14T14:26:39Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

=== Installation of pytest ===
If you are using an anaconda python installation pytest is included. You can test in your python has pytest.
# On command line both should work or none
python3 -c "import pytest"
which pytest
# It is pretty clear if you fail. Success can be more obscure.
# Here is a fail test, so you can compare
python3 -c "import yptest"
which yptest
To install pytest, you need to be root/administrator.
pip install -U pytest
# or maybe (depending on your system)
sudo pip install -U pytest

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive. 
# You hopefully remember the '''MyMath''' class you made in exercise 1 & 2 in [[Beginning classes]]. Make a folder ''classes' in your ''unittest/src'' folder and put the ''MyMath'' class in a file ''MyMath.py'' in 'unittest/src/classes''. Now make a unit test file ''MyMath_factorial_test.py'' in ''unittest/test'' that - surprise - tests your factorial method.

== Exercises for extra practice ==
# Add unit tests for all methods in your '''fasta''' class. That will be a bit of work.

Intermediate unit test

2026-04-14T14:16:24Z

WikiSysop: /* Exercises to be handed in */

Beginning unit test

2026-04-14T14:15:55Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

=== Installation of pytest ===
If you are using an anaconda python installation pytest is included. You can test in your python has pytest.
# On command line both should work or none
python3 -c "import pytest"
which pytest
# It is pretty clear if you fail. Success can be more obscure.
# Here is a fail test, so you can compare
python3 -c "import yptest"
which yptest
To install pytest, you need to be root/administrator.
pip install -U pytest
# or maybe (depending on your system)
sudo pip install -U pytest

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive. 

== Exercises for extra practice ==
# Add unit tests for all methods in your '''fasta''' class. That will be a bit of work.

Beginning unit test

2026-04-13T10:06:00Z

WikiSysop: /* Required course material for the lesson */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

=== Installation of pytest ===
If you are using an anaconda python installation pytest is included. You can test in your python has pytest.
# On command line both should work or none
python3 -c "import pytest"
which pytest
# It is pretty clear if you fail. Success can be more obscure.
# Here is a fail test, so you can compare
python3 -c "import yptest"
which yptest
To install pytest, you need to be root/administrator.
pip install -U pytest
# or maybe (depending on your system)
sudo pip install -U pytest

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive. 
# Follow the file structure of having a ''code'' (or ''src'') folder for programs, a ''test'' folder for tests, and now a ''testdata'' folder for files containing test data. Now make unit tests and appropriate test data files for your '''fasta''' class from last week. In this exercise you just need to make unit test for the method '''load'''. You need to hand in both tests and test data. 
# Add unit tests for the method '''save''' in your '''fasta''' class. Hand in same way as above. 
# Add unit tests for the method '''delete''' in your '''fasta''' class. Hand in same way as above. 
I would not be surprised if you find errors in your '''fasta''' class based on these tests. I found flaws in my code.

== Exercises for extra practice ==
# Add unit tests for all methods in your '''fasta''' class. That will be a bit of work.

Beginning unit test

2026-04-13T09:52:42Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set containing numbers, and a dict where the keys are numbers. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive. 
# Follow the file structure of having a ''code'' (or ''src'') folder for programs, a ''test'' folder for tests, and now a ''testdata'' folder for files containing test data. Now make unit tests and appropriate test data files for your '''fasta''' class from last week. In this exercise you just need to make unit test for the method '''load'''. You need to hand in both tests and test data. 
# Add unit tests for the method '''save''' in your '''fasta''' class. Hand in same way as above. 
# Add unit tests for the method '''delete''' in your '''fasta''' class. Hand in same way as above. 
I would not be surprised if you find errors in your '''fasta''' class based on these tests. I found flaws in my code.

== Exercises for extra practice ==
# Add unit tests for all methods in your '''fasta''' class. That will be a bit of work.

Beginning unit test

2026-04-13T09:50:54Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Intermediate classes]]
|Next: [[Intermediate unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_09-Testing.ppt Testing] 
Online: [https://docs.pytest.org/ pytest documentation] 
Resource: [[Example code - Unit test]] 
Resource: [[Unit test - start of reverse polish notation class]] 

== Subjects covered ==
Overview of test methods 
Unit test using pytest framework.

== Exercises to be handed in ==
You should make a special folder for the exercises. I will refer to my special folder as ''unittest'' in these exercises. You will also see some ''__pycache__'' folders appear in places. This is Pythons cache for "compiled" programs. It is safe to ignore and also to delete, because it may become outdated. 
In some of these exercise you need to hand in not just a single file, but multiple files in a folder hierarchy. Zip the folder structure for your entire solution folder. Make sure it is clear to see what exercise your code/data is solving. And learn to zip :-)
# Use your '''normalize''' function from exercise 3 in [[Functions, namespace, memory management]]. If you did not do so already, change it to use exceptions instead of '''sys.exit()''', when an error occurs. Now make simple unit tests for the following test cases: a list of positive numbers, a list of negative numbers, a list of integers, a list of mixed floats and integers, a single number in the list, empty list, a list with at least one non-number (string, list, set), a set and a dict. Get other ideas if you can. The '''normalize''' function and all test functions must be in one single file (''normalize_test.py'' in ''unittest''), which you can run ''pytest'' on. 
# Now remove the '''normalize''' function from ''normalize_test.py'' and put it in its own file ''normalize.py''. Import it from the ''normalize_test.py'' like '''from normalize import normalize'''. The first ''normalize'' is the name of the .py file, the second ''normalize'' is the name of your normalize function. Just run ''pytest'' (no file name) in the folder to check it works. It is more normal to have test and function separated. 
# Above we removed test code from function code by creating two files. Next, put the files in their own folder in ''unittest''. I would put my ''normalize.py'' in ''unittest/src'' and ''normalize_test.py'' in ''unittest/test''. This way there is a very clear separation between function and test. The problem is making sure the test code loads the function code. Do it wrong a couple of times - it is very instructive. 
# Follow the file structure of having a ''code'' (or ''src'') folder for programs, a ''test'' folder for tests, and now a ''testdata'' folder for files containing test data. Now make unit tests and appropriate test data files for your '''fasta''' class from last week. In this exercise you just need to make unit test for the method '''load'''. You need to hand in both tests and test data. 
# Add unit tests for the method '''save''' in your '''fasta''' class. Hand in same way as above. 
# Add unit tests for the method '''delete''' in your '''fasta''' class. Hand in same way as above. 
I would not be surprised if you find errors in your '''fasta''' class based on these tests. I found flaws in my code.

== Exercises for extra practice ==
# Add unit tests for all methods in your '''fasta''' class. That will be a bit of work.

Beginning unit test

2026-04-13T09:40:22Z

WikiSysop: /* Exercises to be handed in */

Intermediate unit test

2026-04-10T12:07:43Z

WikiSysop: /* Subjects covered */

Intermediate unit test

2026-04-10T12:05:47Z

WikiSysop: /* Exercises for extra practice */

Intermediate unit test

2026-04-10T12:05:35Z

WikiSysop: /* Exercises to be handed in */

Intermediate classes

2026-03-23T10:06:12Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Beginning classes]]
|Next: [[Beginning unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_07-Classes.ppt Classes] 
Resource: [[Example code - Inheritance issues]] 

== Subjects covered ==
Magic methods in classes 
Object Oriented Programming 
Polymorphism and inheritance 
Practical knowledge

== Exercises to be handed in ==
The first four exercises will continue with the '''Fasta''' class from last time.
# Use magic methods to add ''iteration'' and ''length'' evaluation (using '''__iter__''' and '''__len__''' magic methods) to the '''Fasta''' class. Do this so you can write code like <div style="font-family:'Courier New'">if len(MyFastaInstance) > 0:     for header, sequence in MyFastaInstance:         # Do something with header and sequence         print(header, sequence)</div>The function '''len''' returns the number of sequences. 
# Add the methods '''deletethis()''', '''insertthis(header, sequence)''', '''verifythis(alphabet)''' and '''discardthis(alphabet)''' to the '''Fasta''' class. The methods should only work when ''iterating over an instance at the current item'', i.e. they work when you are iterating over the fasta sequences on the ''current'' sequence and header, like this:<div style="font-family:'Courier New'">for header, sequence in MyFastaInstance:     if not MyFastaInstance.verifythis("DNA"):         MyFastaInstance.deletethis()         continue     # Do something with header and sequence</div>As some may remember, it is normally impossible to successfully iterate straightforward through a list and delete and/or add elements to the list during the iteration. You have to make this possible. Hint: change the way your iteration works in the previous exercise. You need to take a position on this issue: When iterating over entries, how should you continue after inserting entries at your current position? Example: You are at element in position 5, you insert 2 elements at that position. This WILL mean the new elements are at position 5 and 6, and the one you "looked at" is now on position 7. Do you continue the iteration on position 5 or is the next position 8? My opinion is that you should not look at the new elements and you have already looked at the "old" element at 5, so the next one is at 8. You are free to make your own decision - just be clear about it. Realize if you insert something because you see a special element and you do not choose my way, then you will create an infinite loop, since you will see the special element again. 
# Let's do something natural. Make it possible to add one FastaInstance to another using the '''+=''' operator, like this:<div style="font-family:'Courier New'">FastaInstance1 += FastaInstance2 </div>The headers and sequences in Fastainstance2 should be added (list extension) to the headers and sequences in FastaInstance1. Use the magic method [https://zetcode.com/python/dunder-iadd/ '''__iadd__''']. Try with the files ''dna7.fsa'' and ''protein.fsa''. That will be a strange DNA and protein mix, but it is a great opportunity to use the '''discard''' method to get rid of one of the types. 
# Implement the ''addition'', using [https://zetcode.com/python/dunder-add/ '''__add__''']. Addition creates a new Fasta instance, but leaves the originals untouched.<div style="font-family:'Courier New'">FastaInstance3 = FastaInstance1 + FastaInstance2 </div>The resulting Fasta object must contain the headers and sequences from FastaInstance1 and FastaInstance2 in that order. Note that this works as an alternative constructor. Now that the Fasta class is done, save it in a file, so you can import it for the next exercises. 
# You can consider a '''Fasta''' instance as a ''set'' of headers/sequences. The sequences are obviously uniquely identified by the identifier in the header, which is what will be used as key in the set operations. In the rest of the exercises we will explore inheritance by making a new class called '''FastaSet''', which inherits from the '''Fasta''' class. A) The original '''__init__''', '''save''', '''load''', '''insert''', the iteration and the corresponding '''deletethis''', '''insertthis''', '''verifythis''' and '''discardthis''' methods are fine to keep in the new class (meaning do nothing about them). B) To help in the new class create a new getter method '''identifiers''', which returns a list of identifiers from the header lines. C) Override the '''content''' method such that it takes a set or list of identifiers and returns only the headers/sequences that corresponds to the identifiers in the list. If you do not specify a list/set of identifiers, it still returns all. D) Override the '''delete''' method in a similar way - it deletes the headers/sequences that corresponds to the input. E) Override the '''verify''' method in a similar way to '''content''' - it verifies the headers/sequences that corresponds to the input. F) Override the '''discard''' method in a similar way to '''content''' - it discards the headers/sequences that corresponds to the input. 
# As the new FastaSet class is set orientated, implement the following set operations in the class: A) union, operator is '''|''', magic method is '''__or__'''. B) intersection, operator is '''&''', magic method is '''__and__'''. C) difference, operator is '''-''', magic method is '''__sub__'''. D) symmetric difference, operator is '''^''', magic method is '''__xor__'''. These are quite similar to the addition in exercise 4 - the operators are used in the same way and a new Fasta object is returned. The identity of the sequence depends on the identifier in the corresponding header. This is an example of operator overloading - the normal arithmetic operator used on numbers are used on something completely different.

== Exercises for extra practice ==
# You continue to add the unique identifier control for all methods in Fasta and FastaSet, as mentioned last week.

Intermediate classes

2026-03-23T10:05:41Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Beginning classes]]
|Next: [[Beginning unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_07-Classes.ppt Classes] 
Resource: [[Example code - Inheritance issues]] 

== Subjects covered ==
Magic methods in classes 
Object Oriented Programming 
Polymorphism and inheritance 
Practical knowledge

== Exercises to be handed in ==
The first four exercises will continue with the '''Fasta''' class from last time.
# Use magic methods to add ''iteration'' and ''length'' evaluation (using '''__iter__''' and '''__len__''' magic methods) to the '''Fasta''' class. Do this so you can write code like <div style="font-family:'Courier New'">if len(MyFastaInstance) > 0:     for header, sequence in MyFastaInstance:         # Do something with header and sequence         print(header, sequence)</div>The function '''len''' returns the number of sequences. 
# Add the methods '''deletethis()''', '''insertthis(header, sequence)''', '''verifythis(alphabet)''' and '''discardthis(alphabet)''' to the '''Fasta''' class. The methods should only work when ''iterating over an instance at the current item'', i.e. they work when you are iterating over the fasta sequences on the ''current'' sequence and header, like this:<div style="font-family:'Courier New'">for header, sequence in MyFastaInstance:     if not MyFastaInstance.verifythis("DNA"):         MyFastaInstance.deletethis()         continue     # Do something with header and sequence</div>As some may remember, it is normally impossible to successfully iterate straightforward through a list and delete and/or add elements to the list during the iteration. You have to make this possible. Hint: change the way your iteration works in the previous exercise. You need to take a position on this issue: When iterating over entries, how should you continue after inserting entries at your current position? Example: You are at element in position 5, you insert 2 elements at that position. This WILL mean the new elements are at position 5 and 6, and the one you "looked at" is now on position 7. Do you continue the iteration on position 5 or is the next position 8? My opinion is that you should not look at the new elements and you have already looked at the "old" element at 5, so the next one is at 8. You are free to make your own decision - just be clear about it. Just realize if you insert something because you see a special elements and you do not choose my way, then you will create an infinite loop, since you will see the special element again. 
# Let's do something natural. Make it possible to add one FastaInstance to another using the '''+=''' operator, like this:<div style="font-family:'Courier New'">FastaInstance1 += FastaInstance2 </div>The headers and sequences in Fastainstance2 should be added (list extension) to the headers and sequences in FastaInstance1. Use the magic method [https://zetcode.com/python/dunder-iadd/ '''__iadd__''']. Try with the files ''dna7.fsa'' and ''protein.fsa''. That will be a strange DNA and protein mix, but it is a great opportunity to use the '''discard''' method to get rid of one of the types. 
# Implement the ''addition'', using [https://zetcode.com/python/dunder-add/ '''__add__''']. Addition creates a new Fasta instance, but leaves the originals untouched.<div style="font-family:'Courier New'">FastaInstance3 = FastaInstance1 + FastaInstance2 </div>The resulting Fasta object must contain the headers and sequences from FastaInstance1 and FastaInstance2 in that order. Note that this works as an alternative constructor. Now that the Fasta class is done, save it in a file, so you can import it for the next exercises. 
# You can consider a '''Fasta''' instance as a ''set'' of headers/sequences. The sequences are obviously uniquely identified by the identifier in the header, which is what will be used as key in the set operations. In the rest of the exercises we will explore inheritance by making a new class called '''FastaSet''', which inherits from the '''Fasta''' class. A) The original '''__init__''', '''save''', '''load''', '''insert''', the iteration and the corresponding '''deletethis''', '''insertthis''', '''verifythis''' and '''discardthis''' methods are fine to keep in the new class (meaning do nothing about them). B) To help in the new class create a new getter method '''identifiers''', which returns a list of identifiers from the header lines. C) Override the '''content''' method such that it takes a set or list of identifiers and returns only the headers/sequences that corresponds to the identifiers in the list. If you do not specify a list/set of identifiers, it still returns all. D) Override the '''delete''' method in a similar way - it deletes the headers/sequences that corresponds to the input. E) Override the '''verify''' method in a similar way to '''content''' - it verifies the headers/sequences that corresponds to the input. F) Override the '''discard''' method in a similar way to '''content''' - it discards the headers/sequences that corresponds to the input. 
# As the new FastaSet class is set orientated, implement the following set operations in the class: A) union, operator is '''|''', magic method is '''__or__'''. B) intersection, operator is '''&''', magic method is '''__and__'''. C) difference, operator is '''-''', magic method is '''__sub__'''. D) symmetric difference, operator is '''^''', magic method is '''__xor__'''. These are quite similar to the addition in exercise 4 - the operators are used in the same way and a new Fasta object is returned. The identity of the sequence depends on the identifier in the corresponding header. This is an example of operator overloading - the normal arithmetic operator used on numbers are used on something completely different.

== Exercises for extra practice ==
# You continue to add the unique identifier control for all methods in Fasta and FastaSet, as mentioned last week.

Example code - Inheritance issues

2026-03-19T19:22:14Z

WikiSysop: /* Take home messages */

The challenges in inheritance can not be demonstrated well in a powerpoint.
Thus, I made this page with examples. You can copy the code in the section and add it together and run it.

First I create a slightly bigger CatClass.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instantiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

### Main program
yourcat = CatClass('Missy', 'female')

CatClass.add_action("annoy", "scratches your face")
print("Actions in CatClass:", CatClass.count_action())

mycat = CatClass("Tom", "male")
kitten = mycat + yourcat

print(f"Kitten: {kitten.name}")

yourcat.action('scare')
</pre>
This class looks fine, but it has a number of inheritance issues.
By creating a Tiger class that inherits from the CatClass, I will demonstrate. Also, see how simple it was to create a new class based on an old :-)
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

tigger = Tiger("Shere Khan", "male")
tigger.action("scratch")
tigger.action('scare')
</pre>
We want the Tiger to react differently than the Cat, at least for some actions. However, this code does not do it. The problem lies in the inherited '''action''' method.
<pre>
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

# We are specifically using the actions in the CatClass for the behavior
# We need to use the current class, as in cats uses CatClass actions and tigers uses Tiger actions.

# These are the problematic lines, they can be replaced in different ways
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
# Through '''self''', as self will search the instance namespace and then the class namespace for the variable
if act in self.acts:
print(self._name, self.acts[act])
# By dynamically getting the class by type
cls = type(self)
if act in cls.acts:
print(self._name, cls.acts[act])
</pre>
This does not completely solve the problem. We would still like to be able to scare the tiger (inherit the cat action), but for now it looks bored when we try. This problem is caused by the complete replacement of the class variable acts in the Tiger class. The cat actions are deleted and replaced with tiger-only actions.
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

# Thats OK, we will just add the tiger actions later - we inherited the add_action from CatClass
class Tiger(CatClass):
pass

tigger = Tiger("Shere Khan", "male")
tigger.add_action('scratch', 'roars')
tigger.add_action('feed', 'demands more meat')
# Testing
tigger.action('scare')
tigger.action('feed')
# All good, but what happened to our cat?
mycat.action('scratch')
</pre>
The cat started roaring when scratched - that is a tiger action. Looking at the add_action class method, it is not specifying anywhere that the CatClass should be used so what is wrong? The problem is that the Tiger and the CatClass are ''sharing'' the class variables. The Tiger did not make new ones, so it is using the CatClass class variables, because CatClass is the parent class. Right now any changes in action made by the Tiger class is reflected in the CatClass and vice versa. The Tiger needs is own. Also did you notice that the Tiger's scientific name is Felis Catus, same as the cat - ridiculous.
<pre>
class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'} = 'demands more meat'

tigger = Tiger("Shere Khan", "male")
tigger.action('scratch')
mycat.action('scratch')
</pre>
Much better. Copy the mutable class variables from the base class and then change them so they fit.

Life is good. Let's make some kittens.....
<pre>
kitten1 = mycat + yourcat
print(kitten1.name)

# Can we mate the cat and the tiger?
kitten2 = yourcat + tigger
kitten2.name = "Monstrous Mutant"
print(kitten2.name)
kitten2.action('scratch')
</pre>
That was unfortunate. We should not be able to breed a cat and a tiger, and if we did anyway, should the result be a cat (the kitten does a cat action)? 
The issue is in the ''__add__'' magic method. All that is required is that the two classes being "added" have a _gender instance variable.
<pre>
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten
</pre>
Here are the two classes without any inheritance problems. I will leave it to you to do the testing.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instantiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in self.acts:
print(self._name, self.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'] = 'demands more meat'
</pre>
== Take home messages ==
* Even if you do not plan for your class to be inherited, make it so it can. That way it is less work later AND you remember how to do it.
* Don't hardcode class names in your class. Use ''type(self)'' to get the class. This goes when using class variables, constructing new instances and elsewhere. But not when copying the parent class' class variables - there you have to name it :-)
* Make a copy of mutable class variables if you have any plan or possibility to modify them.
* In magic methods check that the ''other'' class is the same as ''self''.
* Notice that what you learned here is slightly different from what was told in the beginning of the powerpoint.

Example code - Inheritance issues

2026-03-19T18:54:04Z

WikiSysop:

Example code - Inheritance issues

2026-03-19T18:52:06Z

WikiSysop: /* Take home messages */

The challenges in inheritance can not be demonstrated well in a powerpoint.
Thus, I made this page with examples. You can copy the code in the section and add it together and run it.

First I create a slightly bigger CatClass.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

### Main program
yourcat = CatClass('Missy', 'female')

CatClass.add_action("annoy", "scratches your face")
print("Actions in CatClass:", CatClass.count_action())

mycat = CatClass("Tom", "male")
kitten = mycat + yourcat

print(f"Kitten: {kitten.name}")

yourcat.action('scare')
</pre>
This class looks fine, but it has a number of inheritance issues.
By creating a Tiger class that inherits from the CatClass, I will demonstrate. Also, see how simple it was to create a new class based on an old :-)
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

tigger = Tiger("Shere Khan", "male")
tigger.action("scratch")
tigger.action('scare')
</pre>
We want the Tiger to react differently than the Cat, at least for some actions. However, this code does not do it. The problem lies in the inherited '''action''' method.
<pre>
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

# We are specifically using the actions in the CatClass for the behavior
# We need to use the current class, as in cats uses CatClass actions and tigers uses Tiger actions.

# These are the problematic lines, they can be replaced in different ways
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
# Through '''self''', as self will search the instance namespace and then the class namespace for the variable
if act in self.acts:
print(self._name, self.acts[act])
# By dynamically getting the class by type
cls = type(self)
if act in cls.acts:
print(self._name, cls.acts[act])
</pre>
This does not completely solve the problem. We would still like to be able to scare the tiger (inherit the cat action), but for now it looks bored when we try. This problem is caused by the complete replacement of the class variable acts in the Tiger class. The cat actions are deleted and replaced with tiger-only actions.
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

# Thats OK, we will just add the tiger actions later - we inherited the add_action from CatClass
class Tiger(CatClass):
pass

tigger = Tiger("Shere Khan", "male")
tigger.add_action('scratch', 'roars')
tigger.add_action('feed', 'demands more meat')
# Testing
tigger.action('scare')
tigger.action('feed')
# All good, but what happened to our cat?
mycat.action('scratch')
</pre>
The cat started roaring when scratched - that is a tiger action. Looking at the add_action class method, it is not specifying anywhere that the CatClass should be used so what is wrong? The problem is that the Tiger and the CatClass are ''sharing'' the class variables. The Tiger did not make new ones, so it is using the CatClass class variables, because CatClass is the parent class. Right now any changes in action made by the Tiger class is reflected in the CatClass and vice versa. The Tiger needs is own. Also did you notice that the Tiger's scientific name is Felis Catus, same as the cat - ridiculous.
<pre>
class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'} = 'demands more meat'

tigger = Tiger("Shere Khan", "male")
tigger.action('scratch')
mycat.action('scratch')
</pre>
Much better. Copy the mutable class variables from the base class and then change them so they fit.

Life is good. Let's make some kittens.....
<pre>
kitten1 = mycat + yourcat
print(kitten1.name)

# Can we mate the cat and the tiger?
kitten2 = yourcat + tigger
kitten2.name = "Monstrous Mutant"
print(kitten2.name)
kitten2.action('scratch')
</pre>
That was unfortunate. We should not be able to breed a cat and a tiger, and if we did anyway, should the result be a cat (the kitten does a cat action)? 
The issue is in the ''__add__'' magic method. All that is required is that the two classes being "added" have a _gender instance variable.
<pre>
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten
</pre>
Here are the two classes without any inheritance problems. I will leave it to you to do the testing.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in self.acts:
print(self._name, self.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'] = 'demands more meat'
</pre>
== Take home messages ==
* Even if you do not plan for your class to be inherited, make it so it can. That way it is less work later AND you remember how to do it.
* Don't hardcode class names in your class. Use ''type(self)'' to get the class. This goes when using class variables, constructing new instances and elsewhere. But not when copying the parent class' class variables - there you have to name it :-)
* Make a copy of mutable class variables if you have any plan or possibility to modify them.
* In magic methods check that the ''other'' class is the same as ''self''.

Example code - Inheritance issues

2026-03-19T18:48:00Z

WikiSysop: /* Take home messages */

The challenges in inheritance can not be demonstrated well in a powerpoint.
Thus, I made this page with examples. You can copy the code in the section and add it together and run it.

First I create a slightly bigger CatClass.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

### Main program
yourcat = CatClass('Missy', 'female')

CatClass.add_action("annoy", "scratches your face")
print("Actions in CatClass:", CatClass.count_action())

mycat = CatClass("Tom", "male")
kitten = mycat + yourcat

print(f"Kitten: {kitten.name}")

yourcat.action('scare')
</pre>
This class looks fine, but it has a number of inheritance issues.
By creating a Tiger class that inherits from the CatClass, I will demonstrate. Also, see how simple it was to create a new class based on an old :-)
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

tigger = Tiger("Shere Khan", "male")
tigger.action("scratch")
tigger.action('scare')
</pre>
We want the Tiger to react differently than the Cat, at least for some actions. However, this code does not do it. The problem lies in the inherited '''action''' method.
<pre>
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

# We are specifically using the actions in the CatClass for the behavior
# We need to use the current class, as in cats uses CatClass actions and tigers uses Tiger actions.

# These are the problematic lines, they can be replaced in different ways
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
# Through '''self''', as self will search the instance namespace and then the class namespace for the variable
if act in self.acts:
print(self._name, self.acts[act])
# By dynamically getting the class by type
cls = type(self)
if act in cls.acts:
print(self._name, cls.acts[act])
</pre>
This does not completely solve the problem. We would still like to be able to scare the tiger (inherit the cat action), but for now it looks bored when we try. This problem is caused by the complete replacement of the class variable acts in the Tiger class. The cat actions are deleted and replaced with tiger-only actions.
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

# Thats OK, we will just add the tiger actions later - we inherited the add_action from CatClass
class Tiger(CatClass):
pass

tigger = Tiger("Shere Khan", "male")
tigger.add_action('scratch', 'roars')
tigger.add_action('feed', 'demands more meat')
# Testing
tigger.action('scare')
tigger.action('feed')
# All good, but what happened to our cat?
mycat.action('scratch')
</pre>
The cat started roaring when scratched - that is a tiger action. Looking at the add_action class method, it is not specifying anywhere that the CatClass should be used so what is wrong? The problem is that the Tiger and the CatClass are ''sharing'' the class variables. The Tiger did not make new ones, so it is using the CatClass class variables, because CatClass is the parent class. Right now any changes in action made by the Tiger class is reflected in the CatClass and vice versa. The Tiger needs is own. Also did you notice that the Tiger's scientific name is Felis Catus, same as the cat - ridiculous.
<pre>
class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'} = 'demands more meat'

tigger = Tiger("Shere Khan", "male")
tigger.action('scratch')
mycat.action('scratch')
</pre>
Much better. Copy the mutable class variables from the base class and then change them so they fit.

Life is good. Let's make some kittens.....
<pre>
kitten1 = mycat + yourcat
print(kitten1.name)

# Can we mate the cat and the tiger?
kitten2 = yourcat + tigger
kitten2.name = "Monstrous Mutant"
print(kitten2.name)
kitten2.action('scratch')
</pre>
That was unfortunate. We should not be able to breed a cat and a tiger, and if we did anyway, should the result be a cat (the kitten does a cat action)? 
The issue is in the ''__add__'' magic method. All that is required is that the two classes being "added" have a _gender instance variable.
<pre>
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten
</pre>
Here are the two classes without any inheritance problems. I will leave it to you to do the testing.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in self.acts:
print(self._name, self.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'] = 'demands more meat'
</pre>
== Take home messages ==
* Even if you do not plan for your class to be inherited, make it so it can. That way it is less work later AND you remember how to do it.
* Don't hardcode class names in your class. Use ''type(self)'' to get the class. This goes when using class variables, constructing new instances.
* Make a copy of mutable class variables if you have any plan or possibility to modify them.
* In magic methods check that the ''other'' class is the same as ''self''.

Example code - Inheritance issues

2026-03-19T18:44:30Z

WikiSysop: /* Take home messages */

The challenges in inheritance can not be demonstrated well in a powerpoint.
Thus, I made this page with examples. You can copy the code in the section and add it together and run it.

First I create a slightly bigger CatClass.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

### Main program
yourcat = CatClass('Missy', 'female')

CatClass.add_action("annoy", "scratches your face")
print("Actions in CatClass:", CatClass.count_action())

mycat = CatClass("Tom", "male")
kitten = mycat + yourcat

print(f"Kitten: {kitten.name}")

yourcat.action('scare')
</pre>
This class looks fine, but it has a number of inheritance issues.
By creating a Tiger class that inherits from the CatClass, I will demonstrate. Also, see how simple it was to create a new class based on an old :-)
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

tigger = Tiger("Shere Khan", "male")
tigger.action("scratch")
tigger.action('scare')
</pre>
We want the Tiger to react differently than the Cat, at least for some actions. However, this code does not do it. The problem lies in the inherited '''action''' method.
<pre>
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

# We are specifically using the actions in the CatClass for the behavior
# We need to use the current class, as in cats uses CatClass actions and tigers uses Tiger actions.

# These are the problematic lines, they can be replaced in different ways
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
# Through '''self''', as self will search the instance namespace and then the class namespace for the variable
if act in self.acts:
print(self._name, self.acts[act])
# By dynamically getting the class by type
cls = type(self)
if act in cls.acts:
print(self._name, cls.acts[act])
</pre>
This does not completely solve the problem. We would still like to be able to scare the tiger (inherit the cat action), but for now it looks bored when we try. This problem is caused by the complete replacement of the class variable acts in the Tiger class. The cat actions are deleted and replaced with tiger-only actions.
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

# Thats OK, we will just add the tiger actions later - we inherited the add_action from CatClass
class Tiger(CatClass):
pass

tigger = Tiger("Shere Khan", "male")
tigger.add_action('scratch', 'roars')
tigger.add_action('feed', 'demands more meat')
# Testing
tigger.action('scare')
tigger.action('feed')
# All good, but what happened to our cat?
mycat.action('scratch')
</pre>
The cat started roaring when scratched - that is a tiger action. Looking at the add_action class method, it is not specifying anywhere that the CatClass should be used so what is wrong? The problem is that the Tiger and the CatClass are ''sharing'' the class variables. The Tiger did not make new ones, so it is using the CatClass class variables, because CatClass is the parent class. Right now any changes in action made by the Tiger class is reflected in the CatClass and vice versa. The Tiger needs is own. Also did you notice that the Tiger's scientific name is Felis Catus, same as the cat - ridiculous.
<pre>
class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'} = 'demands more meat'

tigger = Tiger("Shere Khan", "male")
tigger.action('scratch')
mycat.action('scratch')
</pre>
Much better. Copy the mutable class variables from the base class and then change them so they fit.

Life is good. Let's make some kittens.....
<pre>
kitten1 = mycat + yourcat
print(kitten1.name)

# Can we mate the cat and the tiger?
kitten2 = yourcat + tigger
kitten2.name = "Monstrous Mutant"
print(kitten2.name)
kitten2.action('scratch')
</pre>
That was unfortunate. We should not be able to breed a cat and a tiger, and if we did anyway, should the result be a cat (the kitten does a cat action)? 
The issue is in the ''__add__'' magic method. All that is required is that the two classes being "added" have a _gender instance variable.
<pre>
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten
</pre>
Here are the two classes without any inheritance problems. I will leave it to you to do the testing.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in self.acts:
print(self._name, self.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'] = 'demands more meat'
</pre>
== Take home messages ==
* Even if you do not plan for your class to be inherited, make it so it can. That way it is less work later AND you remember how to do it.
* Don't hardcode class names in your class. Use ''type(self)'' to get the class.
* Make a copy of mutable class variables if you have any plan or possibility to modify them.

Example code - Inheritance issues

2026-03-19T18:42:29Z

WikiSysop:

The challenges in inheritance can not be demonstrated well in a powerpoint.
Thus, I made this page with examples. You can copy the code in the section and add it together and run it.

First I create a slightly bigger CatClass.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

### Main program
yourcat = CatClass('Missy', 'female')

CatClass.add_action("annoy", "scratches your face")
print("Actions in CatClass:", CatClass.count_action())

mycat = CatClass("Tom", "male")
kitten = mycat + yourcat

print(f"Kitten: {kitten.name}")

yourcat.action('scare')
</pre>
This class looks fine, but it has a number of inheritance issues.
By creating a Tiger class that inherits from the CatClass, I will demonstrate. Also, see how simple it was to create a new class based on an old :-)
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

tigger = Tiger("Shere Khan", "male")
tigger.action("scratch")
tigger.action('scare')
</pre>
We want the Tiger to react differently than the Cat, at least for some actions. However, this code does not do it. The problem lies in the inherited '''action''' method.
<pre>
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

# We are specifically using the actions in the CatClass for the behavior
# We need to use the current class, as in cats uses CatClass actions and tigers uses Tiger actions.

# These are the problematic lines, they can be replaced in different ways
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
# Through '''self''', as self will search the instance namespace and then the class namespace for the variable
if act in self.acts:
print(self._name, self.acts[act])
# By dynamically getting the class by type
cls = type(self)
if act in cls.acts:
print(self._name, cls.acts[act])
</pre>
This does not completely solve the problem. We would still like to be able to scare the tiger (inherit the cat action), but for now it looks bored when we try. This problem is caused by the complete replacement of the class variable acts in the Tiger class. The cat actions are deleted and replaced with tiger-only actions.
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

# Thats OK, we will just add the tiger actions later - we inherited the add_action from CatClass
class Tiger(CatClass):
pass

tigger = Tiger("Shere Khan", "male")
tigger.add_action('scratch', 'roars')
tigger.add_action('feed', 'demands more meat')
# Testing
tigger.action('scare')
tigger.action('feed')
# All good, but what happened to our cat?
mycat.action('scratch')
</pre>
The cat started roaring when scratched - that is a tiger action. Looking at the add_action class method, it is not specifying anywhere that the CatClass should be used so what is wrong? The problem is that the Tiger and the CatClass are ''sharing'' the class variables. The Tiger did not make new ones, so it is using the CatClass class variables, because CatClass is the parent class. Right now any changes in action made by the Tiger class is reflected in the CatClass and vice versa. The Tiger needs is own. Also did you notice that the Tiger's scientific name is Felis Catus, same as the cat - ridiculous.
<pre>
class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'} = 'demands more meat'

tigger = Tiger("Shere Khan", "male")
tigger.action('scratch')
mycat.action('scratch')
</pre>
Much better. Copy the mutable class variables from the base class and then change them so they fit.

Life is good. Let's make some kittens.....
<pre>
kitten1 = mycat + yourcat
print(kitten1.name)

# Can we mate the cat and the tiger?
kitten2 = yourcat + tigger
kitten2.name = "Monstrous Mutant"
print(kitten2.name)
kitten2.action('scratch')
</pre>
That was unfortunate. We should not be able to breed a cat and a tiger, and if we did anyway, should the result be a cat (the kitten does a cat action)? 
The issue is in the ''__add__'' magic method. All that is required is that the two classes being "added" have a _gender instance variable.
<pre>
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten
</pre>
Here are the two classes without any inheritance problems. I will leave it to you to do the testing.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in self.acts:
print(self._name, self.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'] = 'demands more meat'
</pre>
== Take home messages ==
* Even if you do not plan for your class to be inherited, make it so it can. That way it is less work later AND you remember how to do it.
* Don't hardcode class names in your class. Use ''type(self)'' to get the class.

Example code - Inheritance issues

2026-03-19T18:42:10Z

WikiSysop:

The challenges in inheritance can not be demonstrated well in a powerpoint.
Thus, I made this page with examples. You can copy the code in the section and add it together and run it.

First I create a slightly bigger CatClass.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

### Main program
yourcat = CatClass('Missy', 'female')

CatClass.add_action("annoy", "scratches your face")
print("Actions in CatClass:", CatClass.count_action())

mycat = CatClass("Tom", "male")
kitten = mycat + yourcat

print(f"Kitten: {kitten.name}")

yourcat.action('scare')
</pre>
This class looks fine, but it has a number of inheritance issues.
By creating a Tiger class that inherits from the CatClass, I will demonstrate. Also, see how simple it was to create a new class based on an old :-)
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

tigger = Tiger("Shere Khan", "male")
tigger.action("scratch")
tigger.action('scare')
</pre>
We want the Tiger to react differently than the Cat, at least for some actions. However, this code does not do it. The problem lies in the inherited '''action''' method.
<pre>
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

# We are specifically using the actions in the CatClass for the behavior
# We need to use the current class, as in cats uses CatClass actions and tigers uses Tiger actions.

# These are the problematic lines, they can be replaced in different ways
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
# Through '''self''', as self will search the instance namespace and then the class namespace for the variable
if act in self.acts:
print(self._name, self.acts[act])
# By dynamically getting the class by type
cls = type(self)
if act in cls.acts:
print(self._name, cls.acts[act])
</pre>
This does not completely solve the problem. We would still like to be able to scare the tiger (inherit the cat action), but for now it looks bored when we try. This problem is caused by the complete replacement of the class variable acts in the Tiger class. The cat actions are deleted and replaced with tiger-only actions.
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

# Thats OK, we will just add the tiger actions later - we inherited the add_action from CatClass
class Tiger(CatClass):
pass

tigger = Tiger("Shere Khan", "male")
tigger.add_action('scratch', 'roars')
tigger.add_action('feed', 'demands more meat')
# Testing
tigger.action('scare')
tigger.action('feed')
# All good, but what happened to our cat?
mycat.action('scratch')
</pre>
The cat started roaring when scratched - that is a tiger action. Looking at the add_action class method, it is not specifying anywhere that the CatClass should be used so what is wrong? The problem is that the Tiger and the CatClass are ''sharing'' the class variables. The Tiger did not make new ones, so it is using the CatClass class variables, because CatClass is the parent class. Right now any changes in action made by the Tiger class is reflected in the CatClass and vice versa. The Tiger needs is own. Also did you notice that the Tiger's scientific name is Felis Catus, same as the cat - ridiculous.
<pre>
class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'} = 'demands more meat'

tigger = Tiger("Shere Khan", "male")
tigger.action('scratch')
mycat.action('scratch')
</pre>
Much better. Copy the mutable class variables from the base class and then change them so they fit.

Life is good. Let's make some kittens.....
<pre>
kitten1 = mycat + yourcat
print(kitten1.name)

# Can we mate the cat and the tiger?
kitten2 = yourcat + tigger
kitten2.name = "Monstrous Mutant"
print(kitten2.name)
kitten2.action('scratch')
</pre>
That was unfortunate. We should not be able to breed a cat and a tiger, and if we did anyway, should the result be a cat (the kitten does a cat action)? 
The issue is in the ''__add__'' magic method. All that is required is that the two classes being "added" have a _gender instance variable.
<pre>
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten
</pre>
Here are the two classes without any inheritance problems. I will leave it to you to do the testing.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in self.acts:
print(self._name, self.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'] = 'demands more meat'
</pre>
== Take home messages
* Even if you do not plan for your class to be inherited, make it so it can. That way it is less work later AND you remember how to do it.
* Don't hardcode class names in your class. Use ''type(self)'' to get the class.

Example code - Inheritance issues

2026-03-19T18:36:46Z

WikiSysop:

The challenges in inheritance can not be demonstrated well in a powerpoint.
Thus, I made this page with examples. You can copy the code in the section and add it together and run it.

First I create a slightly bigger CatClass.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

### Main program
yourcat = CatClass('Missy', 'female')

CatClass.add_action("annoy", "scratches your face")
print("Actions in CatClass:", CatClass.count_action())

mycat = CatClass("Tom", "male")
kitten = mycat + yourcat

print(f"Kitten: {kitten.name}")

yourcat.action('scare')
</pre>
This class looks fine, but it has a number of inheritance issues.
By creating a Tiger class that inherits from the CatClass, I will demonstrate. Also, see how simple it was to create a new class based on an old :-)
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

tigger = Tiger("Shere Khan", "male")
tigger.action("scratch")
tigger.action('scare')
</pre>
We want the Tiger to react differently than the Cat, at least for some actions. However, this code does not do it. The problem lies in the inherited '''action''' method.
<pre>
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

# We are specifically using the actions in the CatClass for the behavior
# We need to use the current class, as in cats uses CatClass actions and tigers uses Tiger actions.

# These are the problematic lines, they can be replaced in different ways
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
# Through '''self''', as self will search the instance namespace and then the class namespace for the variable
if act in self.acts:
print(self._name, self.acts[act])
# By dynamically getting the class by type
cls = type(self)
if act in cls.acts:
print(self._name, cls.acts[act])
</pre>
This does not completely solve the problem. We would still like to be able to scare the tiger (inherit the cat action), but for now it looks bored when we try. This problem is caused by the complete replacement of the class variable acts in the Tiger class. The cat actions are deleted and replaced with tiger-only actions.
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

# Thats OK, we will just add the tiger actions later - we inherited the add_action from CatClass
class Tiger(CatClass):
pass

tigger = Tiger("Shere Khan", "male")
tigger.add_action('scratch', 'roars')
tigger.add_action('feed', 'demands more meat')
# Testing
tigger.action('scare')
tigger.action('feed')
# All good, but what happened to our cat?
mycat.action('scratch')
</pre>
The cat started roaring when scratched - that is a tiger action. Looking at the add_action class method, it is not specifying anywhere that the CatClass should be used so what is wrong? The problem is that the Tiger and the CatClass are ''sharing'' the class variables. The Tiger did not make new ones, so it is using the CatClass class variables, because CatClass is the parent class. Right now any changes in action made by the Tiger class is reflected in the CatClass and vice versa. The Tiger needs is own. Also did you notice that the Tiger's scientific name is Felis Catus, same as the cat - ridiculous.
<pre>
class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'} = 'demands more meat'

tigger = Tiger("Shere Khan", "male")
tigger.action('scratch')
mycat.action('scratch')
</pre>
Much better. Copy the mutable class variables from the base class and then change them so they fit.

Life is good. Let's make some kittens.....
<pre>
kitten1 = mycat + yourcat
print(kitten1.name)

# Can we mate the cat and the tiger?
kitten2 = yourcat + tigger
kitten2.name = "Monstrous Mutant"
print(kitten2.name)
kitten2.action('scratch')
</pre>
That was unfortunate. We should not be able to breed a cat and a tiger, and if we did anyway, should the result be a cat (the kitten does a cat action)? 
The issue is in the ''__add__'' magic method. All the is required is that the two classes being "added" have a _gender instance variable.
<pre>
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten
</pre>
Here are the two classes without any inheritance problems. I will leave it to you to do the testing.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in self.acts:
print(self._name, self.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'] = 'demands more meat'
</pre>

Example code - Inheritance issues

2026-03-19T18:19:06Z

WikiSysop:

The challenges in inheritance can not be demonstrated well in a powerpoint.
Thus, I made this page with examples. You can copy the code in the section and add it together and run it.

First I create a slightly bigger CatClass.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

### Main program
yourcat = CatClass('Missy', 'female')

CatClass.add_action("annoy", "scratches your face")
print("Actions in CatClass:", CatClass.count_action())

mycat = CatClass("Tom", "male")
kitten = mycat + yourcat

print(f"Kitten: {kitten.name}")

yourcat.action('scare')
</pre>
This class looks fine, but it has a number of inheritance issues.
By creating a Tiger class that inherits from the CatClass, I will demonstrate. Also, see how simple it was to create a new class based on an old :-)
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

tigger = Tiger("Shere Khan", "male")
tigger.action("scratch")
tigger.action('scare')
</pre>
We want the Tiger to react differently than the Cat, at least for some actions. However, this code does not do it. The problem lies in the inherited '''action''' method.
<pre>
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

# We are specifically using the actions in the CatClass for the behavior
# We need to use the current class, as in cats uses CatClass actions and tigers uses Tiger actions.

# These are the problematic lines, they can be replaced in different ways
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
# Through '''self''', as self will search the instance namespace and then the class namespace for the variable
if act in self.acts:
print(self._name, self.acts[act])
# By dynamically getting the class by type
cls = type(self)
if act in cls.acts:
print(self._name, cls.acts[act])
</pre>
This does not completely solve the problem. We would still like to be able to scare the tiger (inherit the cat action), but for now it looks bored when we try. This problem is caused by the complete replacement of the class variable acts in the Tiger class. The cat actions are deleted and replaced with tiger-only actions.
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

# Thats OK, we will just add the tiger actions later - we inherited the add_action from CatClass
class Tiger(CatClass):
pass

tigger = Tiger("Shere Khan", "male")
tigger.add_action('scratch', 'roars')
tigger.add_action('feed', 'demands more meat')
# Testing
tigger.action('scare')
tigger.action('feed')
# All good, but what happened to our cat?
mycat.action('scratch')
</pre>
The cat started roaring when scratched - that is a tiger action. Looking at the add_action class method, it is not specifying anywhere that the CatClass should be used so what is wrong? The problem is that the Tiger and the CatClass are ''sharing'' the class variables. The Tiger did not make new ones, so it is using the CatClass class variables, because CatClass is the parent class. Right now any changes in action made by the Tiger class is reflected in the CatClass and vice versa. The Tiger needs is own. Also did you notice that the Tiger's scientific name is Felis Catus, same as the cat - ridiculous.
<pre>
class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'} = 'demands more meat'

tigger = Tiger("Shere Khan", "male")
tigger.action('scratch')
mycat.action('scratch')
</pre>
Much better. Copy the mutable class variables from the base class and then change them so they fit.

Life is good. Let's make some kittens.....
<pre>
kitten1 = mycat + yourcat
print(kitten1.name)

# Can we mate the cat and the tiger?
kitten2 = yourcat + tigger
kitten2.name = "Monstrous Mutant"
print(kitten2.name)
kitten2.action('scratch')
</pre>
That was unfortunate. We should not be able to breed a cat and a tiger, and if we did anyway, should the result be a cat (the kitten does a cat action)? 
The issue is in the ''__add__'' magic method. All the is required is that the two classes being "added" have a _gender instance variable.
<pre>
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self) != type(other):
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Still male kittens, making sure tigers begets tigers and cats begets cats
kitten = type(self)('Unnamed kitten', 'male')
return kitten
</pre>

Example code - Inheritance issues

2026-03-19T17:48:08Z

WikiSysop:

The challenges in inheritance can not be demonstrated well in a powerpoint.
Thus, I made this page with examples. You can copy the code in the section and add it together and run it.

First I create a slightly bigger CatClass.
<pre>
class CatClass:
### Class variables
genus = "Felis"
species = "Catus"
acts = {'scratch': "purrs",
'scare': "jumps high in the air",
'feed': "is very excited" }

### Instatiation
def __init__(self, name, gender):
self._name, self._gender = name, gender

### Magic methods
# Addition makes a kitten if male and female cat, alternative constructor
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

### Class methods
# Adding a cat action
@classmethod
def add_action(cls, action, reaction):
cls.acts[action] = reaction
# Querying class for number of actions
@classmethod
def count_action(cls):
return len(cls.acts)

### Property methods
# name setter and getter
@property
def name(self):
if not hasattr(self, '_name'):
raise NameError("Name of cat is not yet set")
return self._name

@name.setter
def name(self, value):
if value == '':
raise ValueError("Name can not be nothing")
self._name = value

### Instance methods
# The action method - using class variables
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

### Main program
yourcat = CatClass('Missy', 'female')

CatClass.add_action("annoy", "scratches your face")
print("Actions in CatClass:", CatClass.count_action())

mycat = CatClass("Tom", "male")
kitten = mycat + yourcat

print(f"Kitten: {kitten.name}")

yourcat.action('scare')
</pre>
This class looks fine, but it has a number of inheritance issues.
By creating a Tiger class that inherits from the CatClass, I will demonstrate. Also, see how simple it was to create a new class based on an old :-)
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

tigger = Tiger("Shere Khan", "male")
tigger.action("scratch")
tigger.action('scare')
</pre>
We want the Tiger to react differently than the Cat, at least for some actions. However, this code does not do it. The problem lies in the inherited '''action''' method.
<pre>
def action(self, act):
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
elif self._gender == 'male':
print(self._name, "looks bored")
else:
print(self._name, "yawns")

# We are specifically using the actions in the CatClass for the behavior
# We need to use the current class, as in cats uses CatClass actions and tigers uses Tiger actions.

# These are the problematic lines, they can be replaced in different ways
if act in CatClass.acts:
print(self._name, CatClass.acts[act])
# Through '''self''', as self will search the instance namespace and then the class namespace for the variable
if act in self.acts:
print(self._name, self.acts[act])
# By dynamically getting the class by type
cls = type(self)
if act in cls.acts:
print(self._name, cls.acts[act])
</pre>
This does not completely solve the problem. We would still like to be able to scare the tiger (inherit the cat action), but for now it looks bored when we try. This problem is caused by the complete replacement of the class variable acts in the Tiger class. The cat actions are deleted and replaced with tiger-only actions.
<pre>
class Tiger(CatClass):
acts = {
'scratch': 'roars',
'feed': 'demands more meat'
}

# Thats OK, we will just add the tiger actions later - we inherited the add_action from CatClass
class Tiger(CatClass):
pass

tigger = Tiger("Shere Khan", "male")
tigger.add_action('scratch', 'roars')
tigger.add_action('feed', 'demands more meat')
# Testing
tigger.action('scare')
tigger.action('feed')
# All good, but what happened to our cat?
mycat.action('scratch')
</pre>
The cat started roaring when scratched - that is a tiger action. Looking at the add_action class method, it is not specifying anywhere that the CatClass should be used so what is wrong? The problem is that the Tiger and the CatClass are ''sharing'' the class variables. The Tiger did not make new ones, so it is using the CatClass class variables, because CatClass is the parent class. Right now any changes in action made by the Tiger class is reflected in the CatClass and vice versa. The Tiger needs is own. Also did you notice that the Tiger's scientific name is Felis Catus, same as the cat - ridiculous.
<pre>
class Tiger(CatClass):
### Class variables
genus = "Panthera"
species = "Tigris"
acts = CatClass.acts.copy()
# Tiger class specials
acts['scratch'] = 'roars'
acts['feed'} = 'demands more meat'

tigger = Tiger("Shere Khan", "male")
tigger.action('scratch')
mycat.action('scratch')
</pre>
Much better. Copy the mutable class variables from the base class and then change them so they fit.

Life is good. Let's make some kittens.....
<pre>
kitten1 = mycat + yourcat
print(kitten1.name)

# Can we mate the cat and the tiger?
kitten2 = yourcat + tigger
kitten2.name = "Monstrous Mutant"
print(kitten2.name)
kitten2.action('scratch')
</pre>
That was unfortunate. We should not be able to breed a cat and a tiger, and if we did anyway, should the result be a cat (the kitten does a cat action)? 
The issue is in the ''__add__'' magic method. All the is required is that the two classes being "added" have a _gender instance variable.
<pre>
def __add__(self, other):
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

# Adding a class check - we must demand that we breed tigers with tigers and cats with cats
def __add__(self, other):
if type(self._gender == other._gender:
return NotImplemented
# Taken a short cut and just demanding the genders to be different to breed
if self._gender == other._gender:
return NotImplemented
# Being biased and saying all kittens are male
kitten = CatClass('Unnamed kitten', 'male')
return kitten

</pre>

Example code - Inheritance issues

2026-03-19T17:30:57Z

WikiSysop:

Example code - Inheritance issues

2026-03-19T17:05:24Z

WikiSysop:

Example code - Inheritance issues

2026-03-19T16:49:52Z

WikiSysop:

Example code - Inheritance issues

2026-03-19T16:37:13Z

WikiSysop:

Example code - Inheritance issues

2026-03-19T16:26:33Z

WikiSysop:

Example code - Inheritance issues

2026-03-19T16:07:22Z

WikiSysop: Created page with "The challenges in inheritance can not be demonstrated well in a powerpoint. Thus, I made this page with examples. You can copy the code in the section and add it together and run it. First I create a slightly bigger CatClass. <pre> class CatClass: ### Class variables genus = "Felis" species = "Catus" acts = {'scratch': "purrs", 'scare': "jumps high in the air", 'feed': "is very excited" } ### Instatiation def __init__(sel..."

Intermediate classes

2026-03-19T16:00:12Z

WikiSysop: /* Required course material for the lesson */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Beginning classes]]
|Next: [[Beginning unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_07-Classes.ppt Classes] 
Resource: [[Example code - Inheritance issues]] 

== Subjects covered ==
Magic methods in classes 
Object Oriented Programming 
Polymorphism and inheritance 
Practical knowledge

== Exercises to be handed in ==
The first four exercises will continue with the '''Fasta''' class from last time.
# Use magic methods to add ''iteration'' and ''length'' evaluation (using '''__iter__''' and '''__len__''' magic methods) to the '''Fasta''' class. Do this so you can write code like <div style="font-family:'Courier New'">if len(MyFastaInstance) > 0:     for header, sequence in MyFastaInstance:         # Do something with header and sequence         print(header, sequence)</div>The function '''len''' returns the number of sequences. 
# Add the methods '''deletethis()''', '''insertthis(header, sequence)''', '''verifythis(alphabet)''' and '''discardthis(alphabet)''' to the '''Fasta''' class. The methods should only work when ''iterating over an instance at the current item'', i.e. they work when you are iterating over the fasta sequences on the ''current'' sequence and header, like this:<div style="font-family:'Courier New'">for header, sequence in MyFastaInstance:     if not MyFastaInstance.verifythis("DNA"):         MyFastaInstance.deletethis()         continue     # Do something with header and sequence</div>As some may remember, it is normally impossible to successfully iterate straightforward through a list and delete and/or add elements to the list during the iteration. You have to make this possible. Hint: change the way your iteration works in the previous exercise. You need to take a position on this issue: When iterating over entries, how should you continue after inserting entries at your current position? Example: You are at element in position 5, you insert 2 elements at that position. This WILL mean the new elements are at position 5 and 6, and the one you "looked at" is now on position 7. Do you continue the iteration on position 5 or is the next position 8? My opinion is that you should not look at the new elements and you have already looked at the "old" element ant 5, so the next one is at 8. You are free to make your own decision - just be clear about it. 
# Let's do something natural. Make it possible to add one FastaInstance to another using the '''+=''' operator, like this:<div style="font-family:'Courier New'">FastaInstance1 += FastaInstance2 </div>The headers and sequences in Fastainstance2 should be added (list extension) to the headers and sequences in FastaInstance1. Use the magic method [https://zetcode.com/python/dunder-iadd/ '''__iadd__''']. Try with the files ''dna7.fsa'' and ''protein.fsa''. That will be a strange DNA and protein mix, but it is a great opportunity to use the '''discard''' method to get rid of one of the types. 
# Implement the ''addition'', using [https://zetcode.com/python/dunder-add/ '''__add__''']. Addition creates a new Fasta instance, but leaves the originals untouched.<div style="font-family:'Courier New'">FastaInstance3 = FastaInstance1 + FastaInstance2 </div>The resulting Fasta object must contain the headers and sequences from FastaInstance1 and FastaInstance2 in that order. Note that this works as an alternative constructor. Now that the Fasta class is done, save it in a file, so you can import it for the next exercises. 
# You can consider a '''Fasta''' instance as a ''set'' of headers/sequences. The sequences are obviously uniquely identified by the identifier in the header, which is what will be used as key in the set operations. In the rest of the exercises we will explore inheritance by making a new class called '''FastaSet''', which inherits from the '''Fasta''' class. A) The original '''__init__''', '''save''', '''load''', '''insert''', the iteration and the corresponding '''deletethis''', '''insertthis''', '''verifythis''' and '''discardthis''' methods are fine to keep in the new class (meaning do nothing about them). B) To help in the new class create a new getter method '''identifiers''', which returns a list of identifiers from the header lines. C) Override the '''content''' method such that it takes a set or list of identifiers and returns only the headers/sequences that corresponds to the identifiers in the list. If you do not specify a list/set of identifiers, it still returns all. D) Override the '''delete''' method in a similar way - it deletes the headers/sequences that corresponds to the input. E) Override the '''verify''' method in a similar way to '''content''' - it verifies the headers/sequences that corresponds to the input. F) Override the '''discard''' method in a similar way to '''content''' - it discards the headers/sequences that corresponds to the input. 
# As the new FastaSet class is set orientated, implement the following set operations in the class: A) union, operator is '''|''', magic method is '''__or__'''. B) intersection, operator is '''&''', magic method is '''__and__'''. C) difference, operator is '''-''', magic method is '''__sub__'''. D) symmetric difference, operator is '''^''', magic method is '''__xor__'''. These are quite similar to the addition in exercise 4 - the operators are used in the same way and a new Fasta object is returned. The identity of the sequence depends on the identifier in the corresponding header. This is an example of operator overloading - the normal arithmetic operator used on numbers are used on something completely different.

== Exercises for extra practice ==
# You continue to add the unique identifier control for all methods in Fasta and FastaSet, as mentioned last week.

Intermediate classes

2026-03-18T22:06:42Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Beginning classes]]
|Next: [[Beginning unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_07-Classes.ppt Classes] 
Resource: [[Example code - Classes]] 

== Subjects covered ==
Magic methods in classes 
Object Oriented Programming 
Polymorphism and inheritance 
Practical knowledge

== Exercises to be handed in ==
The first four exercises will continue with the '''Fasta''' class from last time.
# Use magic methods to add ''iteration'' and ''length'' evaluation (using '''__iter__''' and '''__len__''' magic methods) to the '''Fasta''' class. Do this so you can write code like <div style="font-family:'Courier New'">if len(MyFastaInstance) > 0:     for header, sequence in MyFastaInstance:         # Do something with header and sequence         print(header, sequence)</div>The function '''len''' returns the number of sequences. 
# Add the methods '''deletethis()''', '''insertthis(header, sequence)''', '''verifythis(alphabet)''' and '''discardthis(alphabet)''' to the '''Fasta''' class. The methods should only work when ''iterating over an instance at the current item'', i.e. they work when you are iterating over the fasta sequences on the ''current'' sequence and header, like this:<div style="font-family:'Courier New'">for header, sequence in MyFastaInstance:     if not MyFastaInstance.verifythis("DNA"):         MyFastaInstance.deletethis()         continue     # Do something with header and sequence</div>As some may remember, it is normally impossible to successfully iterate straightforward through a list and delete and/or add elements to the list during the iteration. You have to make this possible. Hint: change the way your iteration works in the previous exercise. You need to take a position on this issue: When iterating over entries, how should you continue after inserting entries at your current position? Example: You are at element in position 5, you insert 2 elements at that position. This WILL mean the new elements are at position 5 and 6, and the one you "looked at" is now on position 7. Do you continue the iteration on position 5 or is the next position 8? My opinion is that you should not look at the new elements and you have already looked at the "old" element ant 5, so the next one is at 8. You are free to make your own decision - just be clear about it. 
# Let's do something natural. Make it possible to add one FastaInstance to another using the '''+=''' operator, like this:<div style="font-family:'Courier New'">FastaInstance1 += FastaInstance2 </div>The headers and sequences in Fastainstance2 should be added (list extension) to the headers and sequences in FastaInstance1. Use the magic method [https://zetcode.com/python/dunder-iadd/ '''__iadd__''']. Try with the files ''dna7.fsa'' and ''protein.fsa''. That will be a strange DNA and protein mix, but it is a great opportunity to use the '''discard''' method to get rid of one of the types. 
# Implement the ''addition'', using [https://zetcode.com/python/dunder-add/ '''__add__''']. Addition creates a new Fasta instance, but leaves the originals untouched.<div style="font-family:'Courier New'">FastaInstance3 = FastaInstance1 + FastaInstance2 </div>The resulting Fasta object must contain the headers and sequences from FastaInstance1 and FastaInstance2 in that order. Note that this works as an alternative constructor. Now that the Fasta class is done, save it in a file, so you can import it for the next exercises. 
# You can consider a '''Fasta''' instance as a ''set'' of headers/sequences. The sequences are obviously uniquely identified by the identifier in the header, which is what will be used as key in the set operations. In the rest of the exercises we will explore inheritance by making a new class called '''FastaSet''', which inherits from the '''Fasta''' class. A) The original '''__init__''', '''save''', '''load''', '''insert''', the iteration and the corresponding '''deletethis''', '''insertthis''', '''verifythis''' and '''discardthis''' methods are fine to keep in the new class (meaning do nothing about them). B) To help in the new class create a new getter method '''identifiers''', which returns a list of identifiers from the header lines. C) Override the '''content''' method such that it takes a set or list of identifiers and returns only the headers/sequences that corresponds to the identifiers in the list. If you do not specify a list/set of identifiers, it still returns all. D) Override the '''delete''' method in a similar way - it deletes the headers/sequences that corresponds to the input. E) Override the '''verify''' method in a similar way to '''content''' - it verifies the headers/sequences that corresponds to the input. F) Override the '''discard''' method in a similar way to '''content''' - it discards the headers/sequences that corresponds to the input. 
# As the new FastaSet class is set orientated, implement the following set operations in the class: A) union, operator is '''|''', magic method is '''__or__'''. B) intersection, operator is '''&''', magic method is '''__and__'''. C) difference, operator is '''-''', magic method is '''__sub__'''. D) symmetric difference, operator is '''^''', magic method is '''__xor__'''. These are quite similar to the addition in exercise 4 - the operators are used in the same way and a new Fasta object is returned. The identity of the sequence depends on the identifier in the corresponding header. This is an example of operator overloading - the normal arithmetic operator used on numbers are used on something completely different.

== Exercises for extra practice ==
# You continue to add the unique identifier control for all methods in Fasta and FastaSet, as mentioned last week.

Collection of files

2026-03-18T16:49:27Z

WikiSysop: /* Files used in various exercises */

__NOTOC__
Last updated: February 2, 2023
== Files used in various exercises ==
To download the files to your system, just press the Shift key while you left click on the blue link. Follow the instructions. 
You can play around with these files as much as you like. If you change or destroy them, just download them again. 
Put the files in your course folder on your computer. 

=== Individual files ===
[https://teaching.healthtech.dtu.dk/material/22118/ex1.acc ex1.acc] 
[https://teaching.healthtech.dtu.dk/material/22118/ex1.dat ex1.dat] 
[https://teaching.healthtech.dtu.dk/material/22118/orphans.sp orphans.sp] 
[https://teaching.healthtech.dtu.dk/material/22118/scores.txt scores.txt] 
[https://teaching.healthtech.dtu.dk/material/22118/negative_list.txt negative_list.txt] 
[https://teaching.healthtech.dtu.dk/material/22118/translation.txt translation.txt] 
[https://teaching.healthtech.dtu.dk/material/22118/dna7.fsa dna7.fsa] 
[https://teaching.healthtech.dtu.dk/material/22118/employee-data.csv employee-data.csv] 
[https://teaching.healthtech.dtu.dk/material/22118/mat1.dat mat1.dat] 
[https://teaching.healthtech.dtu.dk/material/22118/mat2.dat mat2.dat] 
[https://teaching.healthtech.dtu.dk/material/22118/dna-array.dat dna-array.dat] 
[https://teaching.healthtech.dtu.dk/material/22118/dna-array-norm.dat dna-array-norm.dat] 
[https://teaching.healthtech.dtu.dk/material/22118/lineartransform.dat lineartransform.dat] 
[https://teaching.healthtech.dtu.dk/material/22118/dnanoise.fsa dnanoise.fsa] 
[https://teaching.healthtech.dtu.dk/material/22118/protein.fsa protein.fsa]

Intermediate classes

2026-03-18T16:47:37Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Beginning classes]]
|Next: [[Beginning unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_07-Classes.ppt Classes] 
Resource: [[Example code - Classes]] 

== Subjects covered ==
Magic methods in classes 
Object Oriented Programming 
Polymorphism and inheritance 
Practical knowledge

== Exercises to be handed in ==
The first four exercises will continue with the '''Fasta''' class from last time.
# Use magic methods to add ''iteration'' and ''length'' evaluation (using '''__iter__''' and '''__len__''' magic methods) to the '''Fasta''' class. Do this so you can write code like <div style="font-family:'Courier New'">if len(MyFastaInstance) > 0:     for header, sequence in MyFastaInstance:         # Do something with header and sequence         print(header, sequence)</div>The function '''len''' returns the number of sequences. 
# Add the methods '''deletethis()''', '''insertthis(header, sequence)''', '''verifythis(alphabet)''' and '''discardthis(alphabet)''' to the '''Fasta''' class. The methods should only work when ''iterating over an instance at the current item'', i.e. they work when you are iterating over the fasta sequences on the ''current'' sequence and header, like this:<div style="font-family:'Courier New'">for header, sequence in MyFastaInstance:     if not MyFastaInstance.verifythis("DNA"):         MyFastaInstance.deletethis()         continue     # Do something with header and sequence</div>As some may remember, it is normally impossible to successfully iterate straightforward through a list and delete and/or add elements to the list during the iteration. You have to make this possible. Hint: change the way your iteration works in the previous exercise. You need to take a position on this issue: When iterating over entries, how should you continue after inserting entries at your current position? Example: You are at element in position 5, you insert 2 elements at that position. This WILL mean the new elements are at position 5 and 6, and the one you "looked at" is now on position 7. Do you continue the iteration on position 5 or is the next position 8? My opinion is that you should not look at the new elements and you have already looked at the "old" element ant 5, so the next one is at 8. You are free to make your own decision - just be clear about it. 
# Let's do something natural. Make it possible to add one FastaInstance to another using the '''+=''' operator, like this:<div style="font-family:'Courier New'">FastaInstance1 += FastaInstance2 </div>The headers and sequences in Fastainstance2 should be added (list extension) to the headers and sequences in FastaInstance1. Use the magic method [https://zetcode.com/python/dunder-iadd/ '''__iadd__''']. Try with the files ''dna7.fsa'' and ''protein.fsa''. That will be a strange DNA and protein mix, but it is a great opportunity to use the '''discard''' method to get rid of one of the types. 
# Implement the ''addition'', using [https://zetcode.com/python/dunder-add/ '''__add__''']. Addition creates a new Fasta instance, but leaves the originals untouched.<div style="font-family:'Courier New'">FastaInstance3 = FastaInstance1 + FastaInstance2 </div>The resulting Fasta object must contain the headers and sequences from FastaInstance1 and FastaInstance2 in that order. Note that this works as an alternative constructor. Now that the Fasta class is done, save it in a file, so you can import it for the next exercises. 
# You can consider a '''Fasta''' instance as a ''set'' of headers/sequences. The sequences are obviously uniquely identified by the identifier in the header, which is what will be used as key in the set operations. In the rest of the exercises we will explore inheritance by making a new class called '''FastaSet''', which inherits from the '''Fasta''' class. A) The original '''__init__''', '''save''', '''load''', '''insert''', the iteration and the corresponding '''deletethis''', '''insertthis''', '''verifythis''' and '''discardthis''' methods are fine to keep in the new class (meaning do nothing about them). B) To help in the new class create a new getter method '''identifiers''', which returns a list of identifiers from the header lines. C) Override the '''content''' method such that it takes a set or list of identifiers and returns only the headers/sequences that corresponds to the identifiers in the list. If you do not specify a list/set of identifiers, it still returns all. D) Override the '''delete''' method in a similar way - it deletes the headers/sequences that corresponds to the input. E) Override the '''verify''' method in a similar way to '''content''' - it verifies the headers/sequences that corresponds to the input. F) Override the '''discard''' method in a similar way to '''content''' - it discards the headers/sequences that corresponds to the input. 
# As the new FastaSet class is set orientated, implement the following set operations in the class: A) union, operator is '''|''', magic method is '''__or__'''. B) intersection, operator is '''&''', magic method is '''__and__'''. C) difference, operator is '''-''', magic method is '''__sub__'''. D) symmetric difference, operator is '''^''', magic method is '''__xor__'''. These are quite similar to the addition in exercise 4 - the operators are used in the same way and a new Fasta object is returned. The identity of the sequence depends on the identifier in the corresponding header. This is an example of operator overloading.

== Exercises for extra practice ==
# You continue to add the unique identifier control for all methods in Fasta and FastaSet, as mentioned last week.

Collection of files

2026-03-18T16:25:44Z

WikiSysop: /* Individual files */

__NOTOC__
Last updated: February 2, 2023
== Files used in various exercises ==
To download the files to your system, just press the Shift key while you left click on the blue link. Follow the instructions. 
You can play around with these files as much as you like. If you change or destroy them, just download them again. 
Put the files in your course folder on your computer. 

=== Individual files ===
[https://teaching.healthtech.dtu.dk/material/22118/ex1.acc ex1.acc] 
[https://teaching.healthtech.dtu.dk/material/22118/ex1.dat ex1.dat] 
[https://teaching.healthtech.dtu.dk/material/22118/orphans.sp orphans.sp] 
[https://teaching.healthtech.dtu.dk/material/22118/scores.txt scores.txt] 
[https://teaching.healthtech.dtu.dk/material/22118/negative_list.txt negative_list.txt] 
[https://teaching.healthtech.dtu.dk/material/22118/translation.txt translation.txt] 
[https://teaching.healthtech.dtu.dk/material/22118/dna7.fsa dna7.fsa] 
[https://teaching.healthtech.dtu.dk/material/22118/employee-data.csv employee-data.csv] 
[https://teaching.healthtech.dtu.dk/material/22118/mat1.dat mat1.dat] 
[https://teaching.healthtech.dtu.dk/material/22118/mat2.dat mat2.dat] 
[https://teaching.healthtech.dtu.dk/material/22118/dna-array.dat dna-array.dat] 
[https://teaching.healthtech.dtu.dk/material/22118/dna-array-norm.dat dna-array-norm.dat] 
[https://teaching.healthtech.dtu.dk/material/22118/lineartransform.dat lineartransform.dat] 
[https://teaching.healthtech.dtu.dk/material/22118/dnanoise.fsa dnanoise.fsa]

Intermediate classes

2026-03-18T14:59:54Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Beginning classes]]
|Next: [[Beginning unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_07-Classes.ppt Classes] 
Resource: [[Example code - Classes]] 

== Subjects covered ==
Magic methods in classes 
Object Oriented Programming 
Polymorphism and inheritance 
Practical knowledge

== Exercises to be handed in ==
The first four exercises will continue with the '''Fasta''' class from last time.
# Use magic methods to add ''iteration'' and ''length'' evaluation (using '''__iter__''' and '''__len__''' magic methods) to the '''Fasta''' class. Do this so you can write code like <div style="font-family:'Courier New'">if len(MyFastaInstance) > 0:     for header, sequence in MyFastaInstance:         # Do something with header and sequence         print(header, sequence)</div>The function '''len''' returns the number of sequences. 
# Add the methods '''deletethis()''', '''insertthis(header, sequence)''', '''verifythis(alphabet)''' and '''discardthis(alphabet)''' to the '''Fasta''' class. The methods should only work when ''iterating over an instance at the current item'', i.e. they work when you are iterating over the fasta sequences on the ''current'' sequence and header, like this:<div style="font-family:'Courier New'">for header, sequence in MyFastaInstance:     if not MyFastaInstance.verifythis("DNA"):         MyFastaInstance.deletethis()         continue     # Do something with header and sequence</div>As some may remember, it is normally impossible to successfully iterate straightforward through a list and delete and/or add elements to the list during the iteration. You have to make this possible. Hint: change the way your iteration works in the previous exercise. You need to take a position on this issue: When iterating over entries, how should you continue after inserting entries at your current position? Example: You are at element in position 5, you insert 2 elements at that position. This WILL mean the new elements are at position 5 and 6, and the one you "looked at" is now on position 7. Do you continue the iteration on position 5 or is the next position 8? My opinion is that you should not look at the new elements and you have already looked at the "old" element ant 5, so the next one is at 8. You are free to make your own decision - just be clear about it. 
# Let's do something natural. Make it possible to add one FastaInstance to another using the '''+=''' operator, like this:<div style="font-family:'Courier New'">FastaInstance1 += FastaInstance2 </div>The headers and sequences in Fastainstance2 should be added (list extension) to the headers and sequences in FastaInstance1. Use the magic method [https://zetcode.com/python/dunder-iadd/ '''__iadd__''']. 
# Implement the ''addition'', using [https://zetcode.com/python/dunder-add/ '''__add__''']. Addition creates a new Fasta instance, but leaves the originals untouched.<div style="font-family:'Courier New'">FastaInstance3 = FastaInstance1 + FastaInstance2 </div>The resulting Fasta object must contain the headers and sequences from FastaInstance1 and FastaInstance2 in that order. Note that this works as an alternative constructor. Now that the Fasta class is done, save it in a file, so you can import it for the next exercises. 
# You can consider a '''Fasta''' instance as a ''set'' of headers/sequences. The sequences are obviously uniquely identified by the identifier in the header, which is what will be used as key in the set operations. In the rest of the exercises we will explore inheritance by making a new class called '''FastaSet''', which inherits from the '''Fasta''' class. A) The original '''__init__''', '''save''', '''load''', '''insert''', the iteration and the corresponding '''deletethis''', '''insertthis''', '''verifythis''' and '''discardthis''' methods are fine to keep in the new class (meaning do nothing about them). B) To help in the new class create a new getter method '''identifiers''', which returns a list of identifiers from the header lines. C) Override the '''content''' method such that it takes a set or list of identifiers and returns only the headers/sequences that corresponds to the identifiers in the list. If you do not specify a list/set of identifiers, it still returns all. D) Override the '''delete''' method in a similar way - it deletes the headers/sequences that corresponds to the input. E) Override the '''verify''' method in a similar way to '''content''' - it verifies the headers/sequences that corresponds to the input. F) Override the '''discard''' method in a similar way to '''content''' - it discards the headers/sequences that corresponds to the input. 
# As the new FastaSet class is set orientated, implement the following set operations in the class: A) union, operator is '''|''', magic method is '''__or__'''. B) intersection, operator is '''&''', magic method is '''__and__'''. C) difference, operator is '''-''', magic method is '''__sub__'''. D) symmetric difference, operator is '''^''', magic method is '''__xor__'''. These are quite similar to the addition in exercise 4 - the operators are used in the same way and a new Fasta object is returned. The identity of the sequence depends on the identifier in the corresponding header. This is an example of operator overloading.

== Exercises for extra practice ==
# You continue to add the unique identifier control for all methods in Fasta and FastaSet, as mentioned last week.

Intermediate classes

2026-03-18T14:59:31Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Beginning classes]]
|Next: [[Beginning unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_07-Classes.ppt Classes] 
Resource: [[Example code - Classes]] 

== Subjects covered ==
Magic methods in classes 
Object Oriented Programming 
Polymorphism and inheritance 
Practical knowledge

== Exercises to be handed in ==
The first four exercises will continue with the '''Fasta''' class from last time.
# Use magic methods to add ''iteration'' and ''length'' evaluation (using '''__iter__''' and '''__len__''' magic methods) to the '''Fasta''' class. Do this so you can write code like <div style="font-family:'Courier New'">if len(MyFastaInstance) > 0:     for header, sequence in MyFastaInstance:         # Do something with header and sequence         print(header, sequence)</div>The function '''len''' returns the number of sequences. 
# Add the methods '''deletethis()''', '''insertthis(header, sequence)''', '''verifythis(alphabet)''' and '''discardthis(alphabet)''' to the '''Fasta''' class. The methods should only work when ''iterating over an instance at the current item'', i.e. they work when you are iterating over the fasta sequences on the ''current'' sequence and header, like this:<div style="font-family:'Courier New'">for header, sequence in MyFastaInstance:     if not MyFastaInstance.verifythis("DNA"):         MyFastaInstance.deletethis()         continue     # Do something with header and sequence</div>As some may remember, it is normally impossible to successfully iterate straightforward through a list and delete and/or add elements to the list during the iteration. You have to make this possible. Hint: change the way your iteration works in the previous exercise. You need to take a position on this issue: When iteration over entries, how should you continue after inserting entries at your current position? Example: You are at element in position 5, you insert 2 elements at that position. This WILL mean the new elements are at position 5 and 6, and the one you "looked at" is now on position 7. Do you continue the iteration on position 5 or is the next position 8? My opinion is that you should not look at the new elements and you have already looked at the "old" element ant 5, so the next one is at 8. You are free to make your own decision - just be clear about it. 
# Let's do something natural. Make it possible to add one FastaInstance to another using the '''+=''' operator, like this:<div style="font-family:'Courier New'">FastaInstance1 += FastaInstance2 </div>The headers and sequences in Fastainstance2 should be added (list extension) to the headers and sequences in FastaInstance1. Use the magic method [https://zetcode.com/python/dunder-iadd/ '''__iadd__''']. 
# Implement the ''addition'', using [https://zetcode.com/python/dunder-add/ '''__add__''']. Addition creates a new Fasta instance, but leaves the originals untouched.<div style="font-family:'Courier New'">FastaInstance3 = FastaInstance1 + FastaInstance2 </div>The resulting Fasta object must contain the headers and sequences from FastaInstance1 and FastaInstance2 in that order. Note that this works as an alternative constructor. Now that the Fasta class is done, save it in a file, so you can import it for the next exercises. 
# You can consider a '''Fasta''' instance as a ''set'' of headers/sequences. The sequences are obviously uniquely identified by the identifier in the header, which is what will be used as key in the set operations. In the rest of the exercises we will explore inheritance by making a new class called '''FastaSet''', which inherits from the '''Fasta''' class. A) The original '''__init__''', '''save''', '''load''', '''insert''', the iteration and the corresponding '''deletethis''', '''insertthis''', '''verifythis''' and '''discardthis''' methods are fine to keep in the new class (meaning do nothing about them). B) To help in the new class create a new getter method '''identifiers''', which returns a list of identifiers from the header lines. C) Override the '''content''' method such that it takes a set or list of identifiers and returns only the headers/sequences that corresponds to the identifiers in the list. If you do not specify a list/set of identifiers, it still returns all. D) Override the '''delete''' method in a similar way - it deletes the headers/sequences that corresponds to the input. E) Override the '''verify''' method in a similar way to '''content''' - it verifies the headers/sequences that corresponds to the input. F) Override the '''discard''' method in a similar way to '''content''' - it discards the headers/sequences that corresponds to the input. 
# As the new FastaSet class is set orientated, implement the following set operations in the class: A) union, operator is '''|''', magic method is '''__or__'''. B) intersection, operator is '''&''', magic method is '''__and__'''. C) difference, operator is '''-''', magic method is '''__sub__'''. D) symmetric difference, operator is '''^''', magic method is '''__xor__'''. These are quite similar to the addition in exercise 4 - the operators are used in the same way and a new Fasta object is returned. The identity of the sequence depends on the identifier in the corresponding header. This is an example of operator overloading.

== Exercises for extra practice ==
# You continue to add the unique identifier control for all methods in Fasta and FastaSet, as mentioned last week.

Intermediate classes

2026-03-18T09:06:30Z

WikiSysop: /* Exercises for extra practice */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Beginning classes]]
|Next: [[Beginning unit test]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_07-Classes.ppt Classes] 
Resource: [[Example code - Classes]] 

== Subjects covered ==
Magic methods in classes 
Object Oriented Programming 
Polymorphism and inheritance 
Practical knowledge

== Exercises to be handed in ==
The first four exercises will continue with the '''Fasta''' class from last time.
# Use magic methods to add ''iteration'' and ''length'' evaluation (using '''__iter__''' and '''__len__''' magic methods) to the '''Fasta''' class. Do this so you can write code like <div style="font-family:'Courier New'">if len(MyFastaInstance) > 0:     for header, sequence in MyFastaInstance:         # Do something with header and sequence         print(header, sequence)</div>The function '''len''' returns the number of sequences. 
# Add the methods '''deletethis()''', '''insertthis(header, sequence)''', '''verifythis(alphabet)''' and '''discardthis(alphabet)''' to the '''Fasta''' class. The methods should only work when ''iterating over an instance at the current item'', i.e. they work when you are iterating over the fasta sequences on the ''current'' sequence and header, like this:<div style="font-family:'Courier New'">for header, sequence in MyFastaInstance:     if not MyFastaInstance.verifythis("DNA"):         MyFastaInstance.deletethis()         continue     # Do something with header and sequence</div>As some may remember, it is normally impossible to successfully iterate straightforward through a list and delete and/or add elements to the list during the iteration. You have to make this possible. Hint: change the way your iteration works in the previous exercise. 
# Let's do something natural. Make it possible to add one FastaInstance to another using the '''+=''' operator, like this:<div style="font-family:'Courier New'">FastaInstance1 += FastaInstance2 </div>The headers and sequences in Fastainstance2 should be added (list extension) to the headers and sequences in FastaInstance1. Use the magic method [https://zetcode.com/python/dunder-iadd/ '''__iadd__''']. 
# Implement the ''addition'', using [https://zetcode.com/python/dunder-add/ '''__add__''']. Addition creates a new Fasta instance, but leaves the originals untouched.<div style="font-family:'Courier New'">FastaInstance3 = FastaInstance1 + FastaInstance2 </div>The resulting Fasta object must contain the headers and sequences from FastaInstance1 and FastaInstance2 in that order. Note that this works as an alternative constructor. Now that the Fasta class is done, save it in a file, so you can import it for the next exercises. 
# You can consider a '''Fasta''' instance as a ''set'' of headers/sequences. The sequences are obviously uniquely identified by the identifier in the header, which is what will be used as key in the set operations. In the rest of the exercises we will explore inheritance by making a new class called '''FastaSet''', which inherits from the '''Fasta''' class. A) The original '''__init__''', '''save''', '''load''', '''insert''', the iteration and the corresponding '''deletethis''', '''insertthis''', '''verifythis''' and '''discardthis''' methods are fine to keep in the new class (meaning do nothing about them). B) To help in the new class create a new getter method '''identifiers''', which returns a list of identifiers from the header lines. C) Override the '''content''' method such that it takes a set or list of identifiers and returns only the headers/sequences that corresponds to the identifiers in the list. If you do not specify a list/set of identifiers, it still returns all. D) Override the '''delete''' method in a similar way - it deletes the headers/sequences that corresponds to the input. E) Override the '''verify''' method in a similar way to '''content''' - it verifies the headers/sequences that corresponds to the input. F) Override the '''discard''' method in a similar way to '''content''' - it discards the headers/sequences that corresponds to the input. 
# As the new FastaSet class is set orientated, implement the following set operations in the class: A) union, operator is '''|''', magic method is '''__or__'''. B) intersection, operator is '''&''', magic method is '''__and__'''. C) difference, operator is '''-''', magic method is '''__sub__'''. D) symmetric difference, operator is '''^''', magic method is '''__xor__'''. These are quite similar to the addition in exercise 4 - the operators are used in the same way and a new Fasta object is returned. The identity of the sequence depends on the identifier in the corresponding header. This is an example of operator overloading.

== Exercises for extra practice ==
# You continue to add the unique identifier control for all methods in Fasta and FastaSet, as mentioned last week.

Beginning classes

2026-03-18T09:04:12Z

WikiSysop: /* Exercises for extra practice */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Comprehension, generators, iteration]]
|Next: [[Intermediate classes]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_07-Decorators.ppt Decorators] 
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_07-Classes.ppt Classes] 
Resource: [[Example code - Classes]] 

== Subjects covered ==
Overview and motivation for classes 
Class structure 
Creating simple classes 

== Exercises to be handed in ==
The first two exercises are about simple math functions, just to get used to making a class. Remember to add code outside the class (man program), which test the new methods you make as you make them. 
The last exercises will be about the making of a fasta file handling class. As the exercises goes on the class can do more and more. The class methods need some decent input control and you need to think about what is required. Notice how versatile the class becomes, as you progress through the exercises.
# Create a class called '''MyMath'''. Add the following methods; '''cube''' which raises the input number to the power of 3 and returns it, '''factorial''' which computes the factorial of the input integer and returns it, '''collatz_steps''' takes a positive integer and repeatedly solves [https://en.wikipedia.org/wiki/Collatz_conjecture Collatz conjecture] until 1 is reached and returns how many steps/iterations of the collatz function it took. It takes 350 steps for the number 77031. 
# In your '''MyMath''' class, add a method to supply a list of numbers to an instance of the class. Now make the methods '''maximum''', '''minimum''' and '''average''' that returns the obvious result from the list. <div style="font-family:'Courier New'">mm = MyMath() mm.supply(mylist) print('Max is', mm.maximum())</div> 
# Create a class called '''Fasta'''. The purpose of the class is to do various kinds of manipulation of fasta files and sequences. Start with adding 3 methods to the class: '''load(filename)''', which gets a file name/path and loads the fasta file into internal instance lists with header and sequence. '''save(filename)''', which writes the internal instance header/sequence lists into a fasta file. '''content()''', which returns two lists; the headers and the sequences. You can likely reuse part of your functions in exercise 1 and 2 from [[Functions, namespace, memory_management]]. Example use of the Fasta class: <div style="font-family:'Courier New'">myfasta = Fasta() myfasta.load("dna7.fsa") print(myfasta.content()) myfasta.save("newfile.fsa")</div> You can consider modifying the '''__init__''' so if you supply a filename, it calls the '''load''' method automatically. 
# Add a method '''delete([start[,end]])''', which deletes entries in the headers and sequences. If called with no arguments like '''delete()''' it deletes all headers/sequences. If called with one argument like '''delete(start)''' it deletes the header and sequence at position ''start''. If called with two arguments, it deletes headers and sequences from position ''start'' up to but not including position ''end''. ''start'' and ''end'' can also be negative numbers, and in such case we count from the end of the lists, just like it works in normal list manipulations. 
# Modify the '''content()''' method, so it works similar to '''delete()'''. If called with no arguments like '''content()''' it returns 2 lists with all headers and sequences. If called with one argument like '''content(start)''' it returns the header and sequence at position ''start''. If called with two arguments, it returns the headers and sequences from position ''start'' up to but not including position ''end'' as two lists. Be careful that you return a copy of the lists and not the lists themselves as then the headers and sequences in the instance can be modified unintended outside the instance. 
# Add a method '''insert(header,sequence[,position])''', which adds header and sequence to the instance lists. ''header'' and ''sequence'' can either be simple strings (single header and sequence) or lists of headers and sequences. If ''position'' is not given, then the addition takes place at the end of the existing headers/sequences. If ''position'' is given then insertion takes places at that position. 
# Add a method '''verify(alphabet,[start[,end]])''', which verifies sequence entries according to an alphabet. It works in a way similar to '''delete()''' and '''content()''' for the range of what should be verified. The method returns True if all entries in the range are verified (belonging to the alphabet), False otherwise. The alphabet could be a DNA alphabet (ATCG), a protein alphabet or something derived from those. You should put your alphabets into class variables, as they are common for all instances, and not subject to change. Think about generalizing this exercise; You could have short names for your alphabet, you could make methods that could dynamically increase the number of alphabets the class handle. After all, an alphabet is just certain chars that your method has to verify that only those are present in the sequence. You can have any number of alphabets, and the verification method is still the same. Try on ''dnanoise.fsa''. 
# Add a method '''discard(alphabet,[start[,end]])''', which discards sequence entries and corresponding headers if they do not match the given alphabet. It works in a way similar to '''delete()''' and '''content()''' for the range of what should be verified. Try on ''dnanoise.fsa''. 

== Exercises for extra practice ==
# The Fasta class exercises all have one thing in common, that has not been addressed: The identifiers on the header line in a fasta file HAVE TO BE UNIQUE within the file - that is why they are identifiers. That also goes for the lists of headers/sequences in the Fasta class. The extra work you do here is to make sure this unique property of the identifiers are upheld whenever you add header/sequences to the Fasta object. This is only relevant upon '''load''' and '''insert'''ion. Observation: When you delete unique headers/sequences from a Fasta object, the leftovers will still be unique.

Beginning classes

2026-03-18T09:00:15Z

WikiSysop: /* Exercises for extra practice */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Comprehension, generators, iteration]]
|Next: [[Intermediate classes]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_07-Decorators.ppt Decorators] 
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22118/22118_07-Classes.ppt Classes] 
Resource: [[Example code - Classes]] 

== Subjects covered ==
Overview and motivation for classes 
Class structure 
Creating simple classes 

== Exercises to be handed in ==
The first two exercises are about simple math functions, just to get used to making a class. Remember to add code outside the class (man program), which test the new methods you make as you make them. 
The last exercises will be about the making of a fasta file handling class. As the exercises goes on the class can do more and more. The class methods need some decent input control and you need to think about what is required. Notice how versatile the class becomes, as you progress through the exercises.
# Create a class called '''MyMath'''. Add the following methods; '''cube''' which raises the input number to the power of 3 and returns it, '''factorial''' which computes the factorial of the input integer and returns it, '''collatz_steps''' takes a positive integer and repeatedly solves [https://en.wikipedia.org/wiki/Collatz_conjecture Collatz conjecture] until 1 is reached and returns how many steps/iterations of the collatz function it took. It takes 350 steps for the number 77031. 
# In your '''MyMath''' class, add a method to supply a list of numbers to an instance of the class. Now make the methods '''maximum''', '''minimum''' and '''average''' that returns the obvious result from the list. <div style="font-family:'Courier New'">mm = MyMath() mm.supply(mylist) print('Max is', mm.maximum())</div> 
# Create a class called '''Fasta'''. The purpose of the class is to do various kinds of manipulation of fasta files and sequences. Start with adding 3 methods to the class: '''load(filename)''', which gets a file name/path and loads the fasta file into internal instance lists with header and sequence. '''save(filename)''', which writes the internal instance header/sequence lists into a fasta file. '''content()''', which returns two lists; the headers and the sequences. You can likely reuse part of your functions in exercise 1 and 2 from [[Functions, namespace, memory_management]]. Example use of the Fasta class: <div style="font-family:'Courier New'">myfasta = Fasta() myfasta.load("dna7.fsa") print(myfasta.content()) myfasta.save("newfile.fsa")</div> You can consider modifying the '''__init__''' so if you supply a filename, it calls the '''load''' method automatically. 
# Add a method '''delete([start[,end]])''', which deletes entries in the headers and sequences. If called with no arguments like '''delete()''' it deletes all headers/sequences. If called with one argument like '''delete(start)''' it deletes the header and sequence at position ''start''. If called with two arguments, it deletes headers and sequences from position ''start'' up to but not including position ''end''. ''start'' and ''end'' can also be negative numbers, and in such case we count from the end of the lists, just like it works in normal list manipulations. 
# Modify the '''content()''' method, so it works similar to '''delete()'''. If called with no arguments like '''content()''' it returns 2 lists with all headers and sequences. If called with one argument like '''content(start)''' it returns the header and sequence at position ''start''. If called with two arguments, it returns the headers and sequences from position ''start'' up to but not including position ''end'' as two lists. Be careful that you return a copy of the lists and not the lists themselves as then the headers and sequences in the instance can be modified unintended outside the instance. 
# Add a method '''insert(header,sequence[,position])''', which adds header and sequence to the instance lists. ''header'' and ''sequence'' can either be simple strings (single header and sequence) or lists of headers and sequences. If ''position'' is not given, then the addition takes place at the end of the existing headers/sequences. If ''position'' is given then insertion takes places at that position. 
# Add a method '''verify(alphabet,[start[,end]])''', which verifies sequence entries according to an alphabet. It works in a way similar to '''delete()''' and '''content()''' for the range of what should be verified. The method returns True if all entries in the range are verified (belonging to the alphabet), False otherwise. The alphabet could be a DNA alphabet (ATCG), a protein alphabet or something derived from those. You should put your alphabets into class variables, as they are common for all instances, and not subject to change. Think about generalizing this exercise; You could have short names for your alphabet, you could make methods that could dynamically increase the number of alphabets the class handle. After all, an alphabet is just certain chars that your method has to verify that only those are present in the sequence. You can have any number of alphabets, and the verification method is still the same. Try on ''dnanoise.fsa''. 
# Add a method '''discard(alphabet,[start[,end]])''', which discards sequence entries and corresponding headers if they do not match the given alphabet. It works in a way similar to '''delete()''' and '''content()''' for the range of what should be verified. Try on ''dnanoise.fsa''. 

== Exercises for extra practice ==
# The Fasta class exercises all have one thing in common, that has not been addressed: The identifiers on the header line in a fasta file HAVE TO BE UNIQUE within the file - that is why they are identifiers. That also goes for the lists of headers/sequences in the Fasta class. The extra work you do here is to make sure this unique property of the identifiers are upheld whenever you add header/sequences to the Fasta object. You do not have to check this when you delete headers/sequences because if they were unique before the deletion, they will also be after.

Beginning classes

2026-03-18T08:57:44Z

WikiSysop: /* Exercises for extra practice */