Grade 12 Science: Computer science

In this unit, 'Python functions, files and exceptions', you learn to write and test functions and handle files. You work with exam-style questions and written reasoning. You see it, say it, then do it alone.

• See it: watch or try the skill in 'Python functions, files and exceptions' on a teacher screen or a safe device.
• Name the parts: write the key words and what each part does.
• Use it: write and test functions and handle files. Save your work in a named file or folder.
• Test and fix: run it, find one fault, correct it, and note what you changed.

Step by step.

1. Step 1, A function with exception handling: def safe_div(a, b): try: return a / b except ZeroDivisionError: return None. safe_div(10, 2) returns 5.0 and safe_div(5, 0) returns None instead of crashing the program.
2. Step 2, Test with assert: assert safe_div(10, 2) == 5.0 passes silently. assert safe_div(5, 0) is None also passes. If a test fails, Python raises AssertionError with the line number, so the bug is found quickly.
3. Step 3, Prepare a file: nums.txt contains three lines: 4, then x, then 6. The goal is to total the valid numbers. The expected answer is 4 plus 6, which is 10, and x should be skipped and reported.
4. Step 4, Read with handling: def read_total(path): total = 0, then with open(path) as f: for line in f: try: total += int(line) except ValueError: print('skip', line.strip()), then return total. Each int() is guarded by its own try block.
5. Step 5, Run and check: read_total('nums.txt') prints skip x and returns 10. Because int('4\n') and int('6\n') accept surrounding whitespace, they convert, but int('x') raises ValueError, which is caught, so the loop continues.
6. Step 6, Missing file: read_total('none.txt') raises FileNotFoundError because open fails. A caller wraps it in try and except FileNotFoundError and prints 'No such file'. Different errors need different handlers, and a bare except would hide mistakes.
7. Your turn: Write average(nums) that returns 0 for an empty list, and test it. Model answer: if not nums: return 0, otherwise return sum(nums) / len(nums); assert average([2, 4, 6]) == 4 and assert average([]) == 0.

Activity. About 40 to 50 minutes of class work, then one short practice task for home. Keep evidence: a timed paper and an error log.

Standard to meet. Write and test functions and handle files: at least 70 percent on an exam-style task, with the method shown.

In this unit, 'Data structures: stacks and queues', you learn to implement stacks and queues. You work with exam-style questions and written reasoning. You see it, say it, then do it alone.

• See it: watch or try the skill in 'Data structures: stacks and queues' on a teacher screen or a safe device.
• Name the parts: write the key words and what each part does.
• Use it: implement stacks and queues. Save your work in a named file or folder.
• Test and fix: run it, find one fault, correct it, and note what you changed.

Step by step.

1. Step 1, Stack with a list: stack = [], then stack.append(5), stack.append(8), stack.append(2). The stack is [5, 8, 2] with 2 on top. print(stack.pop()) prints 2, then print(stack[-1]) prints 8, the new top, and print(stack) shows [5, 8].
2. Step 2, Last in, first out: The last item added, 2, was the first removed. Calling pop() on an empty list raises IndexError, so check if stack: before popping. A stack suits undo history and bracket checking.
3. Step 3, Queue with deque: from collections import deque, then q = deque(), q.append('A'), q.append('B'), q.append('C'). print(q.popleft()) prints A, and print(list(q)) shows ['B', 'C']. First in, first out, like a print queue.
4. Step 4, Why deque: Removing from the front of a plain list with pop(0) shifts every other item, while deque.popleft() is fast. Use a list for stacks and a deque for queues.
5. Step 5, Balanced brackets: def balanced(s): st = [], for ch in s: if ch == '(': st.append(ch) elif ch == ')': if not st: return False, then st.pop(); finally return len(st) == 0. balanced('((a+b)*c)') is True.
6. Step 6, Trace the failures: balanced('(a+b))') pushes once, pops once, then meets a second ) with an empty stack and returns False. balanced('(a+b') ends with one item left, so len(st) is 1 and it returns False.
7. Your turn: Reverse 'abc' with a stack. Model answer: push a, b, c to make [a, b, c]; pop gives c, then b, then a; joining them gives 'cba'. The last character comes out first.

Activity. About 40 to 50 minutes of class work, then one short practice task for home. Keep evidence: a timed paper and an error log.

Standard to meet. Implement stacks and queues: at least 70 percent on an exam-style task, with the method shown.

In this unit, 'Computer networks and security', you learn to describe network layers and security. You work with exam-style questions and written reasoning. You see it, say it, then do it alone.

• See it: watch or try the skill in 'Computer networks and security' on a teacher screen or a safe device.
• Name the parts: write the key words and what each part does.
• Use it: describe network layers and security. Save your work in a named file or folder.
• Test and fix: run it, find one fault, correct it, and note what you changed.

Step by step.

1. Step 1, The layers: A browser request passes through four layers. Application: HTTP data. Transport: TCP splits it into segments with port numbers, such as 443 for secure web traffic. Network: IP adds source and destination addresses. Link: frames move it over one hop.
2. Step 2, Follow one request: A student opens a page. The browser makes an HTTP request, TCP adds the destination port 443, IP adds the server's address, and the link layer sends the frame to the router. The server reverses the process, so the reply climbs the layers.
3. Step 3, Subnet: 192.168.1.0/24 has a prefix of 24 bits, leaving 8 host bits. 2 to the power 8 is 256 addresses, and two are reserved, the network and the broadcast, so 254 hosts can be used. The mask is 255.255.255.0.
4. Step 4, Split into smaller subnets: With /26 there are 6 host bits, so 2 to the power 6 gives 64 addresses and 62 usable hosts. The first subnet is 192.168.1.0 to 192.168.1.63, with hosts .1 to .62, and the next starts at .64. The mask is 255.255.255.192.
5. Step 5, Encryption example: A Caesar cipher with shift 3 changes CAT to FDW, because C moves to F, A to D and T to W. It is easy to break, so real systems use strong, well-tested algorithms. Never design your own for real data.
6. Step 6, Password strength: An 8-letter lowercase password has 26 to the power 8, about 208.8 billion possibilities. With 62 characters, upper and lower case letters and digits, 62 to the power 8 is about 218 trillion. Longer, varied passwords are much harder to guess.
7. Your turn: How many usable hosts in a /28 subnet? Model answer: 32 minus 28 is 4 host bits; 2 to the power 4 is 16 addresses; minus the network and broadcast addresses gives 14 usable hosts.

