22116 - User contributions [en]

How the course is conducted

2026-01-14T07:48:26Z

WikiSysop: /* Requirements for taking the course */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
There will be some hand-in time irregularity at the end of the semester, due to exams. Pay attention. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. You can only evaluate if you have handed in exercises, so the hand-in is required. 
You are required to make a Jupyter Notebook for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. Many people use VScode for this, but it is up to you. In the last part of the course, this is changed to a '''.py''' file, to get you used to how the exam will be. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
DTU Learn does not allow for late hand-in. Set an alarm on your phone to remember. 


== Requirements for taking the course ==
'''You most take this seriously. Half of the students failed the course first year it ran.''' 
This course requires that you have previously taken 5 ECTS in a beginner course in programming. DTU students have taken [https://kurser.dtu.dk/course/02002 02002 Computer Programming (Polytechnical Foundation)], however foreign Master students are more of a mixed group. This course can NOT be treated as your first real programming course - it is your second, and the difficulty of the course and exam reflects that. I have tried to make the course accessible to people with a moderate background in programming, but it is not a free ride. I have an obsolete beginner course [https://teaching.healthtech.dtu.dk/22101/ 22101 Introduction to programming in Life Science using Python] which you can learn from on your own, if your background is insufficient and you want to take this course anyway.

Using AI/ChatGPT is a bad idea. From my observations and exam results, the use of AI hinders the acquisition of "programmatic thinking". This skill is what the course is about - the core competence. When asking AI about a problem, you are usually served a solution. Even if you understand the solution, then you have not gone through the process of thinking the solution. It weakens your thinking enormously, you don't "own" the solution and you are not getting used to thinking about programming problems. This becomes a big problem at exam time, because you think you are OK, but you have not acquired the correct thinking and the exam will seem very hard. Yes, there are a number of elements in the exam that we have been going through in the course, but there are also new elements (not python elements, but logic problems) where you have to think your way through.

You can read these American studies showing how the use of AI damages your thinking:
[https://www.microsoft.com/en-us/research/wp-content/uploads/2025/01/lee_2025_ai_critical_thinking_survey.pdf The Impact of Generative AI on Critical Thinking: Self-Reported Reductions in Cognitive Effort and Confidence Effects From a Survey of Knowledge Workers] and [https://arxiv.org/abs/2506.08872 Your Brain on ChatGPT: Accumulation of Cognitive Debt when Using an AI Assistant for Essay Writing Task].

== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. 

The peer evaluation is a central part of the learning process. As you will discover, you will be asked many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out '''.py''' file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam '''.py''' file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re, math and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

=== How much is required to pass? ===
The '''.py''' file is mostly structure and does not give much advice in how to solve the assignments. It is for you to show that you have learned to analyze a programming problem and come up with a solution. As you will be given both the input files and the output files, you can check how well you have succeeded. A correct solution to both assignments is an automatic pass. A correct solution to only one assignment, without any constructive work (in my evaluation) on the other assignment is not enough for a pass. No correct solutions, but writing good sensible code (again in my evaluation) can pass, as it shows you have learned essential things in the course. Comments are part the the essential things. 
In the end, unless you passed automatically, it comes down to a overall evaluation of your hand-in.

How the course is conducted

2026-01-14T07:46:35Z

WikiSysop: /* Requirements for taking the course */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
There will be some hand-in time irregularity at the end of the semester, due to exams. Pay attention. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. You can only evaluate if you have handed in exercises, so the hand-in is required. 
You are required to make a Jupyter Notebook for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. Many people use VScode for this, but it is up to you. In the last part of the course, this is changed to a '''.py''' file, to get you used to how the exam will be. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
DTU Learn does not allow for late hand-in. Set an alarm on your phone to remember. 


== Requirements for taking the course ==
'''You most take this seriously. Half of the students failed the course first year it ran.''' 
This course requires that you have previously taken 5 ECTS in a beginner course in programming. DTU students have taken [https://kurser.dtu.dk/course/02002 02002 Computer Programming (Polytechnical Foundation)], however foreign Master students are more of a mixed group. This course can NOT be treated as your first real programming course - it is your second, and the difficulty of the course and exam reflects that. I have tried to make the course accessible to people with a moderate background in programming, but it is not a free ride. I have an obsolete beginner course [https://teaching.healthtech.dtu.dk/22101/ 22101 Introduction to programming in Life Science using Python] which you can learn from on your own, if your background is insufficient and you want to take this course anyway.

Using AI/ChatGPT is a bad idea. From my observations and exam results, the use of AI hinders the acquisition of "programmatic thinking". This skill is what the course is about - the core competence. When asking AI about a problem, you are usually served a solution. Even if you understand the solution, then you have not gone through the process of thinking the solution. It weakens your thinking enormously, you don't "own" the solution and you are not getting used to thinking about programming problems. This becomes a big problem at exam time, because you think you are OK, but you have not acquired the correct thinking and the exam will seem very hard. Yes, there are a number of elements in the exam that we have been going through in the course, but there are also new elements (not python elements, but logic problems) where you have to think your way through.

You can read these American studies showing how the use of AI damages your thinking: [https://www.microsoft.com/en-us/research/wp-content/uploads/2025/01/lee_2025_ai_critical_thinking_survey.pdf The Impact of Generative AI on Critical Thinking: Self-Reported
Reductions in Cognitive Effort and Confidence Effects From a Survey of Knowledge Workers], [https://arxiv.org/abs/2506.08872 Your Brain on ChatGPT: Accumulation of Cognitive Debt when Using an AI Assistant for Essay Writing Task].

== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. 

The peer evaluation is a central part of the learning process. As you will discover, you will be asked many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out '''.py''' file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam '''.py''' file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re, math and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

=== How much is required to pass? ===
The '''.py''' file is mostly structure and does not give much advice in how to solve the assignments. It is for you to show that you have learned to analyze a programming problem and come up with a solution. As you will be given both the input files and the output files, you can check how well you have succeeded. A correct solution to both assignments is an automatic pass. A correct solution to only one assignment, without any constructive work (in my evaluation) on the other assignment is not enough for a pass. No correct solutions, but writing good sensible code (again in my evaluation) can pass, as it shows you have learned essential things in the course. Comments are part the the essential things. 
In the end, unless you passed automatically, it comes down to a overall evaluation of your hand-in.

22116/22166 Python programming in Life Science

2025-12-22T14:54:02Z

WikiSysop:

__NOTOC__
'''Teacher:''' [https://www.inside.dtu.dk/da/dtuinside/generelt/telefonbog/person?id=816&cpid=214027&tab=2&qt=dtupublicationquery Peter Wad Sackett], pwsa@dtu.dk  
'''Language:''' The course is taught in English. 
'''Tools:''' The course is using the standard DTU python setup, see [https://pythonsupport.dtu.dk/ https://pythonsupport.dtu.dk/] if you do not have it already. 
'''Textbooks:''' I believe students should not pay at lot of money for textbooks. I will use powerpoints, videos and references to online resources. You can find the material under the individual lessons in the [[Programme]]. 
'''Location:''' Building 358, room 60b + streaming to room 046, no matter what your plan says. Course 22116 and 22166 are taught together. 
'''Time:''' Monday 13:00 - 17:00, module E2-A. 

== Course details ==
There are no plans for streaming the lectures. 

[[Programme]] Fall 2025

[https://teaching.healthtech.dtu.dk/22116/progress/ See the progress of your hand-ins]

[[How the course is conducted]] Required reading - read or fail.

[[Course Survival Guide]] Useful when you get stuck early

[[AI guidelines for the course]] You want to use AI, then you MUST read it.

[[Good code]] Always keep this in mind


== Competences ==
A general engineering competence skill is the ability to explain the process through which you obtain your results - how else can they be trusted?
Learning to program is a great way to practice that skill, since you have to explain to the computer how it is supposed to solve the task you give.
This explanation must pay attention to detail, specifically identifying and ordering the elements of the solution.
This nurtures and strengthens an analytical and structured mindset which is also an essential engineering competence skill.
Training these skills is obviously beneficial for the student, but they do not come for free - it is '''hard work''', so put the time aside for it.

== Resources ==
* Online: [https://teaching.healthtech.dtu.dk/material/22116/clean_code.html Clean Code] by Lukasz Dynowski. An amazing read that is mandatory. Read it once around lesson 5 and once more around lesson 8.
* Info: [[Biological knowledge needed in the course]]
* Online: [https://rosalind.info/problems/locations/ Rosalind project] Python exercises at different levels for practicing

* Online: [https://www.coursera.org/learn/python Coursera course: Programming for Everybody] is a beginner course in Python. Everyone who wants to prepare for course 22116/22166 can start here. Just get far enough so you understand what programming is and how it works. That will benefit you a lot as a newbie. The [https://teaching.healthtech.dtu.dk/material/22118/CourseraPythonBook_270.pdf Coursera textbook].

* Book: ''Learning Python'', 5th ed. by Mark Lutz (O'Reilly) ISBN: 978-1-449-35573-9. This is the best Python book I have read. It covers all the basics and then some. All from the perspective of being a novice programmer. However, it is a brick; big, heavy and unwieldy. If you only want one Python book, then this should be the one. The course will not be taught from this book, but it could be good to have as a Python reference manual.

* Book: ''Python Crash Course: A Hands-On, Project-Based Introduction to Programming'' by Eric Matthes (No Starch Press) ISBN: 1593276036, 9781593276034. A pretty OK book which leads you into the Python world without too many distracting points and theoretical contemplation.

* Online: [https://wiki.python.org/moin/BeginnersGuide/NonProgrammers Python for Non-Programmers]
* Online: [https://docs.python.org/3/tutorial/ Official Python 3 tutorial]
* Online: [https://docs.python.org/3/reference/index.html Python 3 reference manual]
* Online: [https://docs.python.org/3/library/index.html Python 3 standard library]

'''Videos with advice on learning how to code''' 
* Youtube: [https://www.youtube.com/watch?v=A8ldqcFS5S8 How I Would Learn To Code If I Was To Start Over] by Tiff In Tech
* Youtube: [https://www.youtube.com/watch?v=_nsV65jUPL8 Coding Was Hard Until I Learned THESE 5 Things!] by Pooja Dutt
* Youtube: [https://www.youtube.com/watch?v=MHPGeQD8TvI How I would learn to code (if I could start over)] by Tina Huang
* Youtube: [https://www.youtube.com/watch?v=To8hKb112Aw How I would learn to code (if I could start over)] by PIRATE KING
* Youtube: [https://www.youtube.com/watch?v=9s29LKfEFjQ How I would learn to code (If I could start over)] by Jason Goodison
* Youtube: [https://www.youtube.com/watch?v=NtfbWkxJTHw How to Learn to Code - 8 Hard Truths] by Fireship

'''Interesting but less teaching oriented material''' 
* Online: [http://ivory.idyll.org/blog/big-data-biology.html Top 12 reasons you know you are a Big Data biologist]
* Online: [http://lifehacker.com/six-life-lessons-ive-learned-from-programming-1502077380 How programming and your life is similar]
* Youtube: [http://www.youtube.com/watch?v=nKIu9yen5nc What most schools don't teach - how to think]

== Archive of old course programmes ==
None yet, as the course is new.

How the course is conducted

2025-12-22T14:53:01Z

WikiSysop: /* Preparation for exam */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
There will be some hand-in time irregularity at the end of the semester, due to exams. Pay attention. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. You can only evaluate if you have handed in exercises, so the hand-in is required. 
You are required to make a Jupyter Notebook for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. Many people use VScode for this, but it is up to you. In the last part of the course, this is changed to a '''.py''' file, to get you used to how the exam will be. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
DTU Learn does not allow for late hand-in. Set an alarm on your phone to remember. 


== Requirements for taking the course ==
'''You most take this seriously. Half of the students failed the course first year it ran.''' 
This course requires that you have previously taken 5 ECTS in a beginner course in programming. DTU students have taken [https://kurser.dtu.dk/course/02002 02002 Computer Programming (Polytechnical Foundation)], however foreign Master students are more of a mixed group. This course can NOT be treated as your first real programming course - it is your second, and the difficulty of the course and exam reflects that. I have tried to make the course accessible to people with a moderate background in programming, but it is not a free ride. I have an obsolete beginner course [https://teaching.healthtech.dtu.dk/22101/ 22101 Introduction to programming in Life Science using Python] which you can learn from on your own, if your background is insufficient and you want to take this course anyway.

Using AI/ChatGPT is a bad idea. From my observations and exam results, the use of AI hinders the acquisition of "programmatic thinking". This skill is what the course is about - the core competence. When asking AI about a problem, you are usually served a solution. Even if you understand the solution, then you have not gone through the process of thinking the solution. It weakens your thinking enormously, you don't "own" the solution and you are not getting used to thinking about programming problems. This becomes a big problem at exam time, because you think you are OK, but you have not acquired the correct thinking and the exam will seem very hard. Yes, there are a number of elements in the exam that we have been going through in the course, but there are also new elements (not python elements, but logic problems) where you have to think your way through.

== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. 

The peer evaluation is a central part of the learning process. As you will discover, you will be asked many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out '''.py''' file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam '''.py''' file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re, math and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

=== How much is required to pass? ===
The '''.py''' file is mostly structure and does not give much advice in how to solve the assignments. It is for you to show that you have learned to analyze a programming problem and come up with a solution. As you will be given both the input files and the output files, you can check how well you have succeeded. A correct solution to both assignments is an automatic pass. A correct solution to only one assignment, without any constructive work (in my evaluation) on the other assignment is not enough for a pass. No correct solutions, but writing good sensible code (again in my evaluation) can pass, as it shows you have learned essential things in the course. Comments are part the the essential things. 
In the end, unless you passed automatically, it comes down to a overall evaluation of your hand-in.

How the course is conducted

2025-12-22T14:50:23Z

WikiSysop: /* Requirements for taking the course */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
There will be some hand-in time irregularity at the end of the semester, due to exams. Pay attention. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. You can only evaluate if you have handed in exercises, so the hand-in is required. 
You are required to make a Jupyter Notebook for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. Many people use VScode for this, but it is up to you. In the last part of the course, this is changed to a '''.py''' file, to get you used to how the exam will be. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
DTU Learn does not allow for late hand-in. Set an alarm on your phone to remember. 


== Requirements for taking the course ==
'''You most take this seriously. Half of the students failed the course first year it ran.''' 
This course requires that you have previously taken 5 ECTS in a beginner course in programming. DTU students have taken [https://kurser.dtu.dk/course/02002 02002 Computer Programming (Polytechnical Foundation)], however foreign Master students are more of a mixed group. This course can NOT be treated as your first real programming course - it is your second, and the difficulty of the course and exam reflects that. I have tried to make the course accessible to people with a moderate background in programming, but it is not a free ride. I have an obsolete beginner course [https://teaching.healthtech.dtu.dk/22101/ 22101 Introduction to programming in Life Science using Python] which you can learn from on your own, if your background is insufficient and you want to take this course anyway.

Using AI/ChatGPT is a bad idea. From my observations and exam results, the use of AI hinders the acquisition of "programmatic thinking". This skill is what the course is about - the core competence. When asking AI about a problem, you are usually served a solution. Even if you understand the solution, then you have not gone through the process of thinking the solution. It weakens your thinking enormously, you don't "own" the solution and you are not getting used to thinking about programming problems. This becomes a big problem at exam time, because you think you are OK, but you have not acquired the correct thinking and the exam will seem very hard. Yes, there are a number of elements in the exam that we have been going through in the course, but there are also new elements (not python elements, but logic problems) where you have to think your way through.

== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. 

The peer evaluation is a central part of the learning process. As you will discover, you will be asked many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out '''.py''' file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam '''.py''' file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re, math and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

=== How much is required to pass? ===
The '''.py''' file is mostly structure and does not give much advice in how to solve the assignments. It is for you to show that you have learned to analyze a programming problem and come up with a solution. As you will be given both the input files and the output files, you can check how well you have succeeded. A correct solution to both assignments is an automatic pass. A correct solution to only one assignment, without any constructive work (in my evaluation) on the other assignment is not enough for a pass. No correct solutions, but writing good sensible code (again in my evaluation) can pass, as it shows you have learned essential things in the course. Comments are part the the essential things. 
In the end, unless you passed automatically, it comes down to a overall evaluation of your hand-in.

How the course is conducted

2025-12-22T14:49:32Z

WikiSysop: /* Requirements for taking the course */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
There will be some hand-in time irregularity at the end of the semester, due to exams. Pay attention. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. You can only evaluate if you have handed in exercises, so the hand-in is required. 
You are required to make a Jupyter Notebook for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. Many people use VScode for this, but it is up to you. In the last part of the course, this is changed to a '''.py''' file, to get you used to how the exam will be. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
DTU Learn does not allow for late hand-in. Set an alarm on your phone to remember. 


== Requirements for taking the course ==
'''You most take this seriously. Half of the students failed the course first year it ran.''' 
This course requires that you have previously taken 5 ECTS in a beginner course in programming. DTU students have taken [https://kurser.dtu.dk/course/02002 02002 Computer Programming (Polytechnical Foundation)], however foreign Master students are more of a mixed group. This course can NOT be treated as your first real programming course - it is your second, and the difficulty of the course and exam reflects that. I have tried to make the course accessible to people with a moderate background in programming, but it is not a free ride. I have an obsolete beginner course [https://teaching.healthtech.dtu.dk/22101/ 22101 Introduction to programming in Life Science using Python] which you can learn from on your own, if your background is insufficient and you want to take this course anyway.

Using AI/ChatGPT is a bad idea. From my observations and exam results, the use of AI hinders the acquisition of "programmatic thinking". This skill is what the course is about - the core competence. When asking AI about a problem, you are usually served a solution. Even if you understand the solution, then you have not gone through the process of thinking the solution. It weakens your thinking enormously, you don't "own" the solution and you are not getting used to thinking about programming problems. This becomes a big problem at exam time, because you think you are OK, but you have not acquired the correct thinking and the exam will seem very hard. Yes, there are a number of elements in the exam that we have been going through in the course, but there are also new elements (not python elements, but logic problems) where you think your way through.

== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. 

The peer evaluation is a central part of the learning process. As you will discover, you will be asked many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out '''.py''' file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam '''.py''' file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re, math and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

=== How much is required to pass? ===
The '''.py''' file is mostly structure and does not give much advice in how to solve the assignments. It is for you to show that you have learned to analyze a programming problem and come up with a solution. As you will be given both the input files and the output files, you can check how well you have succeeded. A correct solution to both assignments is an automatic pass. A correct solution to only one assignment, without any constructive work (in my evaluation) on the other assignment is not enough for a pass. No correct solutions, but writing good sensible code (again in my evaluation) can pass, as it shows you have learned essential things in the course. Comments are part the the essential things. 
In the end, unless you passed automatically, it comes down to a overall evaluation of your hand-in.

How the course is conducted

2025-12-22T14:32:16Z

WikiSysop: /* Peer evaluation of exercises */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
There will be some hand-in time irregularity at the end of the semester, due to exams. Pay attention. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. You can only evaluate if you have handed in exercises, so the hand-in is required. 
You are required to make a Jupyter Notebook for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. Many people use VScode for this, but it is up to you. In the last part of the course, this is changed to a '''.py''' file, to get you used to how the exam will be. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
DTU Learn does not allow for late hand-in. Set an alarm on your phone to remember. 


== Requirements for taking the course ==
'''You most take this seriously. Half of the students failed the course first year it ran.''' 
This course requires that you have previously taken 5 ECTS in a beginner course in programming. DTU students have taken [https://kurser.dtu.dk/course/02002 02002 Computer Programming (Polytechnical Foundation)], however foreign Master students are more of a mixed group. This course can NOT be treated as your first real programming course - it is your second, and the difficulty of the course and exam reflects that. I have tried to make the course accessible to people with a moderate background in programming, but it is not a free ride. I have an obsolete beginner course [https://teaching.healthtech.dtu.dk/22101/ 22101 Introduction to programming in Life Science using Python] which you can learn from on your own, if your background is insufficient and you want to take this course anyway.

== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. 

The peer evaluation is a central part of the learning process. As you will discover, you will be asked many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out '''.py''' file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam '''.py''' file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re, math and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

=== How much is required to pass? ===
The '''.py''' file is mostly structure and does not give much advice in how to solve the assignments. It is for you to show that you have learned to analyze a programming problem and come up with a solution. As you will be given both the input files and the output files, you can check how well you have succeeded. A correct solution to both assignments is an automatic pass. A correct solution to only one assignment, without any constructive work (in my evaluation) on the other assignment is not enough for a pass. No correct solutions, but writing good sensible code (again in my evaluation) can pass, as it shows you have learned essential things in the course. Comments are part the the essential things. 
In the end, unless you passed automatically, it comes down to a overall evaluation of your hand-in.

How the course is conducted

2025-12-22T12:32:46Z

WikiSysop: /* Preparation for exam */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
There will be some hand-in time irregularity at the end of the semester, due to exams. Pay attention. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. You can only evaluate if you have handed in exercises, so the hand-in is required. 
You are required to make a Jupyter Notebook for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. Many people use VScode for this, but it is up to you. In the last part of the course, this is changed to a '''.py''' file, to get you used to how the exam will be. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
DTU Learn does not allow for late hand-in. Set an alarm on your phone to remember. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. 

The peer evaluation is a central part of the learning process. As you will discover, you will be asked many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out '''.py''' file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam '''.py''' file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re, math and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

=== How much is required to pass? ===
The '''.py''' file is mostly structure and does not give much advice in how to solve the assignments. It is for you to show that you have learned to analyze a programming problem and come up with a solution. As you will be given both the input files and the output files, you can check how well you have succeeded. A correct solution to both assignments is an automatic pass. A correct solution to only one assignment, without any constructive work (in my evaluation) on the other assignment is not enough for a pass. No correct solutions, but writing good sensible code (again in my evaluation) can pass, as it shows you have learned essential things in the course. Comments are part the the essential things. 
In the end, unless you passed automatically, it comes down to a overall evaluation of your hand-in.

How the course is conducted

2025-12-22T12:31:55Z

WikiSysop: /* How much is required to pass? */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
There will be some hand-in time irregularity at the end of the semester, due to exams. Pay attention. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. You can only evaluate if you have handed in exercises, so the hand-in is required. 
You are required to make a Jupyter Notebook for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. Many people use VScode for this, but it is up to you. In the last part of the course, this is changed to a '''.py''' file, to get you used to how the exam will be. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
DTU Learn does not allow for late hand-in. Set an alarm on your phone to remember. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. 

The peer evaluation is a central part of the learning process. As you will discover, you will be asked many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out .py file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam .py file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re, math and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

=== How much is required to pass? ===
The '''.py''' file is mostly structure and does not give much advice in how to solve the assignments. It is for you to show that you have learned to analyze a programming problem and come up with a solution. As you will be given both the input files and the output files, you can check how well you have succeeded. A correct solution to both assignments is an automatic pass. A correct solution to only one assignment, without any constructive work (in my evaluation) on the other assignment is not enough for a pass. No correct solutions, but writing good sensible code (again in my evaluation) can pass, as it shows you have learned essential things in the course. Comments are part the the essential things. 
In the end, unless you passed automatically, it comes down to a overall evaluation of your hand-in.

How the course is conducted

2025-12-22T12:30:53Z

WikiSysop: /* Peer evaluation of exercises */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
There will be some hand-in time irregularity at the end of the semester, due to exams. Pay attention. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. You can only evaluate if you have handed in exercises, so the hand-in is required. 
You are required to make a Jupyter Notebook for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. Many people use VScode for this, but it is up to you. In the last part of the course, this is changed to a '''.py''' file, to get you used to how the exam will be. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
DTU Learn does not allow for late hand-in. Set an alarm on your phone to remember. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. 

The peer evaluation is a central part of the learning process. As you will discover, you will be asked many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out .py file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam .py file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re, math and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

=== How much is required to pass? ===
The .py file is mostly structure and does not give much advice in how to solve the assignments. It is for you to show that you have learned to analyze a programming problem and come up with a solution. As you will be given both the input files and the output files, you can check how well you have succeeded. A correct solution to both assignments is an automatic pass. A correct solution to only one assignment, without any constructive work (in my evaluation) on the other assignment is not enough for a pass. No correct solutions, but writing good sensible code (again in my evaluation) can pass, as it shows you have learned essential things in the course. Comments are part the the essential things. 
In the end, unless you passed automatically, it comes down to a overall evaluation of your hand-in.

How the course is conducted

2025-12-22T12:27:55Z

WikiSysop:

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
There will be some hand-in time irregularity at the end of the semester, due to exams. Pay attention. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. You can only evaluate if you have handed in exercises, so the hand-in is required. 
You are required to make a Jupyter Notebook for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. Many people use VScode for this, but it is up to you. In the last part of the course, this is changed to a '''.py''' file, to get you used to how the exam will be. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
DTU Learn does not allow for late hand-in. Set an alarm on your phone to remember. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. You can only evaluate if you have uploaded solutions yourself and you must have done at least 11 evaluations to participate in the exam. 


The peer evaluation is a central part of the learning process. As you will discover, I will be asking many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out .py file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam .py file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re, math and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

=== How much is required to pass? ===
The .py file is mostly structure and does not give much advice in how to solve the assignments. It is for you to show that you have learned to analyze a programming problem and come up with a solution. As you will be given both the input files and the output files, you can check how well you have succeeded. A correct solution to both assignments is an automatic pass. A correct solution to only one assignment, without any constructive work (in my evaluation) on the other assignment is not enough for a pass. No correct solutions, but writing good sensible code (again in my evaluation) can pass, as it shows you have learned essential things in the course. Comments are part the the essential things. 
In the end, unless you passed automatically, it comes down to a overall evaluation of your hand-in.

How the course is conducted

2025-12-22T12:27:22Z

WikiSysop:

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
There will be some irregularity at the end of the semester, due to exams. Pay attention. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. You can only evaluate if you have handed in exercises, so the hand-in is required. 
You are required to make a Jupyter Notebook for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. Many people use VScode for this, but it is up to you. In the last part of the course, this is changed to a '''.py''' file, to get you used to how the exam will be. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
DTU Learn does not allow for late hand-in. Set an alarm on your phone to remember. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. You can only evaluate if you have uploaded solutions yourself and you must have done at least 11 evaluations to participate in the exam. 


The peer evaluation is a central part of the learning process. As you will discover, I will be asking many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out .py file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam .py file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re, math and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

=== How much is required to pass? ===
The .py file is mostly structure and does not give much advice in how to solve the assignments. It is for you to show that you have learned to analyze a programming problem and come up with a solution. As you will be given both the input files and the output files, you can check how well you have succeeded. A correct solution to both assignments is an automatic pass. A correct solution to only one assignment, without any constructive work (in my evaluation) on the other assignment is not enough for a pass. No correct solutions, but writing good sensible code (again in my evaluation) can pass, as it shows you have learned essential things in the course. Comments are part the the essential things. 
In the end, unless you passed automatically, it comes down to a overall evaluation of your hand-in.

How the course is conducted

2025-11-26T22:08:15Z

WikiSysop: /* Preparation for exam */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. Since you can only evaluate if you have handed in exercises, then you need to do those, too :-) 
You are required to make a notebook (in VScode) for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
Exercises which are handed in after the solutions are published, are voided and will not count, no matter the reason for being late. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. You can only evaluate if you have uploaded solutions yourself and you must have done at least 11 evaluations to participate in the exam. 


The peer evaluation is a central part of the learning process. As you will discover, I will be asking many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out .py file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam .py file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re, math and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

=== How much is required to pass? ===
The .py file is mostly structure and does not give much advice in how to solve the assignments. It is for you to show that you have learned to analyze a programming problem and come up with a solution. As you will be given both the input files and the output files, you can check how well you have succeeded. A correct solution to both assignments is an automatic pass. A correct solution to only one assignment, without any constructive work (in my evaluation) on the other assignment is not enough for a pass. No correct solutions, but writing good sensible code (again in my evaluation) can pass, as it shows you have learned essential things in the course. Comments are part the the essential things. 
In the end, unless you passed automatically, it comes down to a overall evaluation of your hand-in.

22116/22166 Python programming in Life Science

2025-10-28T09:45:11Z

WikiSysop: /* Course details */

__NOTOC__
'''Teacher:''' [https://www.inside.dtu.dk/da/dtuinside/generelt/telefonbog/person?id=816&cpid=214027&tab=2&qt=dtupublicationquery Peter Wad Sackett], pwsa@dtu.dk  
'''Language:''' The course is taught in English. 
'''Tools:''' The course is using the standard DTU python setup, see [https://pythonsupport.dtu.dk/ https://pythonsupport.dtu.dk/] if you do not have it already. 
'''Textbooks:''' I believe students should not pay at lot of money for textbooks. I will use powerpoints, videos and references to online resources. You can find the material under the individual lessons in the [[Programme]]. 
'''Location:''' Building 358, room 60b + streaming to room 046, no matter what your plan says. Course 22116 and 22166 are taught together. 
'''Time:''' Monday 13:00 - 17:00, module E2-A. 

== Course details ==
There are no plans for streaming the lectures as there already are some recorded video lectures for each session. However, with over 180 students two teaching rooms must be used. I will stream the teaching from one room to the other.

[[Programme]] Fall 2025

[https://teaching.healthtech.dtu.dk/22116/progress/ See the progress of your hand-ins]

[[How the course is conducted]] Required reading

[[Course Survival Guide]] Useful when you get stuck early

[[AI guidelines for the course]] You want to use AI, then you MUST read it.

[[Good code]] Always keep this in mind


== Competences ==
A general engineering competence skill is the ability to explain the process through which you obtain your results - how else can they be trusted?
Learning to program is a great way to practice that skill, since you have to explain to the computer how it is supposed to solve the task you give.
This explanation must pay attention to detail, specifically identifying and ordering the elements of the solution.
This nurtures and strengthens an analytical and structured mindset which is also an essential engineering competence skill.
Training these skills is obviously beneficial for the student, but they do not come for free - it is '''hard work''', so put the time aside for it.

== Resources ==
* Online: [https://teaching.healthtech.dtu.dk/material/22116/clean_code.html Clean Code] by Lukasz Dynowski. An amazing read that is mandatory. Read it once around lesson 5 and once more around lesson 8.
* Info: [[Biological knowledge needed in the course]]
* Online: [https://rosalind.info/problems/locations/ Rosalind project] Python exercises at different levels for practicing

* Online: [https://www.coursera.org/learn/python Coursera course: Programming for Everybody] is a beginner course in Python. Everyone who wants to prepare for course 22116/22166 can start here. Just get far enough so you understand what programming is and how it works. That will benefit you a lot as a newbie. The [https://teaching.healthtech.dtu.dk/material/22118/CourseraPythonBook_270.pdf Coursera textbook].

* Book: ''Learning Python'', 5th ed. by Mark Lutz (O'Reilly) ISBN: 978-1-449-35573-9. This is the best Python book I have read. It covers all the basics and then some. All from the perspective of being a novice programmer. However, it is a brick; big, heavy and unwieldy. If you only want one Python book, then this should be the one. The course will not be taught from this book, but it could be good to have as a Python reference manual.

* Book: ''Python Crash Course: A Hands-On, Project-Based Introduction to Programming'' by Eric Matthes (No Starch Press) ISBN: 1593276036, 9781593276034. A pretty OK book which leads you into the Python world without too many distracting points and theoretical contemplation.

* Online: [https://wiki.python.org/moin/BeginnersGuide/NonProgrammers Python for Non-Programmers]
* Online: [https://docs.python.org/3/tutorial/ Official Python 3 tutorial]
* Online: [https://docs.python.org/3/reference/index.html Python 3 reference manual]
* Online: [https://docs.python.org/3/library/index.html Python 3 standard library]

'''Videos with advice on learning how to code''' 
* Youtube: [https://www.youtube.com/watch?v=A8ldqcFS5S8 How I Would Learn To Code If I Was To Start Over] by Tiff In Tech
* Youtube: [https://www.youtube.com/watch?v=_nsV65jUPL8 Coding Was Hard Until I Learned THESE 5 Things!] by Pooja Dutt
* Youtube: [https://www.youtube.com/watch?v=MHPGeQD8TvI How I would learn to code (if I could start over)] by Tina Huang
* Youtube: [https://www.youtube.com/watch?v=To8hKb112Aw How I would learn to code (if I could start over)] by PIRATE KING
* Youtube: [https://www.youtube.com/watch?v=9s29LKfEFjQ How I would learn to code (If I could start over)] by Jason Goodison
* Youtube: [https://www.youtube.com/watch?v=NtfbWkxJTHw How to Learn to Code - 8 Hard Truths] by Fireship

'''Interesting but less teaching oriented material''' 
* Online: [http://ivory.idyll.org/blog/big-data-biology.html Top 12 reasons you know you are a Big Data biologist]
* Online: [http://lifehacker.com/six-life-lessons-ive-learned-from-programming-1502077380 How programming and your life is similar]
* Youtube: [http://www.youtube.com/watch?v=nKIu9yen5nc What most schools don't teach - how to think]

== Archive of old course programmes ==
None yet, as the course is new.

22116/22166 Python programming in Life Science

2025-10-27T13:54:42Z

WikiSysop: /* Course details */

__NOTOC__
'''Teacher:''' [https://www.inside.dtu.dk/da/dtuinside/generelt/telefonbog/person?id=816&cpid=214027&tab=2&qt=dtupublicationquery Peter Wad Sackett], pwsa@dtu.dk  
'''Language:''' The course is taught in English. 
'''Tools:''' The course is using the standard DTU python setup, see [https://pythonsupport.dtu.dk/ https://pythonsupport.dtu.dk/] if you do not have it already. 
'''Textbooks:''' I believe students should not pay at lot of money for textbooks. I will use powerpoints, videos and references to online resources. You can find the material under the individual lessons in the [[Programme]]. 
'''Location:''' Building 358, room 60b + streaming to room 046, no matter what your plan says. Course 22116 and 22166 are taught together. 
'''Time:''' Monday 13:00 - 17:00, module E2-A. 

== Course details ==
There are no plans for streaming the lectures as there already are some recorded video lectures for each session. However, with over 180 students two teaching rooms must be used. I will stream the teaching from one room to the other.

[[Programme]] Fall 2025

[https://teaching.healthtech.dtu.dk/22116/progress/ See the progress of your hand-ins] Apparently slightly bugged currently

[[How the course is conducted]] Required reading

[[Course Survival Guide]] Useful when you get stuck early

[[AI guidelines for the course]] You want to use AI, then you MUST read it.

[[Good code]] Always keep this in mind


== Competences ==
A general engineering competence skill is the ability to explain the process through which you obtain your results - how else can they be trusted?
Learning to program is a great way to practice that skill, since you have to explain to the computer how it is supposed to solve the task you give.
This explanation must pay attention to detail, specifically identifying and ordering the elements of the solution.
This nurtures and strengthens an analytical and structured mindset which is also an essential engineering competence skill.
Training these skills is obviously beneficial for the student, but they do not come for free - it is '''hard work''', so put the time aside for it.

== Resources ==
* Online: [https://teaching.healthtech.dtu.dk/material/22116/clean_code.html Clean Code] by Lukasz Dynowski. An amazing read that is mandatory. Read it once around lesson 5 and once more around lesson 8.
* Info: [[Biological knowledge needed in the course]]
* Online: [https://rosalind.info/problems/locations/ Rosalind project] Python exercises at different levels for practicing

* Online: [https://www.coursera.org/learn/python Coursera course: Programming for Everybody] is a beginner course in Python. Everyone who wants to prepare for course 22116/22166 can start here. Just get far enough so you understand what programming is and how it works. That will benefit you a lot as a newbie. The [https://teaching.healthtech.dtu.dk/material/22118/CourseraPythonBook_270.pdf Coursera textbook].

* Book: ''Learning Python'', 5th ed. by Mark Lutz (O'Reilly) ISBN: 978-1-449-35573-9. This is the best Python book I have read. It covers all the basics and then some. All from the perspective of being a novice programmer. However, it is a brick; big, heavy and unwieldy. If you only want one Python book, then this should be the one. The course will not be taught from this book, but it could be good to have as a Python reference manual.

* Book: ''Python Crash Course: A Hands-On, Project-Based Introduction to Programming'' by Eric Matthes (No Starch Press) ISBN: 1593276036, 9781593276034. A pretty OK book which leads you into the Python world without too many distracting points and theoretical contemplation.

* Online: [https://wiki.python.org/moin/BeginnersGuide/NonProgrammers Python for Non-Programmers]
* Online: [https://docs.python.org/3/tutorial/ Official Python 3 tutorial]
* Online: [https://docs.python.org/3/reference/index.html Python 3 reference manual]
* Online: [https://docs.python.org/3/library/index.html Python 3 standard library]

'''Videos with advice on learning how to code''' 
* Youtube: [https://www.youtube.com/watch?v=A8ldqcFS5S8 How I Would Learn To Code If I Was To Start Over] by Tiff In Tech
* Youtube: [https://www.youtube.com/watch?v=_nsV65jUPL8 Coding Was Hard Until I Learned THESE 5 Things!] by Pooja Dutt
* Youtube: [https://www.youtube.com/watch?v=MHPGeQD8TvI How I would learn to code (if I could start over)] by Tina Huang
* Youtube: [https://www.youtube.com/watch?v=To8hKb112Aw How I would learn to code (if I could start over)] by PIRATE KING
* Youtube: [https://www.youtube.com/watch?v=9s29LKfEFjQ How I would learn to code (If I could start over)] by Jason Goodison
* Youtube: [https://www.youtube.com/watch?v=NtfbWkxJTHw How to Learn to Code - 8 Hard Truths] by Fireship

'''Interesting but less teaching oriented material''' 
* Online: [http://ivory.idyll.org/blog/big-data-biology.html Top 12 reasons you know you are a Big Data biologist]
* Online: [http://lifehacker.com/six-life-lessons-ive-learned-from-programming-1502077380 How programming and your life is similar]
* Youtube: [http://www.youtube.com/watch?v=nKIu9yen5nc What most schools don't teach - how to think]

== Archive of old course programmes ==
None yet, as the course is new.

22116/22166 Python programming in Life Science

2025-10-27T13:54:00Z

WikiSysop: /* Course details */

__NOTOC__
'''Teacher:''' [https://www.inside.dtu.dk/da/dtuinside/generelt/telefonbog/person?id=816&cpid=214027&tab=2&qt=dtupublicationquery Peter Wad Sackett], pwsa@dtu.dk  
'''Language:''' The course is taught in English. 
'''Tools:''' The course is using the standard DTU python setup, see [https://pythonsupport.dtu.dk/ https://pythonsupport.dtu.dk/] if you do not have it already. 
'''Textbooks:''' I believe students should not pay at lot of money for textbooks. I will use powerpoints, videos and references to online resources. You can find the material under the individual lessons in the [[Programme]]. 
'''Location:''' Building 358, room 60b + streaming to room 046, no matter what your plan says. Course 22116 and 22166 are taught together. 
'''Time:''' Monday 13:00 - 17:00, module E2-A. 

== Course details ==
There are no plans for streaming the lectures as there already are some recorded video lectures for each session. However, with over 180 students two teaching rooms must be used. I will stream the teaching from one room to the other.

[[Programme]] Fall 2025

[https://teaching.healthtech.dtu.dk/22116/progress/ See the progress of your hand-ins]

[[How the course is conducted]] Required reading

[[Course Survival Guide]] Useful when you get stuck early

[[AI guidelines for the course]] You want to use AI, then you MUST read it.

[[Good code]] Always keep this in mind


== Competences ==
A general engineering competence skill is the ability to explain the process through which you obtain your results - how else can they be trusted?
Learning to program is a great way to practice that skill, since you have to explain to the computer how it is supposed to solve the task you give.
This explanation must pay attention to detail, specifically identifying and ordering the elements of the solution.
This nurtures and strengthens an analytical and structured mindset which is also an essential engineering competence skill.
Training these skills is obviously beneficial for the student, but they do not come for free - it is '''hard work''', so put the time aside for it.

== Resources ==
* Online: [https://teaching.healthtech.dtu.dk/material/22116/clean_code.html Clean Code] by Lukasz Dynowski. An amazing read that is mandatory. Read it once around lesson 5 and once more around lesson 8.
* Info: [[Biological knowledge needed in the course]]
* Online: [https://rosalind.info/problems/locations/ Rosalind project] Python exercises at different levels for practicing

* Online: [https://www.coursera.org/learn/python Coursera course: Programming for Everybody] is a beginner course in Python. Everyone who wants to prepare for course 22116/22166 can start here. Just get far enough so you understand what programming is and how it works. That will benefit you a lot as a newbie. The [https://teaching.healthtech.dtu.dk/material/22118/CourseraPythonBook_270.pdf Coursera textbook].

* Book: ''Learning Python'', 5th ed. by Mark Lutz (O'Reilly) ISBN: 978-1-449-35573-9. This is the best Python book I have read. It covers all the basics and then some. All from the perspective of being a novice programmer. However, it is a brick; big, heavy and unwieldy. If you only want one Python book, then this should be the one. The course will not be taught from this book, but it could be good to have as a Python reference manual.

* Book: ''Python Crash Course: A Hands-On, Project-Based Introduction to Programming'' by Eric Matthes (No Starch Press) ISBN: 1593276036, 9781593276034. A pretty OK book which leads you into the Python world without too many distracting points and theoretical contemplation.

* Online: [https://wiki.python.org/moin/BeginnersGuide/NonProgrammers Python for Non-Programmers]
* Online: [https://docs.python.org/3/tutorial/ Official Python 3 tutorial]
* Online: [https://docs.python.org/3/reference/index.html Python 3 reference manual]
* Online: [https://docs.python.org/3/library/index.html Python 3 standard library]

'''Videos with advice on learning how to code''' 
* Youtube: [https://www.youtube.com/watch?v=A8ldqcFS5S8 How I Would Learn To Code If I Was To Start Over] by Tiff In Tech
* Youtube: [https://www.youtube.com/watch?v=_nsV65jUPL8 Coding Was Hard Until I Learned THESE 5 Things!] by Pooja Dutt
* Youtube: [https://www.youtube.com/watch?v=MHPGeQD8TvI How I would learn to code (if I could start over)] by Tina Huang
* Youtube: [https://www.youtube.com/watch?v=To8hKb112Aw How I would learn to code (if I could start over)] by PIRATE KING
* Youtube: [https://www.youtube.com/watch?v=9s29LKfEFjQ How I would learn to code (If I could start over)] by Jason Goodison
* Youtube: [https://www.youtube.com/watch?v=NtfbWkxJTHw How to Learn to Code - 8 Hard Truths] by Fireship

'''Interesting but less teaching oriented material''' 
* Online: [http://ivory.idyll.org/blog/big-data-biology.html Top 12 reasons you know you are a Big Data biologist]
* Online: [http://lifehacker.com/six-life-lessons-ive-learned-from-programming-1502077380 How programming and your life is similar]
* Youtube: [http://www.youtube.com/watch?v=nKIu9yen5nc What most schools don't teach - how to think]

== Archive of old course programmes ==
None yet, as the course is new.

How the course is conducted

2025-10-21T05:10:19Z

WikiSysop: /* Preparation for exam */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. Since you can only evaluate if you have handed in exercises, then you need to do those, too :-) 
You are required to make a notebook (in VScode) for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
Exercises which are handed in after the solutions are published, are voided and will not count, no matter the reason for being late. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. You can only evaluate if you have uploaded solutions yourself and you must have done at least 11 evaluations to participate in the exam. 


The peer evaluation is a central part of the learning process. As you will discover, I will be asking many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out .py file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam .py file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re, math and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

How the course is conducted

2025-10-21T05:07:25Z

WikiSysop: /* Preparation for exam */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. Since you can only evaluate if you have handed in exercises, then you need to do those, too :-) 
You are required to make a notebook (in VScode) for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
Exercises which are handed in after the solutions are published, are voided and will not count, no matter the reason for being late. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. You can only evaluate if you have uploaded solutions yourself and you must have done at least 11 evaluations to participate in the exam. 


The peer evaluation is a central part of the learning process. As you will discover, I will be asking many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out .py file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam .py file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

Exam aids: You can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

How the course is conducted

2025-10-21T05:05:54Z

WikiSysop: /* Preparation for exam */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. Since you can only evaluate if you have handed in exercises, then you need to do those, too :-) 
You are required to make a notebook (in VScode) for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
Exercises which are handed in after the solutions are published, are voided and will not count, no matter the reason for being late. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. You can only evaluate if you have uploaded solutions yourself and you must have done at least 11 evaluations to participate in the exam. 


The peer evaluation is a central part of the learning process. As you will discover, I will be asking many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out .py file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam .py file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

Comments that just explains your intentions, but are not supported by code, are disregarded. You can not "talk" your way to a pass, you must code your way to a pass.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

To the exam, you can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

How the course is conducted

2025-10-21T05:03:10Z

WikiSysop: /* Preparation for exam */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. Since you can only evaluate if you have handed in exercises, then you need to do those, too :-) 
You are required to make a notebook (in VScode) for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
Exercises which are handed in after the solutions are published, are voided and will not count, no matter the reason for being late. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. You can only evaluate if you have uploaded solutions yourself and you must have done at least 11 evaluations to participate in the exam. 


The peer evaluation is a central part of the learning process. As you will discover, I will be asking many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out .py file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam .py file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and employ code modularization.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

To the exam, you can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

How the course is conducted

2025-10-21T05:02:27Z

WikiSysop: /* Preparation for exam */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. Since you can only evaluate if you have handed in exercises, then you need to do those, too :-) 
You are required to make a notebook (in VScode) for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
Exercises which are handed in after the solutions are published, are voided and will not count, no matter the reason for being late. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. You can only evaluate if you have uploaded solutions yourself and you must have done at least 11 evaluations to participate in the exam. 


The peer evaluation is a central part of the learning process. As you will discover, I will be asking many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out .py file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam .py file. Follow the naming scheme for your own functions - it should be obvious.

You are expected to solve the assignments using the course curriculum. In particular, it means "pure" python, maybe using standard libraries like os, sys, re and others, but not 3rd party libraries like pandas or numpy. It also means use of comments to explain what you are doing, and modularization.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

To the exam, you can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

How the course is conducted

2025-10-21T04:38:24Z

WikiSysop: /* Using python elements not in the curriculum */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. Since you can only evaluate if you have handed in exercises, then you need to do those, too :-) 
You are required to make a notebook (in VScode) for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
Exercises which are handed in after the solutions are published, are voided and will not count, no matter the reason for being late. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. You can only evaluate if you have uploaded solutions yourself and you must have done at least 11 evaluations to participate in the exam. 


The peer evaluation is a central part of the learning process. As you will discover, I will be asking many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make a solution that follows the course progression, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out .py file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam .py file. Follow the naming scheme for your own functions - it should be obvious.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

To the exam, you can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

How the course is conducted

2025-10-21T04:35:18Z

WikiSysop: /* Preparation for exam */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. Since you can only evaluate if you have handed in exercises, then you need to do those, too :-) 
You are required to make a notebook (in VScode) for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
Exercises which are handed in after the solutions are published, are voided and will not count, no matter the reason for being late. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. You can only evaluate if you have uploaded solutions yourself and you must have done at least 11 evaluations to participate in the exam. 


The peer evaluation is a central part of the learning process. As you will discover, I will be asking many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make the second solution, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out .py file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam .py file. Follow the naming scheme for your own functions - it should be obvious.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

To the exam, you can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

How the course is conducted

2025-10-20T20:05:05Z

WikiSysop: /* Preparation for exam */

__NOTOC__
Weekly exercises are given every Monday. This constitutes an exercise set. There will be 13 of those. 
Exercises have to be uploaded to "DTU Learn" latest Sunday in the week after the exercises were given, i.e you have 7 days to complete a set. 
Peer evaluation of exercises are done in the following week to be handed in Friday. 
The evaluations are mandatory. At least 11 of 13 evaluations must be handed in - in time - for you to be allowed to take the exam. Since you can only evaluate if you have handed in exercises, then you need to do those, too :-) 
You are required to make a notebook (in VScode) for every exercise set, i.e. every week. The .ipynb file is what you hand in to Peer Evaluation. 
Solutions to each week's exercises are published before the next week's lesson on DTU Learn (under Discussions). 
Exercises which are handed in after the solutions are published, are voided and will not count, no matter the reason for being late. 


== Peer evaluation of exercises ==
You must upload the solutions for the exercise set at given lesson to DTU Learn. The following week you must evaluate another students solutions - to be handed in on the Friday. You are getting some help with that as I have published my solutions at that time. You can only evaluate if you have uploaded solutions yourself and you must have done at least 11 evaluations to participate in the exam. 


The peer evaluation is a central part of the learning process. As you will discover, I will be asking many questions about various aspects of the code you will have to evaluate. Initially, it can seem overwhelming, and you might not have been taught about all yet, but it is the same questions week after week, and you mostly have to check boxes, so it will get easier during the course. You learn both by doing the evaluation and by receiving (reading) it.

You can/should use the criteria in [[Good code]] in your own programs and the evaluation. The questions in the evaluation are more in depth than [[Good code]]. The evaluation is anonymous, but known to the teacher.

===Learning from exercises and teachers solutions===
You obviously learn from doing the exercises. However, that is just phase 1. Reflecting over your own solutions while reading the teachers solutions is extremely useful; It prepares you for the following week, it prepares you for the peer evaluation, it shows you alternative solutions you might not have thought about. 
The solutions are examples with explanations and also cover common mistakes. ''They can be found on DTU Learn under Discussions''.

===Pythonic exercises===
Python has several constructs, functions, ways/idioms to do certain things. People who have seen some python before may know of this. When using these methods and ways of thinking the code becomes "pythonic". 
It is a learning objective in the course and important for your future as a programmer to learn to program and to design algorithms. 
It happens especially in the first half of the course that learning to program and making pythonic code are at odds. This can been seen in the teachers solutions - you might think: "Why did he do it this way, when you can do it
smarter/more intuitive/easier/pythonic this way". This is the reason - the course prioritizes learning to program more than doing it the pythonic way. When you have learned to make algorithms and code well, you can do this in any language. Pythonic coding only works with python.

If you do not observe this during the course - no problem.

== Special exercises ==
'''Purple exercises''' has to be done in pseudo code before you start implementing them in Python. The pseudo code is part of the hand-in for these exercises.
So - make the pseudocode FIRST, then the real python programs AFTERWARDS for the purple exercises.

== Using python elements not in the curriculum ==
Most people sooner or later use python not in the curriculum, or not yet covered by the course progression. There are several reasons for that: They know some python from other courses, they have been using AI to create solutions, they have been reading ahead or they have searched the internet for answers. 

While knowledge is good, then there is a reason for why the exercises and the learning materials (powerpoint) are as they are - it is a designed course progression. A very important part of the course is to learn how program, how to think "programming", how to analyze a problem, how to formulate a strategy/workflow/algorithm that will solve the problem. 
By not following the course progression, then you are not learning to analyze or formulate strategies.
By not thinking - structuring the code more logically - gaining insight in the natural flow of problem solving, you will lack those skills - that mindset - when you really need it to solve more difficult exercises and/or problems. 
Also, it brings problems to peer evaluation, as not everyone knows python that is outside the curriculum.

If you want to show some fancy python (i.e. outside the curriculum/progression), then make TWO solutions to the exercise. One that shows the fancy python and one that follows the curriculum and the course progression. The last one can then be used for peer evaluation. If you find yourself unable to make the second solution, then maybe you should study the subject some more.

== Preparation for exam ==
The exam is a 4 hour written exam. You will get the assignments, the input files that you have to use/read/parse, and the output files that you have to create. Most importantly, you will also get a '''.py''' file that you will have to fill out. That is basically a text file with python code, that mostly contains empty functions. You have to fill out the functions with python code that solves the assignments. YOU CAN NOT HAND IN A JUPYTER NOTEBOOK FILE. Your exam hand-in is only the filled out .py file.

The last lesson [[Python object model]]'s exercises is an example of the exam format - not the exam content. All the exercises has to be handed in in one single .py file. Every exercise is one individual python function, which calls some specified other functions which together solves the exercise. You can add your own functions, if you feel some functionality is missing, but you must fill and use those given by the exam .py file. Follow the naming scheme - it should be obvious.

At the exam there will likely be 2 assignments - '''not''' 6 exercises - that you have to solve.

To the exam, you can bring your computer with all the material from the course; powerpoints, exercises, solutions, etc. There is NO INTERNET and NO AI allowed. In the end, it is the programming skill you acquired during the course, that will make you pass - not any aid you bring. That is why we are doing so many difficult exercises.

How the course is conducted

2025-10-20T20:02:31Z

WikiSysop: /* Preparation for exam */

How the course is conducted

2025-10-20T19:43:19Z

WikiSysop: /* Preparation for exam */

How the course is conducted

2025-10-20T19:42:59Z

WikiSysop: /* Preparation for exam */

Collection of files

2025-10-14T14:47:55Z

WikiSysop:

__NOTOC__
Last updated: September 5, 2025 
== 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/22116/ex1.acc ex1.acc] 
[https://teaching.healthtech.dtu.dk/material/22116/ex1.dat ex1.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/ex1_1.dat ex1_1.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/ex1_2.dat ex1_2.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/ex1_3.dat ex1_3.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/mixedlines.txt mixedlines.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/ex5.acc ex5.acc] 
[https://teaching.healthtech.dtu.dk/material/22116/numbers1.txt numbers1.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/numbers2.txt numbers2.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/numbers3.txt numbers3.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/badnumbers.txt badnumbers.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/goodnumbers.txt goodnumbers.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/secret.txt secret.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/secret2.txt secret2.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/dna.dat dna.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/dna.fsa dna.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/orphans.sp orphans.sp] 
[https://teaching.healthtech.dtu.dk/material/22116/studentweight.txt studentweight.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/sprot1.dat sprot1.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/sprot2.dat sprot2.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/sprot3.dat sprot3.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/sprot4.dat sprot4.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/sprotall.dat sprotall.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/sorted5.acc sorted5.acc] 
[https://teaching.healthtech.dtu.dk/material/22116/clean5.acc clean5.acc] 
[https://teaching.healthtech.dtu.dk/material/22116/ex1corrupt.dat ex1corrupt.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/dna7.fsa dna7.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/revdna7.fsa revdna7.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/dna7GC.fsa dna7GC.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/data1.gb data1.gb] 
[https://teaching.healthtech.dtu.dk/material/22116/data2.gb data2.gb] 
[https://teaching.healthtech.dtu.dk/material/22116/data3.gb data3.gb] 
[https://teaching.healthtech.dtu.dk/material/22116/data4.gb data4.gb] 
[https://teaching.healthtech.dtu.dk/material/22116/start10.dat start10.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/res10.dat res10.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/aa7.fsa aa7.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/uniq5.acc uniq5.acc] 
[https://teaching.healthtech.dtu.dk/material/22116/order5.acc order5.acc] 
[https://teaching.healthtech.dtu.dk/material/22116/res10.dat res10.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/slinger.txt slinger.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/hoist.txt hoist.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/combined.txt combined.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/geneA.txt geneA.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/geneB.txt geneB.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/geneC.txt geneC.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/geneD.txt geneD.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/geneE.txt geneE.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/gene_combined.txt gene_combined.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/dnanoise.fsa dnanoise.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/fastaout.fsa fastaout.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/alignment.fsa alignment.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/HIVenvelope.txt HIVenvelope.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/HIVenv.fsa HIVenv.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/HIVepitopes.txt HIVepitopes.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/HIVepitopesML.txt HIVepitopesML.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/test1.dat test1.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/test2.dat test2.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/test3.dat test3.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/combinedresult.dat combinedresult.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/matrix.dat matrix.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/dna-array.dat dna-array.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/column.tab column.tab] 
[https://teaching.healthtech.dtu.dk/material/22116/dna-array-norm.dat dna-array-norm.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/regulation.txt regulation.txt] 

During the course, you will be creating the following files which values depends on your choices: sums.fsa selected.fsa rest.fsa

Collection of files

2025-10-14T14:45:36Z

WikiSysop: /* Individual files */

__NOTOC__
Last updated: September 5, 2025 
Warning: This is not complete or correct yet.
== 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/22116/ex1.acc ex1.acc] 
[https://teaching.healthtech.dtu.dk/material/22116/ex1.dat ex1.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/ex1_1.dat ex1_1.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/ex1_2.dat ex1_2.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/ex1_3.dat ex1_3.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/mixedlines.txt mixedlines.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/ex5.acc ex5.acc] 
[https://teaching.healthtech.dtu.dk/material/22116/numbers1.txt numbers1.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/numbers2.txt numbers2.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/numbers3.txt numbers3.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/badnumbers.txt badnumbers.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/goodnumbers.txt goodnumbers.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/secret.txt secret.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/secret2.txt secret2.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/dna.dat dna.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/dna.fsa dna.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/orphans.sp orphans.sp] 
[https://teaching.healthtech.dtu.dk/material/22116/studentweight.txt studentweight.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/sprot1.dat sprot1.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/sprot2.dat sprot2.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/sprot3.dat sprot3.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/sprot4.dat sprot4.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/sprotall.dat sprotall.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/sorted5.acc sorted5.acc] 
[https://teaching.healthtech.dtu.dk/material/22116/clean5.acc clean5.acc] 
[https://teaching.healthtech.dtu.dk/material/22116/ex1corrupt.dat ex1corrupt.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/dna7.fsa dna7.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/revdna7.fsa revdna7.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/dna7GC.fsa dna7GC.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/data1.gb data1.gb] 
[https://teaching.healthtech.dtu.dk/material/22116/data2.gb data2.gb] 
[https://teaching.healthtech.dtu.dk/material/22116/data3.gb data3.gb] 
[https://teaching.healthtech.dtu.dk/material/22116/data4.gb data4.gb] 
[https://teaching.healthtech.dtu.dk/material/22116/start10.dat start10.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/res10.dat res10.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/aa7.fsa aa7.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/uniq5.acc uniq5.acc] 
[https://teaching.healthtech.dtu.dk/material/22116/order5.acc order5.acc] 
[https://teaching.healthtech.dtu.dk/material/22116/res10.dat res10.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/slinger.txt slinger.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/hoist.txt hoist.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/combined.txt combined.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/geneA.txt geneA.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/geneB.txt geneB.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/geneC.txt geneC.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/geneD.txt geneD.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/geneE.txt geneE.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/gene_combined.txt gene_combined.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/dnanoise.fsa dnanoise.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/fastaout.fsa fastaout.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/alignment.fsa alignment.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/HIVenvelope.txt HIVenvelope.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/HIVenv.fsa HIVenv.fsa] 
[https://teaching.healthtech.dtu.dk/material/22116/HIVepitopes.txt HIVepitopes.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/HIVepitopesML.txt HIVepitopesML.txt] 
[https://teaching.healthtech.dtu.dk/material/22116/test1.dat test1.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/test2.dat test2.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/test3.dat test3.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/combinedresult.dat combinedresult.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/matrix.dat matrix.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/dna-array.dat dna-array.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/column.tab column.tab] 
[https://teaching.healthtech.dtu.dk/material/22116/dna-array-norm.dat dna-array-norm.dat] 
[https://teaching.healthtech.dtu.dk/material/22116/regulation.txt regulation.txt] 

During the course, you will be creating the following files which values depends on your choices: sums.fsa selected.fsa rest.fsa

Python object model

2025-10-14T12:37:15Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Regular expressions]]
|Next: [[Programme]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_13-Objects.ppt Object model and complex data] 
Resource: [[Example code - Complex data]]

== Subjects covered ==
* Python objects
* Identity
* Mutable vs immutable
* Complex data
* Exam format

== Exercises to be handed in ==
'''Important - read this before starting''' 
This exercise set will be similar to the format of the exam. The content will obviously be different. 
You have to download [https://teaching.healthtech.dtu.dk/material/22116/22116_13.py this python file.] It contains some frame work code, but mostly some unfinished functions.
Each exercise is about finishing one of the function groups in the file. You can write the functions directly in the python file, or use VScode or other Jupyter Notebook editor to write it, but then it has to be copied over to the python file. You must hand in the finished python file, '''not''' a .ipynb file. 
Inability to understand or perform this process will make you fail the exam, so it is worth spending some time on the procedure.

# In the file ''test1.dat'' is results from an experiment where every line is in the form: ''AccessionNumber Number Number Number ....'' In the files ''test2.dat'' and ''test3.dat'' are results from similar experiments but with a slightly different gene set. You want find the average the numbers from all experiments for each accession number. Save your results, sorted according to the accession, in the file ''combinedresults.txt'' in the form: ''AccessionNumber SingleAverageNumberOfAll3Experiments'' Of course it might happen that a certain gene is only in one or two experiments and in that case you calculate the average for those. You must use a one of complex data structures to store this data, hint hint - a dict of lists. 
# Create a main function that reads a tab separated file with numbers, ''matrix.dat'', (to be understood as a matrix) and stores the numbers in a matrix (list of lists). Having read the matrix from file it should now transpose it (rows to columns and columns to rows) and save the transposed matrix in the file ''trans1matrix.dat''. The output should look like the input, that is '''not''' a python data structure. You must construct a function like transpose(matrix), which gets a matrix as input an returned a transposed matrix - without using any global variables. matrix = transpose(matrix) This is the easiest, but momentarily most memory consuming method, you just return the transposed matrix, i.e. a new data structure. How do you easily check if it works? Well, transposing twice yields the original matrix. [http://en.wikipedia.org/wiki/Transpose Check out Wikipedia's entry on transposing a matrix.] 
# This is the same problem as the previous exercise, except your transpose function have to transpose the matrix in-line, no returned matrix, i.e. the original matrix data structure is changed. transpose(matrix) The output file is this time ''trans2matrix.dat'' which should be identical with ''trans1matrix.dat'' 
# Study the file ''dna-array.dat'' a bit. This is real DNA array data taken from a number of persons, some controls and some suffering from colon cancer. If you look at the second line there is a lot of 0 and 1. A '0' means that values in that column are from a cancer patient and a '1' means data are from a control (healthy person). The data are all log(intensity), i.e. the logarithm of the measured intensity of the relevant spot on the dna-chip. The data in this file will be used in coming exercises. The data/columns are tab separated. The second item on each line is the accession number for that particular gene. Now make a main function that extracts data from one file and saves it in another, given the accession number, input file ''dna-array.dat'' and output file ''column.tab''. Search in the file for the data concerning that accession number. If it does not find it (you gave a wrong accession no), complain and stop. Otherwise it shall display the data in two tab separated columns. First column shall be the data from the cancer patients, second column for the controls. There are not the same number of sick and healthy people - be able to handle that. 
# The numbers in the input file ''dna-array.dat'' should be normalized between 0 and 1 for each line with an accession number, i.e. normalization only for the individual line - not across the data set. Write the result out in the file ''dna-array-norm.dat'', but NOT the control lines, i.e. lines where the annotation says 'control'. The resulting file will be similar to the original, but control lines are removed and the numbers are different. The problem can (and should) be solved one line at a time. 
# Read the file ''dna-array-norm.dat'' and transform all the numbers less than 0.5 to 0, and numbers at 0.5 or more to 1. Now for each line/accession calculate the average of the control group numbers and the cancer group numbers. If the two averages are more than 0.4 from each other, this is considered significant and the accession should be saved in the file ''regulation.txt'' along with a message '''up''' or '''down''' if it is an up regulation or a down regulation of the cancer group compared to the control. That means each output line looks like "H80240 up" or "H34534 down".

== Exercises for extra practice ==

Python object model

2025-10-14T12:35:39Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Regular expressions]]
|Next: [[Programme]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_13-Objects.ppt Object model and complex data] 
Resource: [[Example code - Complex data]]

== Subjects covered ==
* Python objects
* Identity
* Mutable vs immutable
* Complex data
* Exam format

== Exercises to be handed in ==
'''Important - read this before starting''' 
This exercise set will be similar to the format of the exam. The content will obviously be different. 
You have to download [https://teaching.healthtech.dtu.dk/material/22116/22116_13.py this python file.] It contains some frame work code, but mostly some unfinished functions.
Each exercise is about finishing one of the function groups in the file. You can write the functions directly in the python file, or use VScode or other Jupyter Notebook editor to write it, but then it has to be copied over to the python file. You must hand in the finished python file, '''not''' a .ipynb file. 
Inability to understand or perform this process will make you fail the exam, so it is worth spending some time on the procedure.

# In the file ''test1.dat'' is results from an experiment where every line is in the form: ''AccessionNumber Number Number Number ....'' In the files ''test2.dat'' and ''test3.dat'' are results from similar experiments but with a slightly different gene set. You want find the average the numbers from all experiments for each accession number. Save your results in the file ''combinedresults.txt'' in the form: ''AccessionNumber SingleAverageNumberOfAll3Experiments'' sorted according to the accession. Of course it might happen that a certain gene is only in one or two experiments and in that case you calculate the average for those. You must use a one of complex data structures to store this data, hint hint - a dict of lists. 
# Create a main function that reads a tab separated file with numbers, ''matrix.dat'', (to be understood as a matrix) and stores the numbers in a matrix (list of lists). Having read the matrix from file it should now transpose it (rows to columns and columns to rows) and save the transposed matrix in the file ''trans1matrix.dat''. The output should look like the input, that is '''not''' a python data structure. You must construct a function like transpose(matrix), which gets a matrix as input an returned a transposed matrix - without using any global variables. matrix = transpose(matrix) This is the easiest, but momentarily most memory consuming method, you just return the transposed matrix, i.e. a new data structure. How do you easily check if it works? Well, transposing twice yields the original matrix. [http://en.wikipedia.org/wiki/Transpose Check out Wikipedia's entry on transposing a matrix.] 
# This is the same problem as the previous exercise, except your transpose function have to transpose the matrix in-line, no returned matrix, i.e. the original matrix data structure is changed. transpose(matrix) The output file is this time ''trans2matrix.dat'' which should be identical with ''trans1matrix.dat'' 
# Study the file ''dna-array.dat'' a bit. This is real DNA array data taken from a number of persons, some controls and some suffering from colon cancer. If you look at the second line there is a lot of 0 and 1. A '0' means that values in that column are from a cancer patient and a '1' means data are from a control (healthy person). The data are all log(intensity), i.e. the logarithm of the measured intensity of the relevant spot on the dna-chip. The data in this file will be used in coming exercises. The data/columns are tab separated. The second item on each line is the accession number for that particular gene. Now make a main function that extracts data from one file and saves it in another, given the accession number, input file ''dna-array.dat'' and output file ''column.tab''. Search in the file for the data concerning that accession number. If it does not find it (you gave a wrong accession no), complain and stop. Otherwise it shall display the data in two tab separated columns. First column shall be the data from the cancer patients, second column for the controls. There are not the same number of sick and healthy people - be able to handle that. 
# The numbers in the input file ''dna-array.dat'' should be normalized between 0 and 1 for each line with an accession number, i.e. normalization only for the individual line - not across the data set. Write the result out in the file ''dna-array-norm.dat'', but NOT the control lines, i.e. lines where the annotation says 'control'. The resulting file will be similar to the original, but control lines are removed and the numbers are different. The problem can (and should) be solved one line at a time. 
# Read the file ''dna-array-norm.dat'' and transform all the numbers less than 0.5 to 0, and numbers at 0.5 or more to 1. Now for each line/accession calculate the average of the control group numbers and the cancer group numbers. If the two averages are more than 0.4 from each other, this is considered significant and the accession should be saved in the file ''regulation.txt'' along with a message '''up''' or '''down''' if it is an up regulation or a down regulation of the cancer group compared to the control. That means each output line looks like "H80240 up" or "H34534 down".

== Exercises for extra practice ==

Stateful parsing

2025-10-09T10:51:41Z

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

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Exceptions and bug handling]]
|Next: [[List manipulation]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_06-StatefulParsing.ppt Stateful Parsing] 
Video: [https://panopto.dtu.dk/Panopto/Pages/Viewer.aspx?id=fe50507e-9009-49b1-a3a8-af27012d8cdf Stateful Parsing] 
Video: [https://panopto.dtu.dk/Panopto/Pages/Viewer.aspx?id=ce785005-14cd-424a-a406-af27012b3e1b Finding errors with Stateful Parsing] 


== Subjects covered ==
Using stateful parsing to extract data spanning several lines, by recognizing keywords.

== Exercises to be handed in ==
The following 5 exercises deal with SwissProt. The file sprot1.dat is a SwissProt database entry. Study it carefully. Locate the SwissProt ID (SP96_DICDI), the accession number (P14328) and the amino acid sequence (MRVLLVLVAC....TTTATTTATS). There are other entries ( ''sprot2.dat'', ''sprot3.dat'', ''sprot4.dat''). Your programs should work on those, too. Also your programs must solve all the problems in ONE reading of the file. It is acceptable if you just hand in one program that solves 1 to 4. 5 is separate. These exercises are about studying and understanding the file format.

# Make a program that reads the ID and prints it. Try to use the "walk the line" technique. 
# Add the following functionality to the program: Read the accession number and print it. Again, walk the line. 
# Add the following functionality to the program: Read the amino acid sequence and print it. You really should use stateful parsing in this exercise. Maybe check the video. 
# Add the following functionality to the program: Verification of amino acid number. This means extract the number from the SQ line (example: SQ SEQUENCE 629 AA;) and check that the amino acid sequence has that number of residues. It should be the program that determines if something is wrong - not the user. Imagine that before you go home, you set the computer to run through a million swisprot entries. The next day, you must be able to see what failed. In a sense you don't care about what succeeded, as that is the common case. You care about what failed, because it is here you must take action. 
# Now that you have the ID, accession number and AA sequence save it to a file ''sprot.fsa'' in FASTA format. Look in the file ''dna.fsa'' for an example of FASTA. Notice the first line starts with > and immediately after comes an unique identifier, like an accession number or a SwissProt ID. Any other data must be on the header line only, but in free format. Sequence data is on the following lines. Notice that this exercise incorporates the previous 4, but uses the result in a slightly different way. 
# In reality you never have just one entry in a SwissProt file. The current SwissProt database contains more than half a million entries and it grows all the time. A bioinformatician can access the database by selecting a subset or the whole database as one file for download and extract the needed information from it. In the file ''sprotall.dat'' the 4 sprot files have been collected as a very small example of what you really meet. The exercise is to read all entries in ''sprotall.dat'' and create one fasta file ''sprotall.fsa'' with the ids, accessions and sequence for all entries. In short, just like the previous exercise but for a file that contains more SwissProt entries. And please, don't do anything stupid like reading the entire file into a list and start parsing that. These SwissProt excerpts can get really big and it can kill your computer memory doing that.

== Exercises for extra practice ==
* Count the number of RA (Author) lines in the ''sprot1-4.dat'' files. ''sprot2.dat'' contains 25 RA lines.
* Extract the author names from the RA lines in the ''sprot1-4.dat'' files. Display the names - only the names.
* Continuing previous exercise: Now also extract the title (RT lines). Display like title first on one line, followed by authors on the next. Then empty line followed by the next title and authors and so forth, until no more authors/titles.

Python object model

2025-10-03T14:40:34Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Regular expressions]]
|Next: [[Programme]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_13-Objects.ppt Object model and complex data] 
Resource: [[Example code - Complex data]]

== Subjects covered ==
* Python objects
* Identity
* Mutable vs immutable
* Complex data
* Exam format

== Exercises to be handed in ==
'''Important - read this before starting''' 
This exercise set will be similar to the format of the exam. The content will obviously be different. 
You have to download [https://teaching.healthtech.dtu.dk/material/22116/22116_13.py this python file.] It contains some frame work code, but mostly some unfinished functions.
Each exercise is about finishing one of the function groups in the file. You can write the functions directly in the python file, or use VScode or other Jupyter Notebook editor to write it, but then it has to be copied over to the python file. You must hand in the finished python file, '''not''' a .ipynb file. 
Inability to understand or perform this process will make you fail the exam, so it is worth spending some time on the procedure.

# In the file ''test1.dat'' is results from an experiment where every line is in the form: ''AccessionNumber Number Number Number ....'' In the files ''test2.dat'' and ''test3.dat'' are results from similar experiments but with a slightly different gene set. You want find the average the numbers from all experiments for each accession number. Save your results in the file ''combinedresults.txt'' in the form: ''AccessionNumber SingleAverageNumberOfAll3Experiments'' Of course it might happen that a certain gene is only in one or two experiments and in that case you calculate the average for those. You must use a one of complex data structures to store this data, hint hint - a dict of lists. 
# Create a main function that reads a tab separated file with numbers, ''matrix.dat'', (to be understood as a matrix) and stores the numbers in a matrix (list of lists). Having read the matrix from file it should now transpose it (rows to columns and columns to rows) and save the transposed matrix in the file ''trans1matrix.dat''. The output should look like the input, that is '''not''' a python data structure. You must construct a function like transpose(matrix), which gets a matrix as input an returned a transposed matrix - without using any global variables. matrix = transpose(matrix) This is the easiest, but momentarily most memory consuming method, you just return the transposed matrix, i.e. a new data structure. How do you easily check if it works? Well, transposing twice yields the original matrix. [http://en.wikipedia.org/wiki/Transpose Check out Wikipedia's entry on transposing a matrix.] 
# This is the same problem as the previous exercise, except your transpose function have to transpose the matrix in-line, no returned matrix, i.e. the original matrix data structure is changed. transpose(matrix) The output file is this time ''trans2matrix.dat'' which should be identical with ''trans1matrix.dat'' 
# Study the file ''dna-array.dat'' a bit. This is real DNA array data taken from a number of persons, some controls and some suffering from colon cancer. If you look at the second line there is a lot of 0 and 1. A '0' means that values in that column are from a cancer patient and a '1' means data are from a control (healthy person). The data are all log(intensity), i.e. the logarithm of the measured intensity of the relevant spot on the dna-chip. The data in this file will be used in coming exercises. The data/columns are tab separated. The second item on each line is the accession number for that particular gene. Now make a main function that extracts data from one file and saves it in another, given the accession number, input file ''dna-array.dat'' and output file ''column.tab''. Search in the file for the data concerning that accession number. If it does not find it (you gave a wrong accession no), complain and stop. Otherwise it shall display the data in two tab separated columns. First column shall be the data from the cancer patients, second column for the controls. There are not the same number of sick and healthy people - be able to handle that. 
# The numbers in the input file ''dna-array.dat'' should be normalized between 0 and 1 for each line with an accession number, i.e. normalization only for the individual line - not across the data set. Write the result out in the file ''dna-array-norm.dat'', but NOT the control lines, i.e. lines where the annotation says 'control'. The resulting file will be similar to the original, but control lines are removed and the numbers are different. The problem can (and should) be solved one line at a time. 
# Read the file ''dna-array-norm.dat'' and transform all the numbers less than 0.5 to 0, and numbers at 0.5 or more to 1. Now for each line/accession calculate the average of the control group numbers and the cancer group numbers. If the two averages are more than 0.4 from each other, this is considered significant and the accession should be saved in the file ''regulation.txt'' along with a message '''up''' or '''down''' if it is an up regulation or a down regulation of the cancer group compared to the control. That means each output line looks like "H80240 up" or "H34534 down".

== Exercises for extra practice ==

Python object model

2025-10-03T14:40:12Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Regular expressions]]
|Next: [[Programme]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_13-Objects.ppt Object model and complex data] 
Resource: [[Example code - Complex data]]

== Subjects covered ==
* Python objects
* Identity
* Mutable vs immutable
* Complex data
* Exam format

== Exercises to be handed in ==
'''Important - read this before starting''' 
This exercise set will be similar to the format of the exam. The content will obviously be different. 
You have to download [https://teaching.healthtech.dtu.dk/material/22116/22116_13.py this python file.] It contains some frame work code, but mostly some unfinished functions.
Each exercise is about finishing one of the function groups in the file. You can write the functions directly in the python file, or use VScode or other Jupitor Notebook editor to write it, but then it has to be copied over to the python file. You must hand in the finished python file, '''not''' a .ipynb file. 
Inability to understand or perform this process will make you fail the exam, so it is worth spending some time on the procedure.

# In the file ''test1.dat'' is results from an experiment where every line is in the form: ''AccessionNumber Number Number Number ....'' In the files ''test2.dat'' and ''test3.dat'' are results from similar experiments but with a slightly different gene set. You want find the average the numbers from all experiments for each accession number. Save your results in the file ''combinedresults.txt'' in the form: ''AccessionNumber SingleAverageNumberOfAll3Experiments'' Of course it might happen that a certain gene is only in one or two experiments and in that case you calculate the average for those. You must use a one of complex data structures to store this data, hint hint - a dict of lists. 
# Create a main function that reads a tab separated file with numbers, ''matrix.dat'', (to be understood as a matrix) and stores the numbers in a matrix (list of lists). Having read the matrix from file it should now transpose it (rows to columns and columns to rows) and save the transposed matrix in the file ''trans1matrix.dat''. The output should look like the input, that is '''not''' a python data structure. You must construct a function like transpose(matrix), which gets a matrix as input an returned a transposed matrix - without using any global variables. matrix = transpose(matrix) This is the easiest, but momentarily most memory consuming method, you just return the transposed matrix, i.e. a new data structure. How do you easily check if it works? Well, transposing twice yields the original matrix. [http://en.wikipedia.org/wiki/Transpose Check out Wikipedia's entry on transposing a matrix.] 
# This is the same problem as the previous exercise, except your transpose function have to transpose the matrix in-line, no returned matrix, i.e. the original matrix data structure is changed. transpose(matrix) The output file is this time ''trans2matrix.dat'' which should be identical with ''trans1matrix.dat'' 
# Study the file ''dna-array.dat'' a bit. This is real DNA array data taken from a number of persons, some controls and some suffering from colon cancer. If you look at the second line there is a lot of 0 and 1. A '0' means that values in that column are from a cancer patient and a '1' means data are from a control (healthy person). The data are all log(intensity), i.e. the logarithm of the measured intensity of the relevant spot on the dna-chip. The data in this file will be used in coming exercises. The data/columns are tab separated. The second item on each line is the accession number for that particular gene. Now make a main function that extracts data from one file and saves it in another, given the accession number, input file ''dna-array.dat'' and output file ''column.tab''. Search in the file for the data concerning that accession number. If it does not find it (you gave a wrong accession no), complain and stop. Otherwise it shall display the data in two tab separated columns. First column shall be the data from the cancer patients, second column for the controls. There are not the same number of sick and healthy people - be able to handle that. 
# The numbers in the input file ''dna-array.dat'' should be normalized between 0 and 1 for each line with an accession number, i.e. normalization only for the individual line - not across the data set. Write the result out in the file ''dna-array-norm.dat'', but NOT the control lines, i.e. lines where the annotation says 'control'. The resulting file will be similar to the original, but control lines are removed and the numbers are different. The problem can (and should) be solved one line at a time. 
# Read the file ''dna-array-norm.dat'' and transform all the numbers less than 0.5 to 0, and numbers at 0.5 or more to 1. Now for each line/accession calculate the average of the control group numbers and the cancer group numbers. If the two averages are more than 0.4 from each other, this is considered significant and the accession should be saved in the file ''regulation.txt'' along with a message '''up''' or '''down''' if it is an up regulation or a down regulation of the cancer group compared to the control. That means each output line looks like "H80240 up" or "H34534 down".

== Exercises for extra practice ==

Python object model

2025-10-03T14:37:18Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Regular expressions]]
|Next: [[Programme]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_13-Objects.ppt Object model and complex data] 
Resource: [[Example code - Complex data]]

== Subjects covered ==
* Python objects
* Identity
* Mutable vs immutable
* Complex data
* Exam format

== Exercises to be handed in ==
'''Important - read this before starting''' 
This exercise set will be similar to the format of the exam. The content will obviously be different. 
You have to download [https://teaching.healthtech.dtu.dk/material/22116/22116_13.py this python file.] It contains some frame work code, but mostly some unfinished functions.
Each exercise is about finishing one of the functions in the file. You can write the function directly in the python file, or use VScode or other editor to write it, but then it has to be copied over to the python file. You must hand in the finished python file, '''not''' a .ipynb file. 
Inability to understand or do this will make you fail the exam, so it is worth spending some time on the process.

# In the file ''test1.dat'' is results from an experiment where every line is in the form: ''AccessionNumber Number Number Number ....'' In the files ''test2.dat'' and ''test3.dat'' are results from similar experiments but with a slightly different gene set. You want find the average the numbers from all experiments for each accession number. Save your results in the file ''combinedresults.txt'' in the form: ''AccessionNumber SingleAverageNumberOfAll3Experiments'' Of course it might happen that a certain gene is only in one or two experiments and in that case you calculate the average for those. You must use a one of complex data structures to store this data, hint hint - a dict of lists. 
# Create a main function that reads a tab separated file with numbers, ''matrix.dat'', (to be understood as a matrix) and stores the numbers in a matrix (list of lists). Having read the matrix from file it should now transpose it (rows to columns and columns to rows) and save the transposed matrix in the file ''trans1matrix.dat''. The output should look like the input, that is '''not''' a python data structure. You must construct a function like transpose(matrix), which gets a matrix as input an returned a transposed matrix - without using any global variables. matrix = transpose(matrix) This is the easiest, but momentarily most memory consuming method, you just return the transposed matrix, i.e. a new data structure. How do you easily check if it works? Well, transposing twice yields the original matrix. [http://en.wikipedia.org/wiki/Transpose Check out Wikipedia's entry on transposing a matrix.] 
# This is the same problem as the previous exercise, except your transpose function have to transpose the matrix in-line, no returned matrix, i.e. the original matrix data structure is changed. transpose(matrix) The output file is this time ''trans2matrix.dat'' which should be identical with ''trans1matrix.dat'' 
# Study the file ''dna-array.dat'' a bit. This is real DNA array data taken from a number of persons, some controls and some suffering from colon cancer. If you look at the second line there is a lot of 0 and 1. A '0' means that values in that column are from a cancer patient and a '1' means data are from a control (healthy person). The data are all log(intensity), i.e. the logarithm of the measured intensity of the relevant spot on the dna-chip. The data in this file will be used in coming exercises. The data/columns are tab separated. The second item on each line is the accession number for that particular gene. Now make a main function that extracts data from one file and saves it in another, given the accession number, input file ''dna-array.dat'' and output file ''column.tab''. Search in the file for the data concerning that accession number. If it does not find it (you gave a wrong accession no), complain and stop. Otherwise it shall display the data in two tab separated columns. First column shall be the data from the cancer patients, second column for the controls. There are not the same number of sick and healthy people - be able to handle that. 
# The numbers in the input file ''dna-array.dat'' should be normalized between 0 and 1 for each line with an accession number, i.e. normalization only for the individual line - not across the data set. Write the result out in the file ''dna-array-norm.dat'', but NOT the control lines, i.e. lines where the annotation says 'control'. The resulting file will be similar to the original, but control lines are removed and the numbers are different. The problem can (and should) be solved one line at a time. 
# Read the file ''dna-array-norm.dat'' and transform all the numbers less than 0.5 to 0, and numbers at 0.5 or more to 1. Now for each line/accession calculate the average of the control group numbers and the cancer group numbers. If the two averages are more than 0.4 from each other, this is considered significant and the accession should be saved in the file ''regulation.txt'' along with a message '''up''' or '''down''' if it is an up regulation or a down regulation of the cancer group compared to the control. That means each output line looks like "H80240 up" or "H34534 down".

== Exercises for extra practice ==

Python object model

2025-10-03T14:33:41Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Regular expressions]]
|Next: [[Programme]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_13-Objects.ppt Object model and complex data] 
Resource: [[Example code - Complex data]]

== Subjects covered ==
* Python objects
* Identity
* Mutable vs immutable
* Complex data
* Exam format

== Exercises to be handed in ==
'''Important - read this before starting''' 
This exercise set will be similar to the format of the exam. The content will obviously be different. 
You have to download this python file. It contains some frame work code, but mostly some unfinished functions.
Each exercise is about finishing one of the functions in the file. You can write the function directly in the python file, or use VScode or other editor to write it, but then it has to be copied over to the python file. You must hand in the finished python file, '''not''' a .ipynb file. 
Inability to understand or do this will make you fail the exam, so it is worth spending some time on the process.

# In the file ''test1.dat'' is results from an experiment where every line is in the form: ''AccessionNumber Number Number Number ....'' In the files ''test2.dat'' and ''test3.dat'' are results from similar experiments but with a slightly different gene set. You want find the average the numbers from all experiments for each accession number. Save your results in the file ''combinedresults.txt'' in the form: ''AccessionNumber SingleAverageNumberOfAll3Experiments'' Of course it might happen that a certain gene is only in one or two experiments and in that case you calculate the average for those. You must use a one of complex data structures to store this data, hint hint - a dict of lists. 
# Create a main function that reads a tab separated file with numbers, ''matrix.dat'', (to be understood as a matrix) and stores the numbers in a matrix (list of lists). Having read the matrix from file it should now transpose it (rows to columns and columns to rows) and save the transposed matrix in the file ''trans1matrix.dat''. The output should look like the input, that is '''not''' a python data structure. You must construct a function like transpose(matrix), which gets a matrix as input an returned a transposed matrix - without using any global variables. matrix = transpose(matrix) This is the easiest, but momentarily most memory consuming method, you just return the transposed matrix, i.e. a new data structure. How do you easily check if it works? Well, transposing twice yields the original matrix. [http://en.wikipedia.org/wiki/Transpose Check out Wikipedia's entry on transposing a matrix.] 
# This is the same problem as the previous exercise, except your transpose function have to transpose the matrix in-line, no returned matrix, i.e. the original matrix data structure is changed. transpose(matrix) The output file is this time ''trans2matrix.dat'' which should be identical with ''trans1matrix.dat'' 
# Study the file ''dna-array.dat'' a bit. This is real DNA array data taken from a number of persons, some controls and some suffering from colon cancer. If you look at the second line there is a lot of 0 and 1. A '0' means that values in that column are from a cancer patient and a '1' means data are from a control (healthy person). The data are all log(intensity), i.e. the logarithm of the measured intensity of the relevant spot on the dna-chip. The data in this file will be used in coming exercises. The data/columns are tab separated. The second item on each line is the accession number for that particular gene. Now make a main function that extracts data from one file and saves it in another, given the accession number, input file ''dna-array.dat'' and output file ''column.tab''. Search in the file for the data concerning that accession number. If it does not find it (you gave a wrong accession no), complain and stop. Otherwise it shall display the data in two tab separated columns. First column shall be the data from the cancer patients, second column for the controls. There are not the same number of sick and healthy people - be able to handle that. 
# The numbers in the input file ''dna-array.dat'' should be normalized between 0 and 1 for each line with an accession number, i.e. normalization only for the individual line - not across the data set. Write the result out in the file ''dna-array-norm.dat'', but NOT the control lines, i.e. lines where the annotation says 'control'. The resulting file will be similar to the original, but control lines are removed and the numbers are different. The problem can (and should) be solved one line at a time. 
# Read the file ''dna-array-norm.dat'' and transform all the numbers less than 0.5 to 0, and numbers at 0.5 or more to 1. Now for each line/accession calculate the average of the control group numbers and the cancer group numbers. If the two averages are more than 0.4 from each other, this is considered significant and the accession should be saved in the file ''regulation.txt'' along with a message '''up''' or '''down''' if it is an up regulation or a down regulation of the cancer group compared to the control. That means each output line looks like "H80240 up" or "H34534 down".

== Exercises for extra practice ==

Python object model

2025-10-03T14:30:14Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Regular expressions]]
|Next: [[Programme]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_13-Objects.ppt Object model and complex data] 
Resource: [[Example code - Complex data]]

== Subjects covered ==
* Python objects
* Identity
* Mutable vs immutable
* Complex data
* Exam format

== Exercises to be handed in ==
'''Important - read this before starting''' 
This exercise set will be similar to the format of the exam. The content will obviously be different. 
You have to download this python file. It contains some frame work code, but mostly some unfinished functions.
Each exercise is about finishing one of the functions in the file. You can write the function directly in the python file, or use VScode or other editor to write it, but then it has to be copied over to the python file. You must hand in the finished python file, '''not''' a .ipynb file. 
Inability to understand or do this will make you fail the exam, so it is worth spending some time on the process.

# In the file ''test1.dat'' is results from an experiment where every line is in the form: ''AccessionNumber Number Number Number ....'' In the files ''test2.dat'' and ''test3.dat'' are results from similar experiments but with a slightly different gene set. You want find the average the numbers from all experiments for each accession number. Save your results in the file ''combinedresults.txt'' in the form: ''AccessionNumber SingleAverageNumberOfAll3Experiments'' Of course it might happen that a certain gene is only in one or two experiments and in that case you calculate the average for those. You must use a one of complex data structures to store this data, hint hint - a dict of lists. 
# Create a main function that reads a tab separated file with numbers, ''matrix.dat'', (to be understood as a matrix) and stores the numbers in a matrix (list of lists). Having read the matrix from file it should now transpose it (rows to columns and columns to rows) and save the transposed matrix in the file ''trans1matrix.dat''. The output should look like the input, that is '''not''' a python data structure. You must construct a function like transpose(matrix), which gets a matrix as input an returned a transposed matrix - without using any global variables. matrix = transpose(matrix) This is the easiest, but momentarily most memory consuming method, you just return the transposed matrix, i.e. a new data structure. How do you easily check if it works? Well, transposing twice yields the original matrix. [http://en.wikipedia.org/wiki/Transpose Check out Wikipedia's entry on transposing a matrix.] 
# This is the same problem as the previous exercise, except your transpose function have to transpose the matrix in-line, no returned matrix, i.e. the original matrix data structure is changed. transpose(matrix) The output file is this time ''trans2matrix.dat'' which should be identical with ''trans1matrix.dat'' 
# Study the file ''dna-array.dat'' a bit. This is real DNA array data taken from a number of persons, some controls and some suffering from colon cancer. If you look at the second line there is a lot of 0 and 1. A '0' means that values in that column are from a cancer patient and a '1' means data are from a control (healthy person). The data are all log(intensity), i.e. the logarithm of the measured intensity of the relevant spot on the dna-chip. The data in this file will be used in coming exercises. The data/columns are tab separated. The second item on each line is the accession number for that particular gene. Now make a main function that extracts data from one file and saves it in another, given the accession number, input file ''dna-array.dat'' and output file ''column.tab''. Search in the file for the data concerning that accession number. If it does not find it (you gave a wrong accession no), complain and stop. Otherwise it shall display the data in two tab separated columns. First column shall be the data from the cancer patients, second column for the controls. There are not the same number of sick and healthy people - be able to handle that. 
# The numbers in the input file ''dna-array.dat'' should be normalized between 0 and 1 for each line with an accession number, i.e. normalization only for the individual line - not across the data set. Write the result out in the file ''dna-array-norm.dat'', but NOT the control lines, i.e. lines where the annotation says 'control'. The resulting file will be similar to the original, but control lines are removed and the numbers are different. The problem can (and should) be solved one line at a time. 
# Read the file ''dna-array-norm.dat'' and transform all the numbers less than 0.5 to 0, and numbers at 0.5 or more to 1. Now for each line/accession calculate the average of the control group numbers and the cancer group numbers. If the two averages are more than 0.4 from each other, this is considered significant and the accession should be printed along with a message '''up''' or '''down''' if it is an up regulation or a down regulation of the cancer group compared to the control.

== Exercises for extra practice ==

Python object model

2025-10-03T14:22:49Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Regular expressions]]
|Next: [[Programme]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_13-Objects.ppt Object model and complex data] 
Resource: [[Example code - Complex data]]

== Subjects covered ==
* Python objects
* Identity
* Mutable vs immutable
* Complex data
* Exam format

== Exercises to be handed in ==
'''Important - read this before starting''' 
This exercise set will be similar to the format of the exam. The content will obviously be different. 
You have to download this python file. It contains some frame work code, but mostly some unfinished functions.
Each exercise is about finishing one of the functions in the file. You can write the function directly in the python file, or use VScode or other editor to write it, but then it has to be copied over to the python file. You must hand in the finished python file, '''not''' a .ipynb file. 
Inability to understand or do this will make you fail the exam, so it is worth spending some time on the process.

# In the file ''test1.dat'' is results from an experiment where every line is in the form: ''AccessionNumber Number Number Number ....'' In the files ''test2.dat'' and ''test3.dat'' are results from similar experiments but with a slightly different gene set. You want find the average the numbers from all experiments for each accession number. Save your results in the file ''combinedresults.txt'' in the form: ''AccessionNumber SingleAverageNumberOfAll3Experiments'' Of course it might happen that a certain gene is only in one or two experiments and in that case you calculate the average for those. You must use a one of complex data structures to store this data, hint hint - a dict of lists. 
# Create a program that reads a tab separated file with numbers, ''matrix.dat'', (to be understood as a matrix) and stores the numbers in a matrix (list of lists). Having read the matrix from file it should now transpose it (rows to columns and columns to rows) and save the transposed matrix in the file ''trans1matrix.dat''. The output should look like the input, that is '''not''' a python data structure. You must construct a function like transpose(matrix), which gets a matrix as input an returned a transposed matrix - without using any global variables. matrix = transpose(matrix) This is the easiest, but momentarily most memory consuming method, you just return the transposed matrix, i.e. a new data structure. How do you easily check if it works? Well, transposing twice yields the original matrix. [http://en.wikipedia.org/wiki/Transpose Check out Wikipedia's entry on transposing a matrix.] 
# This is the same problem as the previous exercise, except your transpose function have to transpose the matrix in-line, no returned matrix, i.e. the original matrix data structure is changed. transpose(matrix) The output file is this time ''trans2matrix.dat'' which should be identical with ''trans1matrix.dat'' 
# Study the file ''dna-array.dat'' a bit. This is real DNA array data taken from a number of persons, some controls and some suffering from colon cancer. If you look at the second line there is a lot of 0 and 1. A '0' means that values in that column are from a cancer patient and a '1' means data are from a control (healthy person). The data are all log(intensity), i.e. the logarithm of the measured intensity of the relevant spot on the dna-chip. The data in this file will be used in coming exercises. The data/columns are tab separated. The second item on each line is the accession number for that particular gene. Now make a program that extracts data from ''dna-array.dat''. It shall ask for an accession number (unless you have given it on the command line). Make sure your program handles both situations. Then it shall search in the file for the data concerning that accession number. If it does not find it (you gave a wrong accession no), complain and stop. Otherwise it shall display the data in two tab separated columns. First column shall be the data from the cancer patients, second column for the controls. There are not the same number of sick and healthy people - be able to handle that. 
# The numbers in the input file ''dna-array.dat'' should be normalized between 0 and 1 for each line with an accession number, i.e. normalization only for the individual line - not across the data set. Write the result out in the file ''dna-array-norm.dat'', but NOT the control lines, i.e. lines where the annotation says 'control'. The resulting file will be similar to the original, but control lines are removed and the numbers are different. The problem can (and should) be solved one line at a time. 
# Read the file ''dna-array-norm.dat'' and transform all the numbers less than 0.5 to 0, and numbers at 0.5 or more to 1. Now for each line/accession calculate the average of the control group numbers and the cancer group numbers. If the two averages are more than 0.4 from each other, this is considered significant and the accession should be printed along with a message '''up''' or '''down''' if it is an up regulation or a down regulation of the cancer group compared to the control.

== Exercises for extra practice ==

Python object model

2025-10-03T14:21:14Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Regular expressions]]
|Next: [[Programme]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_13-Objects.ppt Object model and complex data] 
Resource: [[Example code - Complex data]]

== Subjects covered ==
* Python objects
* Identity
* Mutable vs immutable
* Complex data
* Exam format

== Exercises to be handed in ==
'''Important - read this before starting''' 
This exercise set will be similar to the format of the exam. The content will obviously be different. 
You have to download this python file. It contains some frame work code, but mostly some unfinished functions.
Each exercise is about finishing one of the functions in the file. You can write the function directly in the python file, or use VScode or other editor to write it, but then it has to be copied over to the python file. You must hand in the finished python file, '''not''' a .ipynb file. 
Inability to understand or do this will make you fail the exam, so it is worth spending some time on the process.

# In the file ''test1.dat'' is results from an experiment where every line is in the form: ''AccessionNumber Number Number Number ....'' In the files ''test2.dat'' and ''test3.dat'' are results from similar experiments but with a slightly different gene set. You want find the average the numbers from all experiments for each accession number. Save your results in the file ''combinedresults.txt'' in the form: ''AccessionNumber SingleAverageNumberOfAll3Experiments'' Of course it might happen that a certain gene is only in one or two experiments and in that case you calculate the average for those. You must use a one of complex data structures to store this data, hint hint - a dict of lists. 
# Create a program that reads a tab separated file with numbers, ''matrix.dat'', (to be understood as a matrix) and stores the numbers in a matrix (list of lists). Having read the matrix from file it should now transpose it (rows to columns and columns to rows) and save the transposed matrix in the file ''trans1matrix.dat''. The output should look like the input, that is '''not''' a python data structure. You must construct a function like transpose(matrix), which gets a matrix as input an returned a transposed matrix - without using any global variables. matrix = transpose(matrix) This is the easiest, but momentarily most memory consuming method, you just return the transposed matrix, i.e. a new data structure. How do you easily check if it works? Well, transposing twice yields the original matrix. [http://en.wikipedia.org/wiki/Transpose Check out Wikipedia's entry on transposing a matrix.] 
# This is the same problem as the previous exercise, except your transpose function have to transpose the matrix in-line, no returned matrix, i.e. the original matrix data structure is changed. transpose(matrix) 
# Study the file ''dna-array.dat'' a bit. This is real DNA array data taken from a number of persons, some controls and some suffering from colon cancer. If you look at the second line there is a lot of 0 and 1. A '0' means that values in that column are from a cancer patient and a '1' means data are from a control (healthy person). The data are all log(intensity), i.e. the logarithm of the measured intensity of the relevant spot on the dna-chip. The data in this file will be used in coming exercises. The data/columns are tab separated. The second item on each line is the accession number for that particular gene. Now make a program that extracts data from ''dna-array.dat''. It shall ask for an accession number (unless you have given it on the command line). Make sure your program handles both situations. Then it shall search in the file for the data concerning that accession number. If it does not find it (you gave a wrong accession no), complain and stop. Otherwise it shall display the data in two tab separated columns. First column shall be the data from the cancer patients, second column for the controls. There are not the same number of sick and healthy people - be able to handle that. 
# The numbers in the input file ''dna-array.dat'' should be normalized between 0 and 1 for each line with an accession number, i.e. normalization only for the individual line - not across the data set. Write the result out in the file ''dna-array-norm.dat'', but NOT the control lines, i.e. lines where the annotation says 'control'. The resulting file will be similar to the original, but control lines are removed and the numbers are different. The problem can (and should) be solved one line at a time. 
# Read the file ''dna-array-norm.dat'' and transform all the numbers less than 0.5 to 0, and numbers at 0.5 or more to 1. Now for each line/accession calculate the average of the control group numbers and the cancer group numbers. If the two averages are more than 0.4 from each other, this is considered significant and the accession should be printed along with a message '''up''' or '''down''' if it is an up regulation or a down regulation of the cancer group compared to the control.

== Exercises for extra practice ==

Python object model

2025-10-03T14:10:55Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Regular expressions]]
|Next: [[Programme]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_13-Objects.ppt Object model and complex data] 
Resource: [[Example code - Complex data]]

== Subjects covered ==
* Python objects
* Identity
* Mutable vs immutable
* Complex data
* Exam format

== Exercises to be handed in ==
'''Important - read this before starting''' 
This exercise set will be similar to the format of the exam. The content will obviously be different. 
You have to download this python file. It contains some frame work code, but mostly some unfinished functions.
Each exercise is about finishing one of the functions in the file. You can write the function directly in the python file, or use VScode or other editor to write it, but then it has to be copied over to the python file. You must hand in the finished python file, '''not''' a .ipynb file. 
Inability to understand or do this will make you fail the exam, so it is worth spending some time on the process.

# In the file ''test1.dat'' is results from an experiment where every line is in the form: ''AccessionNumber Number Number Number ....'' In the files ''test2.dat'' and ''test3.dat'' are results from similar experiments but with a slightly different gene set. You want find the average the numbers from all experiments for each accession number. Save your results in the file ''combinedresults.txt'' in the form: ''AccessionNumber SingleAverageNumberOfAll3Experiments'' Of course it might happen that a certain gene is only in one or two experiments and in that case you calculate the average for those. You must use a one of complex data structures to store this data, hint hint - a dict of lists. 
# Create a program that reads a tab separated file with numbers, ''matrix.dat'', (to be understood as a matrix) and stores the numbers in a matrix (list of lists). Having read the matrix from file it should now transpose it (rows to columns and columns to rows) and in the end print the transposed matrix to the screen. The output should look like the input, not a python data structure. You must construct a function like transpose(matrix), which transpose the matix without using any global variables. This can be done in two ways. '''a)''' matrix = transpose(matrix) This is the easiest, but momentarily most memory consuming method, you just return the transposed matrix, i.e. a new data structure. '''b)''' transpose(matrix) Here the matrix is transposed in-line, no returned matrix, i.e. the original data structure is changed. You have implement at least one of the two ways. Hint: Make a function that prints a given matrix. That will be useful underway. How do you easily check if it works? Well, transposing twice yields the original matrix. [http://en.wikipedia.org/wiki/Transpose Check out Wikipedia's entry on transposing a matrix.] 
# Study the file ''dna-array.dat'' a bit. This is real DNA array data taken from a number of persons, some controls and some suffering from colon cancer. If you look at the second line there is a lot of 0 and 1. A '0' means that values in that column are from a cancer patient and a '1' means data are from a control (healthy person). The data are all log(intensity), i.e. the logarithm of the measured intensity of the relevant spot on the dna-chip. The data in this file will be used in coming exercises. The data/columns are tab separated. The second item on each line is the accession number for that particular gene. Now make a program that extracts data from ''dna-array.dat''. It shall ask for an accession number (unless you have given it on the command line). Make sure your program handles both situations. Then it shall search in the file for the data concerning that accession number. If it does not find it (you gave a wrong accession no), complain and stop. Otherwise it shall display the data in two tab separated columns. First column shall be the data from the cancer patients, second column for the controls. There are not the same number of sick and healthy people - be able to handle that. 
# The numbers in the input file ''dna-array.dat'' should be normalized between 0 and 1 for each line with an accession number, i.e. normalization only for the individual line - not across the data set. Write the result out in the file ''dna-array-norm.dat'', but NOT the control lines, i.e. lines where the annotation says 'control'. The resulting file will be similar to the original, but control lines are removed and the numbers are different. The problem can (and should) be solved one line at a time. 
# Read the file ''dna-array-norm.dat'' and transform all the numbers less than 0.5 to 0, and numbers at 0.5 or more to 1. Now for each line/accession calculate the average of the control group numbers and the cancer group numbers. If the two averages are more than 0.4 from each other, this is considered significant and the accession should be printed along with a message '''up''' or '''down''' if it is an up regulation or a down regulation of the cancer group compared to the control.

== Exercises for extra practice ==

Python object model

2025-10-03T14:08:08Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Regular expressions]]
|Next: [[Programme]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_13-Objects.ppt Object model and complex data] 
Resource: [[Example code - Complex data]]

== Subjects covered ==
* Python objects
* Identity
* Mutable vs immutable
* Complex data
* Exam format

== Exercises to be handed in ==
'''Important - read this before starting''' 
This exercise set will be similar to the format of the exam. The content will obviously be different. 
You have to download this python file. It contains some frame work code, but mostly some unfinished functions.
Each exercise is about finishing one of the functions in the file. You can write the function directly in the python file, or use VScode or other editor to write it, but then it has to be copied over to the python file. You must hand in the finished python file, '''not''' a .ipynb file. 
Inability to understand or do this will make you fail the exam, so it is worth spending some time on the process.

# In the file ''test1.dat'' is results from an experiment where every line is in the form: ''AccessionNumber Number Number Number ....'' In the files ''test2.dat'' and ''test3.dat'' are results from similar experiments but with a slightly different gene set. You want to average the numbers from all experiments for each accession number. The output this therefore on the form: ''AccessionNumber SingleAverageNumberOfAll3Experiments'' Of course it might happen that a certain gene is only in one or two experiments and in that case you calculate the average for those. You must use a one of complex data structures to store this data, hint hint - a dict of lists. 
# Create a program that reads a tab separated file with numbers, ''matrix.dat'', (to be understood as a matrix) and stores the numbers in a matrix (list of lists). Having read the matrix from file it should now transpose it (rows to columns and columns to rows) and in the end print the transposed matrix to the screen. The output should look like the input, not a python data structure. You must construct a function like transpose(matrix), which transpose the matix without using any global variables. This can be done in two ways. '''a)''' matrix = transpose(matrix) This is the easiest, but momentarily most memory consuming method, you just return the transposed matrix, i.e. a new data structure. '''b)''' transpose(matrix) Here the matrix is transposed in-line, no returned matrix, i.e. the original data structure is changed. You have implement at least one of the two ways. Hint: Make a function that prints a given matrix. That will be useful underway. How do you easily check if it works? Well, transposing twice yields the original matrix. [http://en.wikipedia.org/wiki/Transpose Check out Wikipedia's entry on transposing a matrix.] 
# Study the file ''dna-array.dat'' a bit. This is real DNA array data taken from a number of persons, some controls and some suffering from colon cancer. If you look at the second line there is a lot of 0 and 1. A '0' means that values in that column are from a cancer patient and a '1' means data are from a control (healthy person). The data are all log(intensity), i.e. the logarithm of the measured intensity of the relevant spot on the dna-chip. The data in this file will be used in coming exercises. The data/columns are tab separated. The second item on each line is the accession number for that particular gene. Now make a program that extracts data from ''dna-array.dat''. It shall ask for an accession number (unless you have given it on the command line). Make sure your program handles both situations. Then it shall search in the file for the data concerning that accession number. If it does not find it (you gave a wrong accession no), complain and stop. Otherwise it shall display the data in two tab separated columns. First column shall be the data from the cancer patients, second column for the controls. There are not the same number of sick and healthy people - be able to handle that. 
# The numbers in the input file ''dna-array.dat'' should be normalized between 0 and 1 for each line with an accession number, i.e. normalization only for the individual line - not across the data set. Write the result out in the file ''dna-array-norm.dat'', but NOT the control lines, i.e. lines where the annotation says 'control'. The resulting file will be similar to the original, but control lines are removed and the numbers are different. The problem can (and should) be solved one line at a time. 
# Read the file ''dna-array-norm.dat'' and transform all the numbers less than 0.5 to 0, and numbers at 0.5 or more to 1. Now for each line/accession calculate the average of the control group numbers and the cancer group numbers. If the two averages are more than 0.4 from each other, this is considered significant and the accession should be printed along with a message '''up''' or '''down''' if it is an up regulation or a down regulation of the cancer group compared to the control.

== Exercises for extra practice ==

Python object model

2025-10-03T14:00:10Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Regular expressions]]
|Next: [[Programme]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_13-Objects.ppt Object model and complex data] 
Resource: [[Example code - Complex data]]

== Subjects covered ==
* Python objects
* Identity
* Mutable vs immutable
* Complex data
* Exam format

== Exercises to be handed in ==
'''Important - read this before starting''' 
This exercise set will be similar to the format of the exam. The content will obviously be different. 
You have to download this python file. It contains some frame work code, but mostly some unfinished functions.
Each exercise is about finishing one of the functions in the file. You can write the function directly in the python file, or use VScode or other editor to write it, but then it has to be copied over to the python file. You must hand in the finished python file, '''not''' a .ipynb file. 
Inability to understand or do this will make you fail the exam, so it is worth spending some time on the process.

# In the file ''test1.dat'' is results from an experiment where every line is in the form: ''AccessionNumber Number Number Number ....'' In the files ''test2.dat'' and ''test3.dat'' are results from similar experiments but with a slightly different gene set. You want to average the numbers from all experiments for each accession number. The output this therefore on the form: ''AccessionNumber SingleAverageNumberOfAll3Experiments'' Of course it might happen that a certain gene is only in one or two experiments and in that case you calculate the average for those. You must use a one of complex data structures to store this data, preferably a dict of lists. OPTIONAL: If you have time and inclination, then you can also solve this using simple one-dimensional structures. 
# Create a program that reads a tab separated file with numbers, ''matrix.dat'', (to be understood as a matrix) and stores the numbers in a matrix (list of lists). Having read the matrix from file it should now transpose it (rows to columns and columns to rows) and in the end print the transposed matrix to the screen. The output should look like the input, not a python data structure. You must construct a function like transpose(matrix), which transpose the matix without using any global variables. This can be done in two ways. '''a)''' matrix = transpose(matrix) This is the easiest, but momentarily most memory consuming method, you just return the transposed matrix, i.e. a new data structure. '''b)''' transpose(matrix) Here the matrix is transposed in-line, no returned matrix, i.e. the original data structure is changed. You have implement at least one of the two ways. Hint: Make a function that prints a given matrix. That will be useful underway. How do you easily check if it works? Well, transposing twice yields the original matrix. [http://en.wikipedia.org/wiki/Transpose Check out Wikipedia's entry on transposing a matrix.] 
# Study the file ''dna-array.dat'' a bit. This is real DNA array data taken from a number of persons, some controls and some suffering from colon cancer. If you look at the second line there is a lot of 0 and 1. A '0' means that values in that column are from a cancer patient and a '1' means data are from a control (healthy person). The data are all log(intensity), i.e. the logarithm of the measured intensity of the relevant spot on the dna-chip. The data in this file will be used in coming exercises. The data/columns are tab separated. The second item on each line is the accession number for that particular gene. Now make a program that extracts data from ''dna-array.dat''. It shall ask for an accession number (unless you have given it on the command line). Make sure your program handles both situations. Then it shall search in the file for the data concerning that accession number. If it does not find it (you gave a wrong accession no), complain and stop. Otherwise it shall display the data in two tab separated columns. First column shall be the data from the cancer patients, second column for the controls. There are not the same number of sick and healthy people - be able to handle that. 
# The numbers in the input file ''dna-array.dat'' should be normalized between 0 and 1 for each line with an accession number, i.e. normalization only for the individual line - not across the data set. Write the result out in the file ''dna-array-norm.dat'', but NOT the control lines, i.e. lines where the annotation says 'control'. The resulting file will be similar to the original, but control lines are removed and the numbers are different. The problem can (and should) be solved one line at a time. 
# Read the file ''dna-array-norm.dat'' and transform all the numbers less than 0.5 to 0, and numbers at 0.5 or more to 1. Now for each line/accession calculate the average of the control group numbers and the cancer group numbers. If the two averages are more than 0.4 from each other, this is considered significant and the accession should be printed along with a message '''up''' or '''down''' if it is an up regulation or a down regulation of the cancer group compared to the control.

== Exercises for extra practice ==

Regular expressions

2025-10-03T13:59:33Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Dict techniques]]
|Next: [[Python object model]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_12-Regex.ppt Regular expressions in Python] 

Video: [https://panopto.dtu.dk/Panopto/Pages/Viewer.aspx?id=738d525b-a6c1-4973-b6cc-af27012ca86e An (unfortunately) true story] 
Resource: [[Example code - Regex]] 
Video: [https://panopto.dtu.dk/Panopto/Pages/Viewer.aspx?id=2952d382-7059-4691-8170-af27012bc9a1 Live Coding] 
PDF: [https://teaching.healthtech.dtu.dk/material/22116/regular-expressions-cheat-sheet-v2.pdf Regular Expressions Cheat Sheet] 
WWW: [http://regex101.com/ Web page where you can test your regular expressions] 

== Subjects covered ==
* Regular expressions, duh.
* Patterns, how to design and use them - and not use them.

== Exercises to be handed in ==
Exercise 6 to 8 has strong taste of something I would do at an exam. It is also an interesting beginning of the making a HIV vaccine. The data is real and the methods are real.

# Make a program that accepts a string as input from the keyboard. Use regular expressions (RE) to determine if the input is a number. The goal is to do this with a SINGLE regex. These should all be considered as numbers: "4" "-7" "0.656" "-67.35555" These are not numbers: "5." "56F" ".32" "-.04" "1+1" Note: The program is very simple, but it is likely the most difficult regular expression, you will have to make in this set of exercises. Perhaps you should do the following exercises before attempting this one - just to get some experience first. 
# Regex is often used for validation. This time make a small program that ask for an email address, and checks if it is in a proper format. Quite similar to the previous exercise, just a different thing to validate. 
# Make a program that can read and verify a fasta file. Use your previous function '''fastaread()''' Test the program with ''dna7.fsa'' and ''dnanoise.fsa''. Verification here means that the program prints "DNA fasta" or "Protein fasta" if the file is successfully verified for either dna or protein sequence, and "Not fasta" if unsuccessfully verified. You can find a description of fasta format in [[Biological knowledge needed in the course]]. You are expected to know which symbols are used for DNA and protein sequence - or that you are able to look it up. 
# Building on your experience with the previous exercise, make a program that reads a fasta file, discard entries that can not conform to DNA or protein sequence, and rewrite (using your '''fastawrite()''' function) the acceptable entries in the output file ''fastaout.fsa'', in such a way that the normal 60 chars per line is followed with no spaces in between. The program must inform the user how many entries was kept and how many discarded. Hint: Test on ''dnanoise.fsa'', which contains 3 entries that should be discarded (V00179, J00265, J02989). 
# [[File:consensus.png|50px|right]] In the file ''alignment.fsa'' is a protein alignment of part of the insulin gene from different organisms. Read the fasta file and determine the consensus sequence of the alignment, which you print. The consensus sequence is simply the most frequent occurring amino acid on each position. Consensus: MALWMRLLPLLALLALWEPDPAGAFVNGHLCGSHLVEALYLVCGERGFFYTPKSRREVEDPGVGGLELGGGP 
# All HIV envelope proteins from various HIV strains in SwissProt have been identified and collected in the file ''HIVenvelope.txt''. Using regular repressions you must extract the ID and the protein sequence from each entry and save them in a fasta file named ''HIVenv.fsa''. This job is not new to you and you can use your '''fastawrite()''' function if you want to. 
# Continuing the investigation in HIV. Read the ''HIVenv.fsa'' fasta file and create a single set consisting of all possible epitopes for all sequences. Save the epitopes in the file ''HIVepitopes.txt'' - one epitope per line. An epitope is simply a k-mer 9 residues long, which can possibly elicit a immune system response. So save all unique 9-mers in the sequences in the file. To generate a file that you can verify against my file, you must sort the epitopes alphabetically before saving them. 
# You must prepare the epitopes in ''HIVepitopes.txt'' for machine learning. A common ML problem is when you have many data points (here epitopes) that look like each other. This introduces an unwanted bias in the ML predictions. Your job is to eliminate epitopes that are too similar using the Hobohm-1 algorithm. Hobohm-1 works like this: Look a the first epitope in the list. Compare it sequentially with the rest of the epitopes. If an epitope is too similar with the first, throw it away. Now no epitopes looks like the first. Proceed to the second epitope and repeat the comparing and possibly throwing away of the subsequent epitopes. Proceed to the third epitope in the list. Repeat this pattern until you have reached the end of the list. Now all epitope left are dissimilar to each other. How to determine if two epitopes are too similar? Easy - you earlier learned about the Hamming distance. Just compute the Hamming distance between two epitopes and if the distance is 3 or less, they are too similar. Save the "surviving" epitopes in the file ''HIVepitopesML.txt''. Hint: Think about the Hobohm-1 algorithm before you implement it. You can easily run into problems. You should see a reduction from 15909 epitopes to 3842 in 30-60 seconds.

== Exercises for extra practice ==

Dict techniques

2025-10-03T13:58:35Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Set techniques]]
|Next: [[Regular expressions]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_11-Dicts.ppt Dictionaries] 

Resource: [https://teaching.healthtech.dtu.dk/material/22116/clean_code.html Clean Code] Every time you read it, you will take something from it. 
Resource: [[Example code - Dicts]] 
Video: [https://panopto.dtu.dk/Panopto/Pages/Viewer.aspx?id=276ecfa4-012e-47b4-b521-af27012b06d9 Live Coding]

== Subjects covered ==
* Dictionaries - dicts - which are unordered tables of data.
* Dict methods and functions
* Dict tips and tricks
* Dict algorithms

== Exercises to be handed in ==
# Create a dictionary where the keys are codons and the value are the one-letter-code for the amino acids. The dictionary will function as a look-up table. You can find a [[codon list]] here. You are meant to make the dict "by hand" as there is a structure lesson in that. Add a bit of smart code that tests if you made the dict right. Extra: If you feel like it you can in addition make a program that constructs the dict from a file, which you are responsible for making. 
# Use the dictionary from the previous exercise and your previous functions '''fastaread()''' and '''fastawrite()''' in a program, that translates all the nucleotide fasta entries in ''dna7.fsa'' to amino acid sequence. Save the results in a file ''aa7.fsa'' in fasta format. Since the sequences are now consisting of amino acids add 'Amino Acid Sequence' to each header. The STOP codon is NOT a part of the amino acid sequence. Think about what STOP means. 
# In the file ''ex5.acc'' are a lot of accession numbers, where some are duplicates. Earlier we just removed the duplicates, but now we should count them. Make a program that reads the file once, and writes a file ''order5.acc'' with the unique accession numbers and the number of occurrences in the file. A line should look like this: "AC24677 2", if this accession occurs twice in ''ex5.acc''. The accession numbers must be written in order, which means the accession with most duplicates is on top (the beginning) and the least on bottom. If two accessions have the same amount of duplicates, they need to be ordered according to the accession name, i.e. AC543322 is before BG001110. Note: This is quite a tricky exercise. If you are absolutely stuck, then at least order the accessions by the number of duplicates and hand in. 
# In the tab-separated files ''slinger.txt'' and ''hoist.txt'' are two columns with an accession number and a numeric result; a probability between 0 and 1. The numbers are from running 2 different programs (slinger and hoist, if you are in doubt). You must combine these probabilities - basically taking the average of the two numbers - for each accession number and write the result in a file ''combined.txt''. The file should look like the sources, i.e. tab-separated with accession in column 1 and number in column 2. Unfortunately, the two programs have not been run from the same set of accession numbers, so some of the results are only available in one of the input files. In such case you ignore/discard the data for that accession. Only save results in the output file when the accession is in both of the input files. 
# Using above method gives you too little data. You try this time to combine your two input sets differently. If an accession is in both input files you use the average, if it is in only one, you just use the number straight in the output file. This is effectively making a union of the input instead of an intersection. 
# In the files ''geneA.txt'', ''geneB.txt'', all the way down to ''geneE.txt'' you have normalized mRNA expression data taken at the time of discovery of colon cancer for a number of patients and their survival. This is basically 2 columns in each file; The mRNA expression (x) and the number of months (y) the patient survived. For each gene you have to make a [https://en.wikipedia.org/wiki/Simple_linear_regression simple linear regression] analysis and find 3 numbers; the '''α''' (the intercept - where the line cuts the Y-axis) and '''β''' (the slope) coefficient that describes the line running through the data points best, and the correlation coefficient ('''r''') which describes the fitness of the line. You must identify the gene that best indicates how long the patient survives. For every gene you start calculating these values. [[File:calc.png|220px]]              ''n'' = number of observations. From the values you can compute the required parameters. [[File:alfabeta.png|130px]]          [[File:correlation.png|200px]] Remember to say which gene best describes survival - and why. A survival prediction can be made by calculating β * x + α, given x which is the mRNA expression. Note: The genes will in reality interact with each other in ways that totally destroys our basic assumption for making a linear regression: That the data (gene expressions) are independent. Make your code in a general way - there can for example be more data files. Make it easy to add them. The gene with the best correlation coefficient is geneD, with a CC of 83.75%. 
# Repeat the previous exercise again with a new type of data file ''gene_combined.txt'', which is more typical in real life. All genes are in one tab separated file. There are 3 columns; gene name, normalized mRNA expression and survival in months. There is no particular order in which the data appears and data lines for several genes might be mixed within each other. Again, make general code. There can be more or fewer genes, and you do not need to know there names beforehand.

== Exercises for extra practice ==
* The ''geneA-E.txt'' files all have the same structure on each line; first number is a float between 0 and 1, second number is an integer (representing months of survival after discovery of the cancer). For all files (the combined data set) find the average of the float, given the integer and display in ascending order of the integer. You need to add all the floats for a given integer together and divide by the number of floats for the integer, then you have the average for the integer. To succeed at this, you must use two dicts where the integer is the key in both. The corresponding values are the sum of the floats (for that key) and the number of times the key has been encountered in the files. Hint: Unfortunately, this does not make much biological sense, but is more in the nature of a programming exercise.
* This exercise requires exercise 6 from [[Simple pattern matching]]. Modify the code a bit so you only compute what you have to. In the ''data1-4.gb'' files count how many times the different codons in the coding sequence occurs. Display.
* This exercise builds on exercise 2 for this lesson. You must read the ''dna7.fsa'' file and translate the DNA sequences to protein sequence. Report the frequencies of the various amino acids for the entire file - all sequences (not individual sequences). That is - count how many there is of each amino acid (a total) in the translated sequences, compute the frequency of each (Number_of_this_amino_acid/Total_number_of_amino_acids) and print the results as "S 0.0123", i.e. 4 digits after the dot. You do not need to save the fasta file.

Set techniques

2025-10-03T13:57:50Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Simple pattern matching]]
|Next: [[Dict techniques]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_10-Sets.ppt Sets] 
Video: [https://panopto.dtu.dk/Panopto/Pages/Viewer.aspx?id=e69a7b62-4f83-4b92-b254-af27012c464e Sets] 

== Subjects covered ==
* Sets, which are unordered data collections with no duplicates. 
* Set methods 
* Set uses

== Exercises to be handed in ==
Many modern bioinformatic algorithms utilizes '''k-mers'''. A k-mer is a piece of sequence k units long. The k in the k-mer usually changes size, i.e. length of the sequence depending on the algorithm. It can be both protein and DNA sequence. As an example I have this DNA sequence: GACTAC. It contains the following 4-mers: GACT, ACTA, CTAC. The first 4 exercises works with k-mers and sets and leads up to an algorithm for find the sequence in a group that looks most like a target sequence. Would they be homologs? Good bet.

# From a genbank file like ''data1-4.gb'' extract the DNA sequence (been there - done that). Now insert all 5-mers in the DNA sequence into a set. Compute the following numbers: how many did you insert in the set, how many are in the set, how many different 5-mers could there possibly be. Display. It seems like the two first numbers are the same, but this is not guaranteed to be true. Explain why using your python knowledge. 
# Calculate the overlap of 5-mers between any two of the ''data1-4.gb'' files. Just ask for two filenames and calculate for these. 
# Make a program that asks for a number (integer) then reads the ''dna7.fsa'' file (which contains insulin-like genes) and saves the entry selected by the number in ''selected.fsa'' and the rest of the entries into the file ''rest.fsa'' This should be a fairly easy task since you have your '''fastaread''' and '''fastawrite''' functions from lesson 8, exercise 5 and 6. 
# Now that you can select a fasta entry, then read the ''selected.fsa'' and create 5-mers from the sequence. Now read the entries from ''rest.fsa'' and for every entry create the 5-mers from the sequence. Report which sequence in ''rest.fsa'' had the greatest overlap (and how much overlap) with the selected sequence. This must be the sequence that looks most like the selected one. 
# Read the sequences in the file ''dna7.fsa''. Find out which and how many of the 64 codons are '''not''' used somewhere in the sequences. Print the unused codons. 
# You have made a program (let's call it the X-program), which as input takes a file of accession numbers, ''start10.dat'' and produces some output, which is in ''res10.dat''. Now you count the lines in your input file and your output file and you discover that the line numbers do not match. Horror - your program does not produce output for some input. Now the assignment is to discover which accession numbers did not produce output. This can be done in various ways, but now you have to use a set. Print the results. 
# In the file ''ex5.acc'' are a lot of accession numbers, where some are duplicates. We have earlier cleaned this file of duplicates. Let's do that again using a set. Make a program that reads the file once, finds the unique accession numbers and write them to the file ''uniq5.acc'' 
# In the ''data1.gb'' file there are 6 references (to articles). Make a program that extracts all authors from the references, eliminates those that are duplicates and print the list of authors. You will notice that some authors seems to be the same person using different initials. You should only consider a person a duplicate if the name matches exactly. This should also work for the other Genbank entries: ''data2.gb'', ''data3.gb'' & ''data4.gb''. Beware: there traps in this exercise, check your output properly.

== Exercises for extra practice ==

Simple pattern matching

2025-10-03T13:57:10Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Functions]]
|Next: [[Set techniques]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_09-PatternMatch.ppt Simple pattern matching] 

[[Example code - Wrong parsing]] What many do, and is sooo bad. 

== Subjects covered ==
String pattern matching, stripping, replacement, translation. 
Pattern matching is about 2 things: '''WHAT''' is the pattern and '''WHERE''' is the pattern. 
It is important to '''AVOID''' matching the wrong place.

== Exercises to be handed in ==
The first 7 exercises will all have to do with the files ''data1-4.gb'', which are various Genbank entries of genes. First you should study the files, notice the structure of the data. In all exercises you will have to parse (read and find the wanted data) the files using pattern matching. Every exercise adds to the previous ones, so the final program grow big and can do a lot. It is part of the practice to be able to keep an overview of the elements of a large program. Use structure and comments to help you keep track. Your program should be able to handle all files, but just one at a time.

# Extract the accession number, the definition and the organism (and print it). 
# Extract and print all MEDLINE article numbers which are mentioned in the entries. 
# Extract and print the translated gene (the amino acid sequence). Look for the line starting with /translation=. Generalize; An amino acid sequence can be short, i.e. only one line in the feature table, or long, i.e. more than one line in the feature table. Use stateful parsing. 
# Extract and print the DNA (whole base sequence in the end of the file). Use stateful parsing. 
# Your program already extracts the DNA. Make it also extract the positions of the coding sequence. Display them. You can recognize it by the line that starts with "     CDS     join(" 
# Now that you have the DNA and the positions in the DNA for the coding sequence, extract the coding DNA directly from the DNA, such that you can display the actual gene. Verify that you have done so correctly by thinking about the properties of coding DNA sequence. 
# Find all titles and authors using stateful parsing. Put every author/title record (i.e. all authors/title in one string) in one list. Display all neatly with title on one line, authors on the next and a separator line. 
# Returning all the way back to lesson 6, Stateful parsing, exercise 6. Given the content of today's lecture, how would you improve this exercise now (shorter, more efficient code) ?

== Exercises for extra practice ==
You will program a [https://en.wikipedia.org/wiki/Reverse_Polish_notation reverse polish notation] calculator. This is somewhat complicated, so I will split up the job in a number of smaller exercises, where the one exercise builds on the previous. Shortly, reverse polish notation is a mathematical notation in which operators follow their operands, i.e. adding two numbers is written by "3 4 +" instead of "3 + 4". We will utilize a [https://en.wikipedia.org/wiki/Stack_(abstract_data_type) stack], which is simply a list, where elements are added to and removed from the bottom.
* Let's start with making the overall structure; a loop that asks for input, which is one item/command at a time. Inside the loop, there can be a number of operations depending on the input. If you enter a number, it should be simply appended to your list (the stack, which is the word I will use in the rest of the exercises here). If you enter commands '''STOP''', '''EXIT''' or '''QUIT''', the loop should end and the program stop. If you enter something that the program does not understand it should write "Illegal command", but otherwise do nothing.
* Add the following commands: '''PEEK''', which displays the last number in the stack, and '''SHOW''' which will display the entire stack.
* Add the standard math operations, '''+''', '''-''', '''*''' and '''/''': These remove 2 numbers from the stack (the last number in stack is the first operand and the second last number is the second operand), perform the operation and appends the result back to the stack. You notice operand order matters for - and /. At this point we have a simple but functional calculator.
* Add single number operations '''LOG''' and '''SQRT''', which replaces the last number in the stack with the log/square root of the number.
* Solidify your program by ensuring any operations first check if the required number of operands are on the stack before trying to perform the operation. Display "Not enough operands on the stack" and otherwise do nothing if the check fails. Hint: Maybe lists of zero, one and two operands commands could be useful.
* Add the commands: '''DROP''' which simply removes the last number on the stack, '''=''', which removes the last number on the stack and displays it, '''SWITCH''', which switches the last two numbers on the stack, and '''DUP''' which duplicates the last number on the stack, i.e stack consists of 1, after DUP it consists of 1 1.
* Add the commands: '''ABS''', '''NEG''' which replaces the last number on the stack which the absolute/negative value of the number.
* At this point you can probably work out some mathematical operations to add that require one or 2 operands by yourself. I can think of the '''SIN''', '''COS''' & '''TAN''' operations, the '''INT''' taking the integer part of a number, '''EXP'''onential and '''SQUARE'''. Modulo operation with '''%'''. '''FAC'''torial. You could add constants like '''PI''' and '''E''' that simply puts an appropriate value on the stack.
* Add stack control with '''CLEAR''' to empty the stack and extend the '''SWITCH''' to switch the numbers as two given position like "SWITCH 2 4" if given positions.

Functions

2025-10-03T13:56:25Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[List manipulation]]
|Next: [[Simple pattern matching]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_08-Functions.ppt Functions] 

Resource: [[Example code - Functions]] 


== Subjects covered ==
* Functions: a function is both a way of hiding complexity and a way of reusing code.
* Arguments, scope of variables.

== Exercises to be handed in ==
Any function you are required to make here needs a small program around it to show that it works - so you also make that as part of your hand-in. 
The exercises 5 to 8 belongs together as a group and should be solved in order. They are about reading, changing and writing fasta files with many entries. You will likely find 5 especially hard.

# The [https://en.wikipedia.org/wiki/Hamming_distance Hamming distance] is the distance between two strings of '''equal''' length. Make a function which takes two strings as arguments and calculates the distance between them. Add error handling. 
# Make a function '''fibonacci(no1, no2, count)''' which calculates the first '''count''' [https://en.wikipedia.org/wiki/Fibonacci_number fibonacci numbers] based on '''no1''' and '''no2''' and returns them in a list. The next number in a fibonacci sequence is the sum of the two previous numbers. Test it with printing the resulting list (one number per line) from fibonacci(0,1,20). 
# Make a function that returns the unique elements of a list as a list. Try it on the accession numbers in ''ex5.acc'', which contains 6461 unique accessions, but also make your own file with simple numbers. 
# Make a function that calculates the standard deviation of a list of numbers. Try with the file ''ex1.dat'', where you pool all the numbers in the the 3 columns into one list and get the result 1.8355. You can either do the two-pass algorithm (iteration through all the numbers twice) which is clear from the formula or the one-pass algorithm which you can derive from the formula if you are up to the challenge. [[File:StandardDeviation.gif]] 
# Look at the fasta file ''dna7.fsa''. It contains several fasta entries. Reading more than one entry in a file is more complex. Make a program that mostly consists of one function '''fastaread(filename)''' which takes a filename as a parameter and returns 2 lists, first list is the entry headers, second list is the entry sequences (as single strings without whitespace). Add appropriate error handling to the function. Just print the headers and sequences out pairwise as proof of concept. Hint: I will point out that the reading and writing of fasta files with many entries is a regular occurrence in bioinformatics (and exam), so be sure to get it right. Many people mistakenly believe that they should use a form of stateful parsing with a flag for this - doing so confuses the issue, so abstain from that. 
# Make a function '''fastawrite(filename, headers, sequences)''' which takes a filename, a list of headers and a corresponding list of sequences as parameters and writes a fasta file with that file name. Add appropriate error handling to the function. You can test your function using the file ''dna7.fsa'' and your previous function - reading ''dna7.fsa'' and then writing a new fasta file, should make the files identical. 
# Make a function that take a DNA sequence (string) as parameter and return the complement strand (reverse complement). Make the function generic and portable, i.e. not dependent on any external factors. Together with the functions you made in exercise 5 & 6, read the fasta entries in file ''dna7.fsa'' and write the complement strands in the new file ''revdna7.fsa''. Add 'Complement strand' to each header. 
# Make a function that calculates the GC-content of a DNA sequence. It takes a DNA (string) as parameter and returns the GC percentage. Make the function generic and portable, i.e. not dependent on any external factors. Together with the functions you made in exercise 5 & 6, read the fasta entries in file ''dna7.fsa'' and write only the sequences which has a GC-content percentage over 50% in the new file ''dna7GC.fsa''.

== Exercises for extra practice ==
* Make a function that calculates the factorial. Add some input control to the function to make sure you get positive integers, when you ask for a number. Consider if you want to raise an exception if the function gets invalid data or you want to halt the program.
* Make the factorial function computation use recursion.

List manipulation

2025-10-03T13:55:41Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Stateful parsing]]
|Next: [[Functions]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_07-Lists.ppt List manipulation] Pretty comprehensive (read long). 

Resource: [[Example code - Lists]] 
Resource: [[Example code - Lists and enumerate]] 
Video: [https://panopto.dtu.dk/Panopto/Pages/Viewer.aspx?id=0d134a6c-ec9b-46d0-8a62-af27012bf0ef Live Coding]

== Subjects covered ==
Lists and list methods. 
List algorithms.

== Exercises to be handed in ==
# Searching for accession numbers. In the file ''ex5.acc'' there are 6461 unique GenBank accession numbers (taken from HU6800 DNA array chip). An inexperienced bioinformatician unfortunately fouled up the list, so many of the accession numbers appears more than once. Make a program that first reads the file into a list, then ask for an accession number and counts how many times it appears in the list and displays the result. Keep asking and searching for accession numbers until STOP is entered. Hint: this is 2 loops inside one another. 
# You need to clean up the ''ex5.acc'' file. The first step is to sort the accession numbers alphabetically. You must program a sorting algorithm. There are many different algorithms for sorting, but let's pick a simple one - Bubble Sort. It goes like this. Read the accessions into a list like the previous exercises. Go through the list looking at pairs of accessions (at position i & i+1). If a pair is in the wrong order, you switch them. Repeat going through the list until you have gone through the entire list without switching once. Now the list is sorted and you save the list in the ''sorted5.acc'' file. Note: '''It takes 10-30 sec to run this program'''. There is room for optimization in the described algorithm and it is in any case not the most efficient method. Strings can be compared directly with each other using the operators <nowiki>==, !=, >, <, >=, <=.</nowiki> 
# It is now time to find the unique accession numbers, so you only have one of each - no duplicates. Read the accessions from ''sorted5.acc'' into a list. Since the list is now sorted, the duplicates are "next" to each other, which makes them easy to find. Make a '''new''' list with the unique accessions from the old list, and save that list in the file ''clean5.acc''. Check that you have 6461 accessions, one per line. 
# In this exercise you have to do the same and achieve the same result in a different way as the previous exercise. Instead of making a new list with the unique accessions, just keep the old list and remove the duplicates. You can use '''del''' or '''pop''' to remove elements. If you run into trouble imagine your code executed on this list: [1, 2, 2, 3, 3, 3, 4, 4, 4, 4] 
# First ask for some input file names. Do this a either a loop where you ask for one file name at a time until empty string is entered, or all file names on a space separated string. You must compute the sum of the first number in all files, the sum of the second number in all files and so forth. Save the sums in the output file ''sums.dat''. The input files may be corrupted or not the same length. Deal with that by assuming a corrupted line (a line you can not convert to a number) and missing lines in short files are 0. The files ''ex1_1.dat'', ''ex1_2.dat'', ''ex1_3.dat'' and ''ex1corrupt.dat'' are good for testing. 
# After having looked at the cleaned accession numbers in ''clean5.acc'', you will have seen that the accession numbers are sorted. This means that you can use the much more powerful binary search method when searching for accession numbers. Make a program that reads the file and repeatedly asks for accessions and searches the list (and tells if it is there or not) using binary search until you enter STOP instead of an accession. 
# Make a program that calculates the sum of all columns in an input file, no matter how many columns there are. Each column should be summed individually. You can assume that each row (line) has the same number of columns in the file. In the file ''ex1.dat'', the sums of the three columns are: -904.4143, 482.8410, 292.0515 
# Make a Python program that can select specific columns from a column based (tab separated) file and save them in a new file. It should select the columns that you specify in the order you specify. Ask for input and output file names and column numbers (3 questions, example "ex1.dat", "2col.acc" & "3 1"). The program should work with any number of columns in the input file.

== Exercises for extra practice ==
* Read a file with numbers into two lists. The first number in the file goes to the first list, the second number to the second list, the third number to the first list, and so forth - alternating numbers to alternating lists. Compute the sum of the two lists and display. Files ''ex1_1.dat'', ''ex1_2.dat'' & ''ex1_3.dat'' are good to use for this.
* Now compute the same sums - without the lists :-)
* Ask for files names and read the numbers in the file into a list. Continue to ask for file names and add the numbers to the list until you enter STOP. Your list of numbers will simply grow with each file you add. Now compute the sum of the numbers in the list and display the result. Files ''ex1_1.dat'', ''ex1_2.dat'' & ''ex1_3.dat'' are good to use for this.

Stateful parsing

2025-10-03T13:55:07Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[Exceptions and bug handling]]
|Next: [[List manipulation]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22101/22101_08-StatefulParsing.ppt Stateful Parsing] 
Video: [https://panopto.dtu.dk/Panopto/Pages/Viewer.aspx?id=fe50507e-9009-49b1-a3a8-af27012d8cdf Stateful Parsing] 
Video: [https://panopto.dtu.dk/Panopto/Pages/Viewer.aspx?id=ce785005-14cd-424a-a406-af27012b3e1b Finding errors with Stateful Parsing] 


== Subjects covered ==
Using stateful parsing to extract data spanning several lines, by recognizing keywords.

== Exercises to be handed in ==
The following 5 exercises deal with SwissProt. The file sprot1.dat is a SwissProt database entry. Study it carefully. Locate the SwissProt ID (SP96_DICDI), the accession number (P14328) and the amino acid sequence (MRVLLVLVAC....TTTATTTATS). There are other entries ( ''sprot2.dat'', ''sprot3.dat'', ''sprot4.dat''). Your programs should work on those, too. Also your programs must solve all the problems in ONE reading of the file. It is acceptable if you just hand in one program that solves 1 to 4. 5 is separate. These exercises are about studying and understanding the file format.

# Make a program that reads the ID and prints it. Try to use the "walk the line" technique. 
# Add the following functionality to the program: Read the accession number and print it. Again, walk the line. 
# Add the following functionality to the program: Read the amino acid sequence and print it. You really should use stateful parsing in this exercise. Maybe check the video. 
# Add the following functionality to the program: Verification of amino acid number. This means extract the number from the SQ line (example: SQ SEQUENCE 629 AA;) and check that the amino acid sequence has that number of residues. It should be the program that determines if something is wrong - not the user. Imagine that before you go home, you set the computer to run through a million swisprot entries. The next day, you must be able to see what failed. In a sense you don't care about what succeeded, as that is the common case. You care about what failed, because it is here you must take action. 
# Now that you have the ID, accession number and AA sequence save it to a file ''sprot.fsa'' in FASTA format. Look in the file ''dna.fsa'' for an example of FASTA. Notice the first line starts with > and immediately after comes an unique identifier, like an accession number or a SwissProt ID. Any other data must be on the header line only, but in free format. Sequence data is on the following lines. Notice that this exercise incorporates the previous 4, but uses the result in a slightly different way. 
# In reality you never have just one entry in a SwissProt file. The current SwissProt database contains more than half a million entries and it grows all the time. A bioinformatician can access the database by selecting a subset or the whole database as one file for download and extract the needed information from it. In the file ''sprotall.dat'' the 4 sprot files have been collected as a very small example of what you really meet. The exercise is to read all entries in ''sprotall.dat'' and create one fasta file ''sprotall.fsa'' with the ids, accessions and sequence for all entries. In short, just like the previous exercise but for a file that contains more SwissProt entries. And please, don't do anything stupid like reading the entire file into a list and start parsing that. These SwissProt excerpts can get really big and it can kill your computer memory doing that.

== Exercises for extra practice ==
* Count the number of RA (Author) lines in the ''sprot1-4.dat'' files. ''sprot2.dat'' contains 25 RA lines.
* Extract the author names from the RA lines in the ''sprot1-4.dat'' files. Display the names - only the names.
* Continuing previous exercise: Now also extract the title (RT lines). Display like title first on one line, followed by authors on the next. Then empty line followed by the next title and authors and so forth, until no more authors/titles.

Exceptions and bug handling

2025-10-03T13:54:29Z

WikiSysop: /* Exercises to be handed in */

__NOTOC__
{| width=500 style="font-size: 10px; float:right; margin-left: 10px; margin-top: -56px;"
|Previous: [[String manipulation]]
|Next: [[Stateful parsing]]
|}
== Required course material for the lesson ==
Powerpoint: [https://teaching.healthtech.dtu.dk/material/22116/22116_05-Exceptions.ppt Exceptions and bug handling] 

Resource: [[Example code - Exceptions]] 


== Subjects covered ==
How to structure your code in distinct parts. 
Finding bugs in your program, using ''exceptions''. 

== Exercises to be handed in ==
# In the file ''dna.fsa'' is some DNA. Construct a program that finds possible translation starts :-) All proteins start with the amino acid methionine (at least when translating, Met might be removed in later processing states). Methionine is coded with ATG. The exercise is therefore; find the position of all ATG's in the sequence. The first position is 83 as humans count. In some organisms different start codons are possible. If you really want to, you can make the program handle those cases too. 
# Connecting to the previous exercise; Assuming that the first Met at position 83 is translation start, find the corresponding translation stop (which is the first one in frame). Stop codon is coded by TAA, TAG, or TGA. Remember that the stop codon has to be in the same reading frame as ATG. Notice: There are two ways to solving this exercise. The primitive way is to start at the position given. The more general and better way is to find the first ATG and then find the corresponding stop codon, which is on position 128. 
# Read the file ''orphans.sp'' and find all accession numbers (and only the accession numbers), save them in another file of your choosing. Hint: an accession number might look like this AB000114.CDS.1 or like this AB000114 or like this AB000114.CDS.3. CDS means CoDing Sequence followed by a number. If the accession number contains the CDS part, consider .CDS.1 as a part of the accession number. Accession numbers differ in length for historical reasons. You can assume that the accession number comes straight after the '''>''', which is first on the line. 
# Make a program that asks for an organism, like 'HUMAN' or 'RAT'. The program should then count the number of lines/times a SwissProt identifier in the file ''orphans.sp'' is present with said organism, ie. PARG_HUMAN and LUM_HUMAN are the two first for HUMAN. Hint: you should probably think twice in this exercise. The position is significant. Check what happens if you search for RAT. 
# Count the ATCG's in the sequence in ''dna.fsa''. Display the percentage of ATCG's with 2 digits after the dot. Make it look really structured. Just to be exceedingly clear; the percentage of A's is 100*(NumberOfA/LengthOfSequence). 
# The file ''studentweight.txt'' contains both text lines and numbers. Make a program that can ask for a file name and sum the numbers and ignore the text lines using exceptions. Result is 1035.

== Exercises for extra practice ==
* In the file ''mixedlines.txt'' how many 4 letter words exists? A word is here defined as consecutive visible characters, i.e. "12", "ipsum." are both words.
* Write a program that asks for an integer, and then determines if the number was a prime number or not.
* Write a program that prints a "bulls-eye" to the screen using characters like; '.', '+', '*', '#', etc. You have to import the math library, in order to access the squareroot (sqrt), sine (sin), cosine (cos), and so forth functions. The square root of x is gotten like math.sqrt(x). I only used: for, if, elif, print, +, -, /, **, int, sqrt for this 40x40 example. Hint: Think of a grid where one point is the center of the eye/circle. The positions in the grid will use different chars, depending how far away they are from the center. You might get an oval shape - think about why. [[File:BullsEye.png]]
* Make a small program that asks for input - any input. It should output 1 of 3 simple lines: 1) You gave me a string 2) You gave me a number 3) You gave me a floating point number