Information for the Written Exam
Date, Time, and Place ("Normal Season", a.k.a. "Época Normal")
As discussed on the evaluation page and Sigarra, this exam is worth 50% of the grade on this course (the other 50% come from the practical tests and exercises during practical classes).
Exam Sample Questions:
Here you can see the exam from last year:
Goals for the Final Exam
Fundamentals
Programming Fundamentals
- Understand the concept of a variable as a container for storing data.
- Understand the difference between a statement and an expression.
- Understand the difference between arithmetic and logical operators.
- Be able to write simple programs that combine multiple programming concepts (e.g., input, processing, output).
Python Fundamentals
- Know the basic usage of the
input() and print() functions.
- Know the primary data types in Python:
int, float, str, and bool.
- Know the
type() function and how to perform explicit type conversions (e.g., using int(), float(), and str()).
- Know the rules for naming variables and the meaning of reserved keywords.
- Be able to assign values to variables and evaluate Python expressions.
- Know the main arithmetic operators (
+, -, *, /, //, %, **), their functionality, and precedence rules.
- Know how to combine and predict the result of expressions using arithmetic and logical operators.
Conditionals and Program Flow
Boolean Values
- Understand the role of Boolean values (
True and False) in decision-making within a program.
- Understand the difference between comparison operators (e.g.,
==, !=, <, >, <=, >=).
- Know how to interpret Boolean expressions and predict their result.
- Know how logical operators (
and, or, not) are used to combine Boolean expressions.
Conditional Execution (if-else statements)
- Know how to use the
if statement to execute code based on a condition.
- Know how to use the
else statement to provide an alternative when the condition is not met.
- Know how to write chained conditionals (i.e., multiple
if-elif-else statements) to evaluate multiple conditions in sequence.
- Understand how to write nested conditionals, where an
if statement appears inside another if block.
Program Flow (for and while loops)
- Understand the concept of iteration and how it is used to repeat code based on conditions.
- Know how variables are updated during iteration to track changes within loops.
- Know how to write a
for loop using the range() function or by traversing an iterable (e.g., a list).
- Know how to write a
while loop using a condition to control/stop the loop.
- Understand the behavior of the
break statement to exit a loop early.
- Understand the behavior of the
continue statement to skip the current iteration and move to the next.
Functions
Basic Concepts
- Understand the concept of a function as a reusable block of code that performs a specific task.
- Know how to define a function using the
def keyword and how to call it in a program.
- Understand how functions can receive arguments that are later assigned parameters (during function calls).
- Understand how functions that return values can pass data back to the calling code using the
return statement.
- Understand the concept of flow of execution in a program, including how the program jumps to a function and returns after execution.
Advanced Concepts
- Be able to create Boolean functions that return
True or False based on conditions and how to use them in conditional statements.
- Be able to design functions that return multiple values using tuples or lists.
- Understand the concept of lambda functions and how to define and use them.
- Understand and implement higher-order functions (functions that take other functions as arguments or return functions).
Strings
Basic Concepts
- Understand how to create and manipulate strings in Python, using basic string operations such as concatenation and repetition (
+, *).
- Understand string formatting techniques, such as using f-strings to embed variables inside strings.
- Know how to perform indexing and slicing operations on strings (
str[idx], str[start:end]).
- Understand that strings are immutable in Python.
Advanced Concepts
- Know how to use
ord() to get the Unicode integer value of a character and chr() to convert a Unicode value back to a character.
- Identify common string constants and know how to use
isX methods (e.g., isalpha(), isdigit()) to check for certain string properties.
- Know how to split strings using
.split() and join strings using .join(), including working with delimiters and whitespace.
Algorithms and Structured Programming
Concepts
- Learn how to understand a problem by carefully reading and analyzing it, ensuring that you fully comprehend what is being asked.
- Know how to organize your solutions logically before jumping into writing the code.
- Understand modular programming (dividing the code into smaller, more manageable pieces or functions) and incremental development (testing each block of code before moving on to the next).
- Understand the importance of algorithm correctness and efficiency.
Applications
- Understand how to break complex problem statements into simpler tasks.
- Know how to break and organize a large program into smaller functions or files (modules).
- Know how to implement helper functions to simplify the main logic of your programs.
- Know how to import and use standard libraries to make code more modular.
- Know how to test your programs.
- Know how to apply the algorithmic techniques of sliding windows and prefix sums
Data Structures
Concepts
- Understand the concepts of iterables, sequences, and the distinction between mutable and immutable data types.
- Understand the difference between tuples, lists, dictionaries, and sets in terms of mutability and use cases.
- Identify the situations where using a specific data structure is more appropriate than using another (e.g., tuples vs. lists vs. dictionaries vs. sets).
- Understand and apply algorithmic patterns using data structures (e.g., extracting elements based on conditions; applying a transformation to each element; combining elements into a single value).
Tuples
- Know how to create and access elements in a tuple.
- Know how to perform basic tuple operations (e.g., traversing, concatenation, multiplication/repetition, slicing).
- Understand tuple packing and unpacking.
- Understand the immutability of tuples and its implications.
- Understand and apply nested tuples in more complex data structures.
- Know how to apply built-in functions like
len(), max(), min(), sum() with tuples.
Lists
- Know how to create, access, and modify elements in a list.
- Know how to perform list operations (e.g., traversing, slicing, appending, extending, removing, and sorting).
- Understand the mutability of lists and its implications.
- Understand and apply nested lists in more complex data structures.
- Know how to apply built-in functions like
len(), max(), min(), sum() with lists.
- Know and use common list methods (e.g.,
append, extend, insert, remove, clear, reverse, sort).
- Understand how equality (
==) and ordering (<, >, <=, >=) comparisons work on lists.
- Understand the difference between copying by reference and copying by value and know how to create shallow copies and deep copies of lists (e.g., using
copy()).
- Know how to use higher-order functions (e.g.,
map, filter, reduce) with lists.
- Understand list comprehensions and their advantages in creating and transforming lists.
Dictionaries
- Understand the dictionary data structure as a collection of key-value pairs.
- Understand how to iterate over dictionaries effectively using loops.
- Be able to combine dictionaries with other data structures (e.g., dictionaries of lists).
- Know how to create dictionaries using literals (
{}) or the dict() constructor.
- Understand the rules for keys (e.g., they must be immutable types like strings, numbers, booleans, or tuples).
- Know how to access, add, update, and delete key-value pairs in a dictionary.
- Know how to use key dictionary methods, such as
keys(), values(), items(), clear(), get(), pop(), update().
Sets
- Understand the set data structure as a collection of unique, unordered elements.
- Understand set operators:
union (
|), intersection (&), difference (-), symmetric difference (^) and subset relationships (<, >, <=, >=).
- Be able to combine sets with other data structures (e.g., lists of sets, sets of tuples).
- Know how to create sets using literals (
{}) and the set() constructor.
- Know how to iterate over sets and how to add and remove elements using methods like
add() and remove() or discard().
Recursion
Concepts
- Understand the concept of recursion as a problem-solving approach where a function calls itself.
- Understand the base case and recursive case as fundamental components of any recursive function.
- Be able to identify problems that can be effectively solved using recursion.
- Know how to break down a problem recursively into smaller subproblems.
Applications
- Understand and implement simple recursive patterns, such as summing a list recursively, factorial computation, fibonacci sequence generation, flattening nested lists.
- Understand and implement more advanced recursive algorithms such as generating permutations or combinations (without using
itertools 🙃), and navigating multi-dimensional structures (e.g., 2D grids).
Variable Scope and Modules
Variable Scope
- Understand the concept of variable scope as the region of a program where a variable is accessible.
- Know Python's LEGB rule (Local, Enclosing, Global, Built-in) for variable lookup and resolution.
- Be able to predict which variable is being accessed or modified based on its scope.
- Understand and use the
nonlocal and global keywords.
Modules
- Understand the concept of modules as reusable Python files containing functions, variables, and classes.
- Know how namespaces are managed in Python and how they interact with modules.
- Understand the purpose and functionality of import statements, including
"import ___", "from ___ import ___", and "import ___ as ___".
- Understand the use of the dot operator (
.) to access module attributes and functions.
- Be able to import and use standard library modules like
math and random.
Errors and Exceptions
Concepts
- Be able to identify the main types of errors in Python: syntax errors, runtime errors, and semantic errors.
- Understand some common beginner errors such as off-by-one, initialization and order of operation
- Understand runtime errors and their potential causes during program execution.
Applications
- Be able to predict the common built-in exceptions in Python, such as
TypeError, ValueError, KeyError, and IndexError.
- Know how to implement the
try-except block for catching and handling exceptions.
- Know how to use multiple
except blocks to handle different types of exceptions.
- Be able to use the
else and finally clauses in conjunction with try-except blocks to specify additional functionality.
- Understand how to raise custom exceptions using the
raise statement.
- Know how to use assertions (using the
assert statement) to validate conditions during development and testing.