EXAM - Python Programming

Question 1

Which of the following is the correct way to define a variable in Python?
a) int x = 5
b) x := 5
c) x = 5
d) let x = 5

Answer 1

• Answer: c) x = 5

Question 2

Explain the difference between a list and a tuple in Python. Provide an example of each.

Answer 2

A list is mutable, meaning it can be modified after its creation, while a tuple is immutable, meaning it cannot be changed once created.

Example of a list: my_list = [1, 2, 3]; Example of a tuple: my_tuple = (1, 2, 3)

Question 3

Write a Python program that prints all even numbers from 1 to 20 using a for loop.

Answer 3

for i in range(1, 21):
if i % 2 == 0:
print(i)

Question 4

Complete the following function to calculate the factorial of a given number n:
python
def factorial(n):
if n == 0:
return 1
else:
__________your solution__________

Answer 4

python
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1)

Question 5

Design a Python class named Car that has attributes for make, model, and year. Include a method to display the car’s information.

Answer 5

class Car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year

def display_info(self):
    print(f"{self.year} {self.make} {self.model}")

Example usage
my_car = Car(“Toyota”, “Corolla”, 2020)
my_car.display_info()

Question 6

When asking ChatGPT for help with a coding problem, what are two key pieces of information you should always include in your question?

Answer 6

The specific error message (if any) and a clear description of what you are trying to achieve.

Question 7

Explain why it is important to avoid plagiarism in programming assignments and list two strategies to ensure your work is original.

Answer 7

Avoiding plagiarism is important because it ensures academic integrity and demonstrates your own understanding of the material. Two strategies to ensure originality are: 1) Writing code from scratch and 2) Properly citing any code snippets or libraries used from external sources.

Question 8

Analyse how participating in online coding communities can enhance your coding skills. Provide two specific examples.

Answer 8

Participating in online coding communities can enhance coding skills by providing exposure to different coding styles and solutions to common problems. For example, contributing to open-source projects can improve collaborative skills, and engaging in coding challenges can help identify and fill knowledge gaps.

Question 9

Which of the following is a common coding convention in Python?
a) Using camelCase for variable names
b) Using tabs for indentation
c) Using snake_case for variable names
d) Using all uppercase letters for function names

Answer 9

c) Using snake_case for variable names

Question 10

Which of the following is NOT a reserved word in Python?
a) if
b) while
c) true
d) class

Answer 10

c) true

Question 11

Write a Python program that asks the user for a number and prints “Positive” if the number is greater than zero, “Negative” if it is less than zero, and “Zero” if it is exactly zero.

Answer 11

number = int(input(“Enter a number: “))
if number > 0:
print(“Positive”)
elif number < 0:
print(“Negative”)
else:
print(“Zero”)

Question 12

Explain how flowcharts can help in solving programming problems and provide an example scenario where a flowchart would be useful.

Answer 12

Flowcharts help by providing a visual representation of the sequence of steps in an algorithm, making it easier to understand and debug the logic. For example, a flowchart would be useful in planning the logic for a complex conditional statement in a program.

Question 13

What is Google Colab and how can it be used for coding in Python?

Answer 13

Google Colab is a cloud-based coding environment that allows users to write and execute Python code in a web browser. It is particularly useful for data analysis, machine learning, and collaborating on coding projects.

Question 14

Write a Python function that takes a number as input and returns a list of all its multiples up to 100.

Answer 14

def find_multiples(n):
multiples = []
for i in range(1, 101):
if i % n == 0:
multiples.append(i)
return multiples

Example usage
print(find_multiples(5))

Question 15

Understand the difference between .ipynb and .py files

Answer 15

A .ipynb file is a Jupyter Notebook file that can contain both code and rich text elements (paragraphs, equations, figures, links, etc.), while a .py file is a plain Python script that contains only Python code.

Question 16

Explain how you would convert a Jupyter Notebook (.ipynb file) to a Python script (.py file).

Answer 16

You can convert a Jupyter Notebook to a Python script by using the “Download as” option in the “File” menu of Jupyter Notebook and selecting “Python (.py)”. Alternatively, you can use the command jupyter nbconvert --to script notebook.ipynb in the terminal.

Question 17

