Welcome to your go-to hub for GCSE AQA Python programming resources! This post is designed to provide easy access to all the materials from our tuition classes, including video recordings, detailed slides, and hands-on exercises. Whether you’re just starting with Python or looking to refine your skills, these resources are structured to help you succeed. Dive in and start mastering Python programming today!

Class 1 (17 Dec 2024) - 40 min. class duration 

a) Class Summary:

• Explored the differences between SSDs and HDDs, focusing on performance, durability, and storage capabilities.

• Practical Python Exercise:
  Worked on generating a secure 3-digit password using the randint function and a loop, combining programming logic with hands-on coding practice.

b) Video (Tuesday):

• Part 1: Understanding SSD vs HDD & Python Password Generator Exercise

d) Files:

• n/a

e) Class Code:

• n/a

f) Exercises:

• n/a

g) HomeWork Solutions Posting (FB) : 

• n/a

Class 2 (20 Dec 2024) - 90 min. class duration 

a) Class Summary:

• Understanding Variable Scopes and Return Statements:

  • Discussed local and global variable scopes, demonstrating how the return statement allows data to be accessed outside a method.
  • Introduced examples using functions like sum_array, max, and min to explain the importance of returning values.

• Exploring Mutable vs. Immutable Objects:

  • Clarified the difference between mutable objects (e.g., lists) and immutable objects (e.g., strings).
  • Demonstrated how passing references allows list modifications but not string changes unless explicitly returned.

• Shuffling Arrays and Efficient Code Practices:

  • Explained and improved the array shuffling process, emphasizing iteration and random swapping.
  • Highlighted ways to optimize repetitive code, ensuring clarity and efficiency.

• Generating Team Scores in 2D Lists:

  • Guided Yu through creating a generate_scores() method to populate a 2D list with random scores, reinforcing concepts of nested lists and loops.
  • Demonstrated best practices for naming conventions and structuring clean, readable code.

• Personal Advice for Yu:

  • Practice solving Python exercises, focusing on variable scopes, list manipulation, and 2D arrays.
  • Review and rewrite provided code snippets to build familiarity with Python syntax and functionality.
  • Gradually progress from simple to complex problems to enhance confidence and understanding.
  • Regularly use print statements for troubleshooting and debugging to identify issues in the code.
  • Approach coding with patience and persistence, treating it like mathematics—improvement comes with consistent practice.

b) Video (Friday):

• Part 1: Mastering Python Scopes, Mutable Objects, and Array Shuffling Techniques

d) Files:

• GetValue, CreateValues, and ShuffleCards Code: Exploration and Improvement.

e) Class Code:

• Card Deck Simulation: Value Creation and Shuffling in Python

f) Exercises:

• Generate Team Scores in 2D Arrays and Perform 1D Array Operations (Sum, Average, Max)

g) HomeWork Solutions Posting (FB) : 

• n/a

Class 3 (22 Dec 2024) - 105 min. class duration 

a) Class Summary:

• Understanding 2D Array Structure and Loops
  Ahmed explained the structure of a 2D array and guided Yu on how to use nested loops to iterate through rows and columns, with hands-on examples.

• Storing User Input in a 2D Array
  The class covered how to take user input for each element in a 2D array using nested loops and the append method, ensuring data was stored correctly.

• Creating Flexible Arrays for Variable Teams and Players
  Ahmed demonstrated how to modify the code to handle varying numbers of teams and players, creating a dynamic 2D array to store scores.

• Debugging and Improving Code Functionality
  Key debugging techniques were discussed, including fixing array recognition issues, handling indentation errors, and understanding the difference between rows and columns.

• Personal Advice for Yu

  • Revisit the class recording at 1.5x or 2x speed to consolidate understanding.
  • Practice small coding exercises to build confidence with 2D arrays.
  • Avoid over-relying on external help; focus on fully grasping the basics.

b) Video (Sunday):

• Part 1: Mastering 2D Arrays in Python: Loops, User Input, and Debugging Techniques

d) Files:

• Ideal solution for the "Generate Team Scores in 2D Arrays" homework exercise.
• Two methods for populating a 2D array with data.

e) Class Code:

• n/a

f) Exercises:

• Exam Question: Division Counter Code

g) HomeWork Solutions Posting (FB) : 

• n/a

Class 4 (26 Dec 2024) - 90 min. class duration 

a) Class Summary:

• Initializing and Manipulating 2D Arrays:

  • Discussed two methods for initializing 2D arrays and filling them with information.
  • Explained practical exercises, such as iterating through an array for specific calculations.

