0% found this document useful (0 votes)
8 views

Python Questions Answers

Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
8 views

Python Questions Answers

Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 10

Python Programming Questions and Answers

1. Backing up a folder into a ZIP file

import os

import zipfile

def backup_to_zip(folder):

folder = os.path.abspath(folder)

number = 1

while True:

zip_filename = os.path.basename(folder) + '_' + str(number) + '.zip'

if not os.path.exists(zip_filename):

break

number += 1

print(f'Creating {zip_filename}...')

with zipfile.ZipFile(zip_filename, 'w') as backup_zip:

for foldername, subfolders, filenames in os.walk(folder):

print(f'Adding files in {foldername}...')

backup_zip.write(foldername)

for filename in filenames:

backup_zip.write(os.path.join(foldername, filename))

print('Backup complete.')

# Example usage:

# backup_to_zip('my_folder')
2. Interface in Python

In Python, an interface is a way to define a contract for what a class should do, without specifying

how it should do it. This is often achieved using abstract base classes (ABCs) from the `abc`

module.

from abc import ABC, abstractmethod

class Shape(ABC):

@abstractmethod

def area(self):

pass

@abstractmethod

def perimeter(self):

pass

class Circle(Shape):

def __init__(self, radius):

self.radius = radius

def area(self):

return 3.14 * (self.radius ** 2)

def perimeter(self):

return 2 * 3.14 * self.radius


# Example usage:

# circle = Circle(5)

# print(circle.area())

# print(circle.perimeter())

3. Explanation of Commands

- **move()**: Moves a file or directory to another location.

import shutil

shutil.move('source.txt', 'destination_folder/')

- **unlink()**: Removes a file.

import os

os.unlink('file_to_remove.txt')

- **rmdir()**: Removes an empty directory.

import os

os.rmdir('empty_folder')

- **rmtree()**: Removes a directory and all its contents.

import shutil

shutil.rmtree('folder_to_remove')
- **extractall()**: Extracts all contents of a ZIP file.

import zipfile

with zipfile.ZipFile('archive.zip', 'r') as zip_ref:

zip_ref.extractall('extracted_folder')

4. Detailed Explanation

- **Debugger**: A tool that allows developers to inspect and control the execution of a program. It

helps in finding and fixing bugs by providing functionalities like breakpoints, step execution, and

variable inspection.

- **Functionality of Debug Control Window**: This window in a debugger allows users to control the

flow of program execution. It typically provides options to start/stop execution, step through code

line-by-line, and inspect variables.

- **Exceptions**: Errors that occur during the execution of a program. They can be handled using

try-except blocks to prevent the program from crashing.

- **Assertions**: Statements used during debugging to check if a condition is true. If the condition is

false, an `AssertionError` is raised.

5. Code Snippets

- **Copying files and folders using shutil module**


import shutil

# Copy a file

shutil.copy('source.txt', 'destination.txt')

# Copy a directory

shutil.copytree('source_folder', 'destination_folder')

- **os.walk()**: Generates the file names in a directory tree.

import os

for dirpath, dirnames, filenames in os.walk('my_directory'):

print(f'Found directory: {dirpath}')

for file_name in filenames:

print(f'\tFile: {file_name}')

- **Creating and adding to a ZIP file**

import zipfile

with zipfile.ZipFile('new_archive.zip', 'w') as zipf:

zipf.write('file_to_add.txt')

6. Class 'Complex' for Complex Numbers


class Complex:

def __init__(self, real, imag):

self.real = real

self.imag = imag

def __add__(self, other):

return Complex(self.real + other.real, self.imag + other.imag)

def __str__(self):

return f'{self.real} + {self.imag}i'

# Example usage:

n = int(input("Enter the number of complex numbers: "))

complex_numbers = [Complex(float(input("Enter real part: ")), float(input("Enter imaginary part: ")))

for _ in range(n)]

result = sum(complex_numbers, Complex(0, 0))

print(f'Sum of complex numbers: {result}')

7. Objects and Classes

- **Classes**: Blueprints for creating objects. They encapsulate data and functions.

- **Objects**: Instances of classes.

class Dog:

def __init__(self, name, age):


self.name = name

self.age = age

def bark(self):

print(f'{self.name} says woof!')

# Example usage:

dog1 = Dog('Buddy', 5)

dog1.bark()

8. Operator Overloading

class Vector:

def __init__(self, x, y):

self.x = x

self.y = y

def __add__(self, other):

return Vector(self.x + other.x, self.y + other.y)

def __str__(self):

return f'({self.x}, {self.y})'

# Example usage:

v1 = Vector(1, 2)

v2 = Vector(3, 4)
v3 = v1 + v2

print(v3) # Output: (4, 6)

9. Class 'Student' for Marks Calculation

class Student:

def __init__(self, name):

self.name = name

self.marks = []

def add_marks(self, mark):

self.marks.append(mark)

def total_marks(self):

return sum(self.marks)

def percentage(self):

return self.total_marks() / len(self.marks) * 100

def display(self):

print(f'Student Name: {self.name}')

print(f'Total Marks: {self.total_marks()}')

print(f'Percentage: {self.percentage()}%')

# Example usage:

student = Student('Alice')
student.add_marks(90)

student.add_marks(85)

student.add_marks(88)

student.display()

10. __init__ Method

The __init__ method is a constructor in Python classes. It initializes the object's attributes.

class Car:

def __init__(self, brand, model):

self.brand = brand

self.model = model

def display_info(self):

print(f'Car Brand: {self.brand}, Model: {self.model}')

# Example usage:

car = Car('Toyota', 'Corolla')

car.display_info()

11. Interface in Python (Repeat)

Python does not have formal interfaces like some other languages, but abstract base classes

(ABCs) can be used to define a set of methods that must be created within any child classes built

from the abstract base class.


from abc import ABC, abstractmethod

class Animal(ABC):

@abstractmethod

def sound(self):

pass

class Dog(Animal):

def sound(self):

return "Woof!"

# Example usage:

dog = Dog()

print(dog.sound())

You might also like