Given a Jupyter Notebook file named analysis.ipynb, write the command you would use in the terminal to convert it to a Python script.

Answer 17

sh
jupyter nbconvert –to script analysis.ipynb

Question 18

Compare and contrast the use cases for .ipynb and .py files. When would you choose one format over the other?

Answer 18

.ipynb files are ideal for data analysis, visualization, and educational purposes because they allow you to combine code with rich text and visualizations. They are also useful for interactive development and sharing results with others. .py files are more suited for production code, automation scripts, and situations where only the code is needed. They are easier to manage with version control systems and are typically used for larger projects and deployment.

Question 19

Evaluate the following statement: “Jupyter Notebooks are superior to Python scripts for all types of programming tasks.” Do you agree or disagree? Provide reasons for your answer.

Answer 19

Disagree. Jupyter Notebooks are superior for tasks that involve data analysis, visualization, and interactive development because they allow for combining code, text, and visualizations in one document. However, Python scripts are more suitable for production code, automation, and larger projects because they are easier to manage with version control systems, are more modular, and can be executed directly by Python interpreters without the need for a Jupyter environment.

Question 20

How do you upload a .ipynb file to Google Colab?

Answer 20

In Google Colab, you can upload a .ipynb file by clicking on the “File” menu, selecting “Upload notebook”, and then choosing the file from your local machine.

Question 21

Describe the steps to run a .py file in Google Colab.

Answer 21

To run a .py file in Google Colab, follow these steps:
1. Upload the .py file to your Colab environment by clicking on the “Files” tab and then the “Upload” button.
2. Use the %run magic command followed by the file name to execute the script. For example, %run script.py.

Question 22

Explain how you can save your work in Google Colab to your local machine.

Answer 22

You can save your work in Google Colab to your local machine by using the “File” menu and selecting “Download .ipynb” to save the notebook as a .ipynb file or “Download .py” to save it as a Python script. You can also use the files.download function from the google.colab module to download specific files.

Question 23

Write the code to upload a file named data.csv from your local machine to Google Colab.

Answer 23

from google.colab import files
uploaded = files.upload()

Answer: After running this code, you will be prompted to select the data.csv file from your local machine to upload it to the Colab environment.

Question 24

You have a Jupyter Notebook (.ipynb) and a Python script (.py) that perform similar data analysis tasks. Discuss the pros and cons of running each in Google Colab.

Answer 24

• Pros of running .ipynb in Google Colab:
  
  • Interactive environment with rich text, code, and visualizations.
  • Easy to share and collaborate with others.
  • Built-in support for running cells individually.
  • Cons of running .ipynb in Google Colab:
    
    • Can be slower to load and execute compared to plain scripts.
    • Requires more resources for rendering the notebook interface.
  • Pros of running .py in Google Colab:
    
    • Faster execution since it’s a plain script.
    • Easier to manage and version control.
    • Suitable for automation and batch processing.
  • Cons of running .py in Google Colab:
    
    • Lacks the interactive features and rich text capabilities of notebooks.
    • More challenging to visualize and interpret intermediate results.

Question 25

What is the purpose of the `if __name__ == "__main__":` construct in a Python script?

Answer 25

The `if __name__ == "__main__":` construct is used to check whether a Python script is being run directly or being imported as a module. Code within this block will only execute if the script is run directly, not if it is imported.

Question 26

Given the following Python script, what will be printed when the script is run directly? def greet(): print("Hello, World!") if __name__ == "__main__": greet()

Answer 26

When the script is run directly, it will print "Hello, World!".

Question 27

Explain why the `if __name__ == "__main__":` construct is useful when writing reusable modules.

Answer 27

The `if __name__ == "__main__":` construct is useful for writing reusable modules because it allows the script to run code only when it is executed directly, not when it is imported. This is helpful for testing the module's functionality without executing the test code when the module is imported into other scripts.

Question 28

Analyze the following code snippet. What will be the output if this script is imported as a module into another script? def add(a, b): return a + b if __name__ == "__main__": print(add(3, 4))

Answer 28

If the script is imported as a module into another script, there will be no output because the code inside the `if __name__ == "__main__":` block will not execute. Only the `add` function will be available for use in the importing script.

Question 29