• Building Menu-Based Programs:

  • Created a selection menu for operations like sum, average, max, and min.
  • Emphasized the importance of proper input validation and handling invalid choices.

• Troubleshooting and Debugging:

  • Addressed errors such as undefined variables, division by zero, and issues with the sum keyword.
  • Highlighted the importance of a systematic approach to debugging.

• Efficient Use of Variables and Global Scope:

  • Discussed when to use global variables versus passing variables as inputs.
  • Improved code by reducing redundancy and ensuring efficient variable usage.

• Personal Advice for Better Coding:

  • Practice consistent troubleshooting to gain confidence and speed in debugging.
  • Focus on understanding core concepts, such as loops, input validation, and variable scope, as they form the foundation of effective programming.

b) Video (Thrusday):

• Part 1: Building Efficient Code: Loop Techniques, Input Validation, and Menu-Based Programming

d) Files:

• Array Operations Menu Exercise 

e) Class Code:

• n/a

f) Exercises:

• Continue working on The array operations menu Exercise to make it work
• Create a Fibonacci Series Homework Exercise 

g) HomeWork Solutions Posting (FB) : 

• n/a

Class 5 (8 Feb 2025) - 90 min. class duration 

a) Class Summary:

• User Input & Range Validation – Yu practiced validating user input to ensure it meets specific conditions, such as checking if a score falls within a valid range (0-100).

• Loops & Condition Control – Ahmed explained how to replace an infinite while True loop with a condition-based loop to improve efficiency and readability.

• Subroutines vs. Functions – They discussed the differences between subroutines (procedures) and functions, focusing on how functions return values while subroutines execute actions.

• Counting Elements in Strings – Ahmed demonstrated modifying an algorithm to count specific characters in a string, such as counting the occurrences of 'E'.

• Debugging & Code Improvement – Yu encountered errors while implementing concepts, but with Ahmed’s guidance, she corrected them and gained confidence in writing structured Python code.

b) Video (Saturday):

• Part 1: Python Programming: Input Validation, Loops & Functions

d) Files:

• YU Ru AQA GCSE Python Basics Slides

e) Class Code:

• n/a

f) Exercises:

• Age Input Validation Exercise

g) HomeWork Solutions Posting (FB) : 

• n/a

Class 6 (19 Feb 2025) - 90 min. class duration 

a) Class Summary:

• Error Handling & Function Definitions: Ahmed guided Yu in handling Python errors using try and except, emphasizing their correct usage and simplifying redundant code to improve clarity.

• Passing Variables & Data Manipulation: They discussed how variables in different function areas are stored separately and need to be explicitly passed or returned for proper data flow in a program.

• Testing Subroutines & Functions: Yu practiced defining and testing functions, including a multiplication function, while learning the difference between subroutines (no return) and functions (with return).

• Implementing a User-Friendly Menu System: Ahmed introduced the get_input function to validate user choices, guiding Yu in structuring a menu system that ensures correct input handling.

• Validating User Input & Next Steps: They worked on refining a validate_choice function to accept values between 1 and 4, with Yu assigned homework to integrate and test this function within the menu system.

b) Video (Wednesday):

• Part 1: Functions, Error Handling & Menu System Implementation in Python

d) Files:

• Introducing Method Definitions and Method Calling

e) Class Code:

• n/a

f) Exercises:

• Modify Validate Number Method Exercise

• Using get_age as a Helper Function Exercise

g) HomeWork Solutions Posting (FB) : 

• n/a

Class 7 (22 Feb 2025) - 90 min. class duration 

a) Class Summary:

• Even and Odd Number Validation:

  • Ahmed explained how to determine even and odd numbers using the modulus operator.
  • Yu practiced modifying numbers in a print statement to observe results.

• Function Scope and Input Handling:

  • Ahmed clarified how variables within a function remain local unless explicitly passed as arguments.
  • They discussed how to correctly pass inputs between functions to avoid scope issues.

• Helper Functions for Code Reusability:

  • Yu learned how to use helper functions to validate inputs instead of rewriting code repeatedly.
  • Ahmed guided Yu in modifying the validate_choice function to improve efficiency.

• String Manipulation and Indexing:

  • Ahmed introduced string indexing, including negative indexing to access characters from the end.
  • Yu successfully completed an exercise extracting specific letters from a string.

• Using random.choice() for Dynamic Functionality:

  • Ahmed introduced random.choice() to generate random selections, such as ASCII characters.
  • They discussed function adaptability for different input ranges, like menus or booking systems.

