EXAM - Python Programming Flashcards
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: c)
x = 5
Explain the difference between a list and a tuple in Python. Provide an example of each.
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)
Write a Python program that prints all even numbers from 1 to 20 using a for loop.
for i in range(1, 21):
if i % 2 == 0:
print(i)
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__________
python
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1)
Design a Python class named Car that has attributes for make, model, and year. Include a method to display the car’s information.
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()
When asking ChatGPT for help with a coding problem, what are two key pieces of information you should always include in your question?
The specific error message (if any) and a clear description of what you are trying to achieve.
Explain why it is important to avoid plagiarism in programming assignments and list two strategies to ensure your work is original.
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.
Analyse how participating in online coding communities can enhance your coding skills. Provide two specific examples.
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.
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
c) Using snake_case for variable names
Which of the following is NOT a reserved word in Python?
a) if
b) while
c) true
d) class
c) true
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.
number = int(input(“Enter a number: “))
if number > 0:
print(“Positive”)
elif number < 0:
print(“Negative”)
else:
print(“Zero”)
Explain how flowcharts can help in solving programming problems and provide an example scenario where a flowchart would be useful.
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.
What is Google Colab and how can it be used for coding in Python?
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.
Write a Python function that takes a number as input and returns a list of all its multiples up to 100.
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))
Understand the difference between .ipynb and .py files
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.
Explain how you would convert a Jupyter Notebook (.ipynb file) to a Python script (.py file).
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.
Given a Jupyter Notebook file named analysis.ipynb, write the command you would use in the terminal to convert it to a Python script.
sh
jupyter nbconvert –to script analysis.ipynb
Compare and contrast the use cases for .ipynb and .py files. When would you choose one format over the other?
.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.
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.
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.
How do you upload a .ipynb file to Google Colab?
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.
Describe the steps to run a .py file in Google Colab.
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.
Explain how you can save your work in Google Colab to your local machine.
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.
Write the code to upload a file named data.csv from your local machine to Google Colab.
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.
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.
- Pros of running
.ipynbin 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
.ipynbin Google Colab:- Can be slower to load and execute compared to plain scripts.
- Requires more resources for rendering the notebook interface.
- Pros of running
.pyin 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
.pyin Google Colab:- Lacks the interactive features and rich text capabilities of notebooks.
- More challenging to visualize and interpret intermediate results.
What is the purpose of the if \_\_name\_\_ == "\_\_main\_\_": construct in a Python script?
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.
Given the following Python script, what will be printed when the script is run directly?
def greet():
print(“Hello, World!”)
if __name__ == “__main__”:
greet()
When the script is run directly, it will print “Hello, World!”.
Explain why the if \_\_name\_\_ == "\_\_main\_\_": construct is useful when writing reusable modules.
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.
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))
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.
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.
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.
Write a Python function named square that takes a single argument x and returns its square.
def square(x):
return x * x
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.
def square(x):
return x * x
Test case
assert square(4) == 16, “Test case failed”
print(“Test case passed”)
Explain the importance of writing test cases for Python functions.
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.
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”)
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.
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”)
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.
How do you run a Python script from another Python script?
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.
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.
def greet():
print(“Hello from helper.py”)
main.py:
from helper import greet
greet()
Explain the difference between using import and exec to run code from another Python file.
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.
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)
~~~
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.
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())
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.
What is the purpose of the import statement in Python?
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.
Write the code to import the math module and use its sqrt function to calculate the square root of 16.
import math
result = math.sqrt(16)
print(result)
Explain the difference between import module and from module import function.
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()).
Analyze the following code. What will be the output and why?
import math
from math import sqrt
print(math.sqrt(25))
print(sqrt(25))
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.
Evaluate the following import statement. Is it a good practice? Why or why not?
from math import *
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.
What is the output of the following code snippet?
my_list = [1, 2, 3, 4, 5]
print(my_list[1:4])
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.
Explain how the Bubble Sort algorithm works.
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.
Write a Python function to implement the Bubble Sort algorithm.
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
What is the time complexity of the Linear Search algorithm in the worst case?
0(n)
Write a Python function to implement the Linear Search algorithm.
def linear_search(arr, target):
for i in range(len(arr)):
if arr[i] == target:
return i
return -1
Write a Python function to implement the Binary Search algorithm.
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
What are the first five numbers in the Fibonacci sequence?
0, 1, 1, 2, 3
Write a Python function to generate the first n numbers in the Fibonacci sequence.
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]
Write a recursive Python function to calculate the factorial of a given number.
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
Write a recursive Python function to solve the Towers of Hanoi problem for n disks.
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)
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.
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
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]
The inner loop should be for j in range(n-i-1): instead of for j in range(n-1): to avoid unnecessary comparisons.
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]
The index of the number 7 is 5.
Write a recursive Python function to compute the nth Fibonacci number.
def recursive_fibonacci(n):
if n <= 0:
return 0
elif n == 1:
return 1
else:
return recursive_fibonacci(n-1) + recursive_fibonacci(n-2)