Evaluate the following statement: "Using the `if __name__ == "__main__":` construct is essential for all Python scripts." Do you agree or disagree? Provide reasons for your answer.

Answer 29

Disagree. Using the `if __name__ == "__main__":` construct is not essential for all Python scripts. It is primarily useful for scripts that are intended to be both executable and importable as modules. For scripts that are only meant to be run directly or do not need to be imported, this construct is not necessary.

Question 30

Write a Python function named `square` that takes a single argument `x` and returns its square.

Answer 30

def square(x): return x * x

Question 31

Write a Python function named `square` that takes a single argument `x` and returns its square. Also, write a test case to verify the function works correctly for the input `4`.

Answer 31

def square(x): return x * x Test case assert square(4) == 16, "Test case failed" print("Test case passed")

Question 32

Explain the importance of writing test cases for Python functions.

Answer 32

Writing test cases for Python functions is important because it helps ensure that the functions work correctly and as expected. Test cases can catch errors and bugs early in the development process, making it easier to fix issues before the code is deployed. They also provide documentation for the expected behavior of the functions and make it easier to refactor code with confidence.

Question 33

Analyze the following function. Identify any issues and suggest improvements. def square(x): return x ** 2 Test case assert square(3) == 9, "Test case failed" assert square(-3) == 9, "Test case failed" assert square(0) == 0, "Test case failed" print("All test cases passed")

Answer 33

The function `square(x)` is correct and returns the square of `x`. The test cases are also correct and cover positive, negative, and zero values. No issues are identified, and the function is properly tested.

Question 34

Evaluate the following function and its test case. Do you think the test case is sufficient? Why or why not? def square(x): return x * x Test case assert square(5) == 25, "Test case failed" print("Test case passed")

Answer 34

The test case is not sufficient because it only tests the function with a single input value (`5`). To be thorough, the test case should include a variety of inputs, such as positive numbers, negative numbers, and zero. This would ensure the function works correctly for all possible input values.

Question 35

How do you run a Python script from another Python script?

Answer 35

You can run a Python script from another Python script by using the `import` statement to import the script as a module or by using the `exec` function to execute the script's content.

Question 36

Given two Python scripts, `main.py` and `helper.py`, write the code to import and use a function named `greet` from `helper.py` in `main.py`.

Answer 36

def greet(): print("Hello from helper.py") main.py: from helper import greet greet()

Question 37

Explain the difference between using `import` and `exec` to run code from another Python file.

Answer 37

Using `import` allows you to import and use specific functions, classes, or variables from another Python file as a module. This method is more structured and maintainable. Using `exec` executes the entire content of another Python file as a string, which is less structured and can lead to potential security risks and maintainability issues.

Question 38