b) Video (Saturday):

• Part 1: Understanding Functions, Scope, and String Manipulation in Python

d) Files:

• Creating Helper Functions and Using Them
• Using String Methods with Examples

e) Class Code:

• n/a

f) Exercises:

•  Scope and functions exercises

g) HomeWork Solutions Posting (FB) : 

• n/a
   

Class 8 (08 Mar 2025) - 94 min. class duration 

a) Class Summary:

• Debugging and Input Handling: Addressed issues with Python code execution, including undefined variables and improper input validation.
• Understanding 2D Arrays: Explained 2D arrays, their structure, and how to loop through them using nested loops.
• Game Board Creation: Discussed building a game board using a 2D array, incorporating obstacles and player movement logic.
• Code Refinement & Visualization: Worked on refining code for better readability, using print statements and global variables for visualization.
• Checkerboard & Conditionals: Demonstrated the use of if statements to differentiate between border and inner spaces while printing a checkerboard-style output.

b) Video (Saturday):

• Part 1: Mastering 2D Arrays and Debugging in Python: Input Handling & Game Board Design

d) Files:

• Introduction to 2D Arrays
• Introduction to 1D Arrays
• Overview of the Checker Game Board in the Skeleton Program

e) Class Code:

• n/a

f) Exercises:

• 1D Array Exercise: Complete the Loop for Student Names
• 2D Array Exercise: Working with Exam Marks

g) HomeWork Solutions Posting (FB) : 

• n/a

Class 9 (15 Mar 2025) - 93 min. class duration 

a) Class Summary:

• 2D Arrays & Logic Gates: Euro was guided on how to work with 2D arrays to store student data and find maximum marks, utilizing functions like index() to track specific student scores.
• Modulus for Direction Control: Ahmed explained how the modulus operator is used to control movement direction in a program, particularly in the context of navigating a game board.
• Creating Random Obstacles: They worked on implementing a random obstacle generator within the game board, using percentages to control the frequency of obstacles appearing.
• Error Handling & Debugging: Ahmed helped Euro troubleshoot errors, particularly with using functions like sum() and index() correctly, while also explaining the importance of consistent practice in coding.
• Skeleton Program Enhancement: They reviewed the skeleton program, discussing improvements like adding special moves for the player (e.g., diagonal movement), which could appear in future exams.

b) Video (Saturday):

• Part 1: Python Programming: 2D Arrays, Logic Gates & Improving Skeleton Programs

d) Files:

• How the Turn Function Works in the Skeleton Program
• Drawing a Checkerboard in the Skeleton Program

e) Class Code:

• n/a

f) Exercises:

• Add Undo Command to the Skeleton Program (Exercise)

g) HomeWork Solutions Posting (FB) : 

• n/a

Class 10 (22 Mar 2025) - 93 min. class duration 

a) Class Summary:

• Troubleshooting the Undo Feature: Ahmed and Yu identified errors with the undo functionality in the code, including an extra "equal one" causing issues and proposed corrections to ensure it works properly.
• Improving Code with Tuples & Functionality: They discussed using tuples to store positions efficiently and reviewed the logic behind the "Fd move" and how to better capture the last position.
• Loop Functionality & Movement Logic: Ahmed explained the loop’s role in moving the arrow step-by-step and discussed the process of implementing multiple steps using a loop for forward movement.
• Game Score Tracking & Leaderboard: They explored adding a feature to track the total number of moves in the game and implemented a minimum score algorithm to track the best scores, resetting after each session.
• Diagonal Movement Implementation: Ahmed suggested that Yu implement diagonal movement as a feature, starting with the simpler "down-right" direction, and provided guidance on how to proceed with the coding task.

b) Video (Saturday):

• Part 1:  Improving Code Functionality: Undo Feature, Movement Logic & Game Score Tracking

d) Files:

• Skeleton Program Improvement Exercises & Answers

e) Class Code:

• n/a

f) Exercises:

• Add Extra Command FD Max to the Skeleton Program (Exercise)

g) HomeWork Solutions Posting (FB) : 

• n/a

Class 11 ( 29 Mar 2025) - 95 min. class duration 

a) Class Summary:

• Implementing FD MAX (Forward Until Obstacle):
  Yu learned how to replace a for loop with a while loop to handle continuous forward movement until hitting an obstacle, using refined parameter handling and conditionals.

• Input Splitting & Command Processing:
  Ahmed explained how the input string splits into arrays, how command parsing works, and why MAX needs to be properly indexed and interpreted within the function.