Activity. About 40 to 50 minutes of class work, then one short practice task for home. Keep evidence: a timed paper and an error log.

Standard to meet. Describe network layers and security: at least 70 percent on an exam-style task, with the method shown.

In this unit, 'Databases and SQL with Python', you learn to connect Python with a database and query it. You work with exam-style questions and written reasoning. You see it, say it, then do it alone.

• See it: watch or try the skill in 'Databases and SQL with Python' on a teacher screen or a safe device.
• Name the parts: write the key words and what each part does.
• Use it: connect Python with a database and query it. Save your work in a named file or folder.
• Test and fix: run it, find one fault, correct it, and note what you changed.

Step by step.

1. Step 1, Connect and create: import sqlite3, con = sqlite3.connect('school.db'), cur = con.cursor(), then cur.execute('CREATE TABLE IF NOT EXISTS marks (name TEXT, score INTEGER)'). If school.db does not exist, the file is created with an empty marks table.
2. Step 2, Insert safely: cur.executemany('INSERT INTO marks VALUES (?, ?)', [('Learner 1', 72), ('Learner 2', 91), ('Learner 3', 65), ('Learner 4', 88)]) then con.commit(). Without commit the rows are not saved. Running this twice would add 8 rows, so run it once.
3. Step 3, Query: cur.execute('SELECT name, score FROM marks WHERE score >= 80 ORDER BY score DESC') then print(cur.fetchall()). Output: [('Learner 2', 91), ('Learner 4', 88)]. fetchall returns a list of tuples, one per row.
4. Step 4, Aggregate: cur.execute('SELECT AVG(score) FROM marks') then print(cur.fetchone()[0]). The output is 79.0 because 72 plus 91 plus 65 plus 88 is 316, and 316 divided by 4 is 79. fetchone returns one tuple.
5. Step 5, Parameters not string joining: user_name = 'Learner 1', cur.execute('SELECT score FROM marks WHERE name = ?', (user_name,)) returns [(72,)] with fetchall. The question mark keeps user input as data, which prevents SQL injection from input like x' OR '1'='1.
6. Step 6, Close: con.close() releases the file. Wrapping work in try and finally ensures the connection closes even after an error. Reopening school.db and running COUNT(*) should still return 4 rows.
7. Your turn: Create pets(name, age) with ('Cat', 3), ('Dog', 7), ('Bird', 1) and print pets older than 2. Model answer: executemany inserts, commit, SELECT name FROM pets WHERE age > 2 ORDER BY age gives [('Cat',), ('Dog',)].

Activity. About 40 to 50 minutes of class work, then one short practice task for home. Keep evidence: a timed paper and an error log.

Standard to meet. Connect Python with a database and query it: at least 70 percent on an exam-style task, with the method shown.

On the slide: L1 Basic · Computer science as problem solving

Notes: Name what makes a problem suitable for a computer, such as clear steps and repeated work. Notes: ask learners how they would find the tallest person in a room; they describe each step in words. No devices are needed, just a clear list.

On the slide: L2 Awareness · Algorithms and flowcharts

Notes: Describe an algorithm as a flowchart and trace it by hand. Notes: draw a flowchart that finds the larger of two numbers, then run it with 7 and 4 and with 5 and 5. Learners say what the chart does when numbers are equal. Work on paper first.

On the slide: L3 Foundation · Functions and control flow

Notes: Write a function with conditions and loops and test it with chosen inputs. Notes: write a factorial function; 5 factorial must give 120, and 0 factorial must give 1. Learners test one normal case, one edge case and one wrong input. Take screen breaks.

On the slide: L4 Practitioner · Data structures and binary search

Notes: Apply stacks, queues and sorted arrays to solve a task and predict the cost. Notes: a sorted list of 1,000 items needs at most 10 binary-search steps, since 2 to the 10 is 1,024. Learners trace a search for 37 in a list of 16 numbers and count the steps.

On the slide: L5 Specialist · Recursion and analysis

Notes: Analyse a recursive function, count its calls and improve it with memoisation. Notes: a naive Fibonacci of 5 makes 15 calls. Learners draw the call tree, spot repeated work, add a cache and show the calls falling to 9. Test with small inputs before large ones.

This course: Grade 12 Science Computer science is at this level. Its units include Python functions, files and exceptions; Data structures: stacks and queues; Computer networks and security; Databases and SQL with Python.

On the slide: L6 Advanced · Complexity and proofs

Notes: Evaluate algorithms by growth rate and prove a simple correctness claim. Notes: for n of 1,000,000, n squared is 10 to the 12, but n log2 n is about 2 times 10 to the 7. Learners prove a loop invariant for insertion sort and state the best and worst cases.

On the slide: L7 Super expert · Lower bounds and research design

Notes: Evaluate limits of computation and design a rigorous experiment on algorithms. Notes: any comparison sort of 10 items needs at least the ceiling of log2 of 10 factorial, which is 22 comparisons. Learners plan benchmarks with controlled inputs, repeats, confidence intervals and a data-sharing statement.