Question 1

What is the difference between a list and a tuple in Python?

Accepted Answer

A list is mutable, meaning you can change its elements after creation (e.g., append, remove, modify). A tuple is immutable, so once created, its elements cannot be changed. Tuples are often used for fixed collections of items, like coordinates or database records. Lists are more flexible and are used when the data may change. In terms of performance, tuples are slightly faster than lists due to their immutability.

Question 2

How do I handle exceptions in Python?

Accepted Answer

Use a try/except block to catch exceptions. For example: try: risky_code() except SomeException as e: handle_error(e). You can also use finally for cleanup code that runs regardless of whether an exception occurred, and else to run code if no exception was raised. It's good practice to catch specific exceptions rather than using a bare except, as this avoids masking unexpected errors.

Question 3

What is the purpose of the __init__ method in a Python class?

Accepted Answer

The __init__ method is the constructor in Python classes. It is automatically called when a new instance of the class is created. Its purpose is to initialize the object's attributes (instance variables) with initial values. For example, class Person: def __init__(self, name): self.name = name. You can also set default values or perform other setup tasks inside __init__.

Question 4

How do I read and write JSON files in Python?

Accepted Answer

Use the json module. To read a JSON file: import json; with open('data.json', 'r') as f: data = json.load(f). To write: with open('data.json', 'w') as f: json.dump(data, f). You can also use json.dumps() to convert a Python object to a JSON string, and json.loads() to parse a JSON string into a Python object. Ensure the file is opened with the correct mode ('r' for read, 'w' for write).

Question 5

What is the difference between deep copy and shallow copy in Python?

Accepted Answer

A shallow copy creates a new object but inserts references into it to the objects found in the original. So if the original contains mutable objects (like lists), changes to those objects will be reflected in both copies. A deep copy creates a new object and recursively copies all objects found in the original, so the copy is completely independent. Use copy.copy() for shallow copy and copy.deepcopy() for deep copy. For simple objects with only immutable elements, shallow copy may suffice.

Question 6

How do I use list comprehensions effectively?

Accepted Answer

List comprehensions provide a concise way to create lists. The syntax is [expression for item in iterable if condition]. For example, squares = [x**2 for x in range(10)] creates a list of squares. They are faster than traditional for loops because they are optimized in C. Use them for simple transformations and filtering. Avoid nesting too many comprehensions as they can become hard to read; in such cases, a regular loop may be clearer.

Advanced Python Programming

Assessment criteria

Topic Overview

Key Concepts

Learning Objectives

Assessment Criteria

Assessment Guidance

Common Mistakes

Frequently Asked Questions

Before You Start

Key Terminology

Ready to learn?

Related Topics in OTHM QUALIFICATIONS vocational Computer Science

E2E stub concept

Advanced Computer Networks

Advanced Data Analytics

Advanced Database Management Systems

Topic Synopsis

Key Concepts & Core Principles

Exam Tips & Revision Strategies

Common Misconceptions & Mistakes to Avoid

Examiner Marking Points