• Code Debugging & Logic Optimization:
  The class addressed common Python logic bugs like loop redundancy, capitalization inconsistencies, incorrect parameter values, and misaligned indents. Print statements were used to test and track values.

• Diagonal Movement Functionality (Down-Right):
  Ahmed introduced the concept of diagonal movement in a grid system, emphasizing edits to multiple functions (check_forward, move_forward, special_move) and the addition of a DOWN_RIGHT constant.

b) Video (Saturday):

• Part 1:  Advanced Python Movement Logic: Forward-Until-Obstacle & Diagonal Movement Coding Session

d) Files:

• Skeleton Program – Short Answer for FD Max Command

e) Class Code:

• n/a

f) Exercises:

• Implementing Diagonal Move Down-Right (Exercise)

g) HomeWork Solutions Posting (FB) : 

• n/a

Class 13 ( 4 April 2025) - 95 min. class duration 

a) Class Summary:

• This class focused on refining control flow and enhancing the movement system in Yu's Python-based game project. We addressed several logic errors, implemented new functionality, and emphasized good coding practices such as consistency, modular design, and debugging techniques.

  ---

  ✅ Exercises/Tasks Covered

• Debugging existing movement logic

• Implementing move_backward functionality:

  • Direction-based row/column logic

  • Obstacle checking reuse

• Building the diagonal_movement function:

  • Renaming from "downright" for clarity

  • Incorporating obstacle checks

• Implementing the jump command:

  • Handling obstacle skipping

  • Adding error messages for invalid jumps

• Fixing bug in process_input():

  • Handling empty input

  • Using len() and print checks for validation

• Code cleanup & indentation best practices

• Using print statements for flow tracking and debugging

b) Video (Saturday):

• Part 1:  Code Debugging & Movement Functions – IGCSE Python Class (Backward, Jump, Diagonal)

d) Files:

• AQA_GCSE_Jump_Diagonal_Move_Exercise_Answers

e) Class Code:

• n/a

f) Exercises:

• AQA GCSE – Implementing the Backward Command (Exercise)

g) HomeWork Solutions Posting (FB) : 

• n/a

Class 14 ( 12 April 2025) - 95 min. class duration 

a) Class Summary:

• Enhanced Robot Navigation Features
  Explored implementing diagonal and backward movement in a robot navigation project, including handling 45-degree directional logic.

• Backward Movement Function Creation
  Developed and tested a custom "move backward" function by reversing the existing "move forward" logic while preserving direction.

• Circular List Concept Using Modulus
  Introduced circular indexing with modulus to allow seamless directional rotation without index out-of-range errors.

• Code Troubleshooting and Debugging Practice
  Identified execution issues with the 'pk' command, walking through the code step-by-step to isolate bugs and inconsistencies.

• Applied Use of Modulus in Programming
  Explained modulus applications (e.g., modulus 2, 4, 10) and implemented it to control array bounds and simulate circular behavior in arrays

b) Video (Saturday):

• Part 1:  Modulus & Circular Arrays in Programming: Enhancing Robot Navigation Logic

d) Files:

• Back Command & Circular Queue Exercises with Answers

e) Class Code:

• n/a

f) Exercises:

• Skeleton – 45° Rotation Feature Exercise

g) HomeWork Solutions Posting (FB) : 

• n/a

Class 15 ( 19 April 2025) - 110 min. class duration 

a) Class Summary:

• AQA Skeleton Program Prep:
  Focused on exam-relevant Python tasks from the AQA Skeleton Program, including circular rotation using modulus and 45° direction changes.

• Enhanced Direction Logic:
  Expanded the direction array to eight possible angles to accommodate diagonal movements—critical for more accurate game logic.

• Turn Function Debugging:
  Identified logic errors in the turn_right functionality; used print statements and conditional checks to trace and resolve issues.

• Diagonal Movement Task:
  Ahmed assigned a new exercise to calculate maximum “downright” steps on the board, helping Yu build logic for movement-based questions.

• Score File Writing in Python:
  Reviewed how to write scores (including name, date, and number of commands) to a text file using basic file I/O syntax—crucial for the practical exam.

b) Video (Saturday):

• Part 1:  GCSE Python Tutoring: AQA Skeleton Program – Rotation, Diagonal Movement & File Handling Explained

d) Files:

• Turn 45° & Diagonal Movement – Ideal Answer with Circular Logic Using Modulus

e) Class Code:

• n/a

f) Exercises:

• Exercise – Count Safe Diagonal Steps on the Grid

g) HomeWork Solutions Posting (FB) : 

• n/a