Analyze the following code snippet. What will be the output when `main.py` is executed? helper.py: def add(a, b): return a + b main.py: import helper result = helper.add(3, 5) print(result) ```

Answer 38

When `main.py` is executed, the output will be `8` because the `add` function from `helper.py` is imported and used to add `3` and `5`.

Question 39

Evaluate the following approach to running code from another file. Is it a good practice? Why or why not? main.py exec(open("helper.py").read())

Answer 39

This approach is not considered good practice because using `exec` to run code from another file can lead to security risks and maintainability issues. It executes all the code in the file, which might include unintended side effects. It is better to use the `import` statement to explicitly import and use only the necessary functions or classes from another file.

Question 40

What is the purpose of the `import` statement in Python?

Answer 40

The `import` statement in Python is used to include the functionality of other Python modules or packages into the current script, allowing you to reuse code and access functions, classes, and variables defined in those modules.

Question 41

Write the code to import the `math` module and use its `sqrt` function to calculate the square root of 16.

Answer 41

import math result = math.sqrt(16) print(result)

Question 42

Explain the difference between `import module` and `from module import function`.

Answer 42

`import module` imports the entire module, and you need to use the module name to access its functions and variables (e.g., `module.function()`). `from module import function` imports only the specified function(s) or variable(s) from the module, allowing you to use them directly without the module name prefix (e.g., `function()`).

Question 43

Analyze the following code. What will be the output and why? import math from math import sqrt print(math.sqrt(25)) print(sqrt(25))

Answer 43

The output will be: 5.0 5.0 Both `math.sqrt(25)` and `sqrt(25)` will return the square root of 25, which is `5.0`. The `math` module is imported entirely, so `math.sqrt` can be used with the module name, while `sqrt` is imported directly from the `math` module and can be used without the module name.

Question 44

Evaluate the following import statement. Is it a good practice? Why or why not? from math import *

Answer 44

Using `from math import *` is generally not considered good practice because it imports all functions and variables from the `math` module into the current namespace, which can lead to name conflicts and make the code less readable and maintainable. It is better to explicitly import only the functions or variables you need.

Question 45

What is the output of the following code snippet? my_list = [1, 2, 3, 4, 5] print(my_list[1:4])

Answer 45

The output will be `[2, 3, 4]`. NOTE: (with thanks to ChatGPT for an actual explanation!) The slice notation my_list[1:4] extracts elements starting from index 1 up to (but not including) index 4. So, it includes the elements at indices 1, 2, and 3, which are 2, 3, and 4, respectively.

Question 46

Explain how the Bubble Sort algorithm works.

Answer 46

Bubble Sort repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. This process is repeated until the list is sorted. The algorithm gets its name because smaller elements "bubble" to the top of the list.

Question 47

Write a Python function to implement the Bubble Sort algorithm.

Answer 47

def bubble_sort(arr): n = len(arr) for i in range(n): for j in range(0, n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] return arr

Question 48

What is the time complexity of the Linear Search algorithm in the worst case?

Answer 48

0(n)

Question 49

Write a Python function to implement the Linear Search algorithm.

Answer 49

def linear_search(arr, target): for i in range(len(arr)): if arr[i] == target: return i return -1

Question 50

Write a Python function to implement the Binary Search algorithm.

Answer 50

def binary_search(arr, target): left, right = 0, len(arr) - 1 while left <= right: mid = (left + right) // 2 if arr[mid] == target: return mid elif arr[mid] < target: left = mid + 1 else: right = mid - 1 return -1x

Question 51

What are the first five numbers in the Fibonacci sequence?

Answer 51

0, 1, 1, 2, 3

Question 52

Write a Python function to generate the first n numbers in the Fibonacci sequence.

Answer 52

def fibonacci(n): fib_sequence = [0, 1] while len(fib_sequence) < n: fib_sequence.append(fib_sequence[-1] + fib_sequence[-2]) return fib_sequence[:n]

Question 53

Write a recursive Python function to calculate the factorial of a given number.

Answer 53

def factorial(n): if n == 0: return 1 else: return n * factorial(n-1)

Question 54

Write a recursive Python function to solve the Towers of Hanoi problem for n disks.

Answer 54

def towers_of_hanoi(n, source, target, auxiliary): if n == 1: print(f"Move disk 1 from {source} to {target}") else: towers_of_hanoi(n-1, source, auxiliary, target) print(f"Move disk {n} from {source} to {target}") towers_of_hanoi(n-1, auxiliary, target, source)

Question 55

Given a sorted list of integers, write a Python function to find the index of the first occurrence of a given target using binary search. If the target is not found, return -1.

Answer 55

def binary_search_first_occurrence(arr, target): left, right = 0, len(arr) - 1 result = -1 while left <= right: mid = (left + right) // 2 if arr[mid] == target: result = mid right = mid - 1 # Continue searching in the left half elif arr[mid] < target: left = mid + 1 else: right = mid - 1 return result

Question 56

Identify and correct the error in the following Bubble Sort implementation. def bubble_sort(arr): n = len(arr) for i in range(n): for j in range(n-1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j]

Answer 56

The inner loop should be `for j in range(n-i-1):` instead of `for j in range(n-1):` to avoid unnecessary comparisons.

Question 57

Given the following list of integers, use the Linear Search algorithm to find the index of the number 7. numbers = [5, 3, 8, 4, 2, 7, 1, 9]

Answer 57

The index of the number 7 is 5.

Question 58

Write a recursive Python function to compute the nth Fibonacci number.

Answer 58

def recursive_fibonacci(n): if n <= 0: return 0 elif n == 1: return 1 else: return recursive_fibonacci(n-1) + recursive_fibonacci(n-2)