Advanced Python

Question 1

What is a generator?

Answer 1

Specialized code that is able to return a series of values and to control the iteration process.

Question 2

what is a iterator in python?

Answer 2

methods: __iter__() and __next__().

Key Concepts
Iterable: An object that can return an iterator. Examples include lists, tuples, dictionaries, and sets. These objects have an __iter__() method that returns an iterator.

Iterator: An object that represents a stream of data. It has a __next__() method that returns the next item from the collection. When there are no more items to return, it raises a StopIteration exception.

Question 3

Define a custom iterator

Answer 3

class MyIterator:
def __init__(self, data):
self.data = data
self.index = 0

def \_\_iter\_\_(self):
    return self

def \_\_next\_\_(self):
    if self.index < len(self.data):
        result = self.data[self.index]
        self.index += 1
        return result
    else:
        raise StopIteration

Create an instance of MyIterator
my_iter = MyIterator([1, 2, 3])

Use the iterator
for item in my_iter:
print(item) # Output: 1 2 3

Question 4

What is comprehension?

Answer 4

Comprehensions in Python provide a concise way to create sequences such as lists, dictionaries, and sets. They allow you to generate new sequences by applying an expression to each item in an existing sequence or iterable, optionally filtering elements with a conditional statement. Comprehensions are known for their readability and efficiency.

Types of Comprehensions:
List Comprehension
Dictionary Comprehension
Set Comprehension
Generator Comprehension

[expression for item in iterable if condition]

Question 5

What are lambda Functions?

Answer 5

Lambda functions in Python are small, anonymous functions defined with the lambda keyword. They are often used for short, simple functions that are not reused elsewhere, providing a concise way to create function objects.

Question 6

What is the syntax for a lambda function?

Answer 6

lambda arguments: expression

add = lambda x, y: x + y
print(add(3, 5)) # Output: 8

Question 7

What are the 3 characteristics of lambda functions?

Answer 7

Anonymous: Lambda functions do not have a name, unlike regular functions defined using def.

Single Expression: They are limited to a single expression. The result of the expression is implicitly returned.

Inline Usage: Commonly used in places where a small function is required for a short period and is typically used inline.

Question 8

What is a map function?

Answer 8

1. Using Lambda with map()
   The map() function applies a function to all items in an input list (or any iterable) and returns a map object (an iterator).

Question 9

Give me an example of a map function

Answer 9

numbers = [1, 2, 3, 4]
squares = map(lambda x: x**2, numbers)
print(list(squares)) # Output: [1, 4, 9, 16]

Question 10

What is a lambda filter function?

Answer 10

Using Lambda with filter()
The filter() function filters items out of an iterable based on a function that returns True or False.

Question 11

Give an example of a lambda filter function

Answer 11

numbers = [1, 2, 3, 4, 5, 6]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens)) # Output: [2, 4, 6]

Question 12

Explain using Lambda with sorted() or sort() with an example:

Answer 12

Lambda functions can be used to specify a key for sorting.

points = [(1, 2), (4, 1), (5, 3), (2, 4)]
sorted_points = sorted(points, key=lambda x: x[1])
print(sorted_points) # Output: [(4, 1), (1, 2), (5, 3), (2, 4)]

Question 13

explain using Lambda with reduce()

Answer 13

The reduce() function from the functools module applies a function cumulatively to the items of an iterable.

from functools import reduce
numbers = [1, 2, 3, 4]
product = reduce(lambda x, y: x * y, numbers)
print(product) # Output: 24

Question 14

What are closures in python?

Answer 14

A closure in Python refers to a function that retains access to the variables from its enclosing scope, even after the outer function has finished executing. Closures are a powerful feature used to create functions with extended lifetimes for their enclosing scopes’ variables.

Nested Functions: A closure involves at least two functions: an outer function and an inner function defined within it.

Enclosing Scope: The inner function captures variables from the outer (enclosing) function’s scope.

Lifetime Extension: The captured variables persist even after the outer function has finished executing.

Question 15

Give an example of a python closure

Answer 15

Define the Outer Function:
The outer function has a local variable and an inner function.

def outer_function(x):
def inner_function(y):
return x + y
return inner_function

Return the Inner Function:
The outer function returns the inner function, which forms the closure.

add_five = outer_function(5)

Invoke the Closure:
The returned inner function retains access to x from the outer function.

print(add_five(3)) # Output: 8

Question 16

what are the usecases for a python closure?

Answer 16

Encapsulation: Closures help in data hiding by encapsulating data within the function’s scope.

Function Factories: They can create multiple functions with different behaviors based on the captured variables.

Callback Functions: Useful for creating callback functions that retain state.

Question 17

What is concurrency?

Answer 17

Concurrency is the ability of a program to make progress on more than one task at the same time. It involves managing multiple tasks that can run independently but not necessarily simultaneously.

Question 18

What is parallelism?

Answer 18

Parallelism is the simultaneous execution of multiple tasks. It involves splitting a task into smaller sub-tasks and executing them concurrently on multiple processors to achieve faster results.

Question 19

How does concurrency differ from parallelism?

Answer 19

Concurrency involves managing multiple tasks that may be in progress at the same time but not necessarily executing simultaneously. Parallelism involves the simultaneous execution of multiple tasks, often achieved through multiple processors.

Question 20

What is the Global Interpreter Lock (GIL) in Python?

Answer 20

The Global Interpreter Lock (GIL) is a mutex that protects access to Python objects, preventing multiple threads from executing Python bytecode simultaneously. This can limit the performance of CPU-bound programs in Python.

Question 21

How can you achieve concurrency in Python?

Answer 21

Concurrency in Python can be achieved using threading, asyncio for asynchronous programming, and multiprocessing.

Question 22

What is the threading module in Python?

Answer 22

The threading module in Python provides a way to create and manage threads. It allows for concurrent execution of code, though it is limited by the GIL when it comes to CPU-bound tasks.

Question 23

What is the asyncio module in Python?

Answer 23

The asyncio module in Python is used for writing single-threaded concurrent code using the async/await syntax. It is designed for IO-bound and high-level structured network code.

Question 24

What is the multiprocessing module in Python?

Answer 24

The multiprocessing module in Python allows the creation of processes, which bypass the GIL, enabling true parallelism by using separate memory spaces for each process.

Question 25

How does the multiprocessing module achieve parallelism?

Answer 25

The multiprocessing module achieves parallelism by creating separate processes, each with its own Python interpreter and memory space. This allows for true parallel execution on multiple CPU cores.

Question 26

What is the difference between process-based and thread-based concurrency?

Answer 26

Process-based concurrency uses separate memory spaces for each process, enabling true parallelism but with higher memory overhead. Thread-based concurrency uses shared memory space, which is more efficient in terms of memory but can be limited by the GIL in Python.

Question 27

What is the concurrent.futures module in Python?

Answer 27

The concurrent.futures module provides a high-level interface for asynchronously executing callables. It includes the ThreadPoolExecutor and ProcessPoolExecutor classes for managing thread and process pools, respectively.

Question 28

How do you create a thread in Python using the threading module?

Answer 28

A12: You can create a thread in Python using the threading module by creating an instance of threading.Thread and passing a target function to it. For example:

import threading

def worker():
print(“Thread is working”)

thread = threading.Thread(target=worker)
thread.start()
thread.join()

Question 29

How do you create a process in Python using the multiprocessing module?

Answer 29

**A13: You can create a process in Python using the multiprocessing module by creating an instance of multiprocessing.Process and passing a target function to it. For example:

import multiprocessing

def worker():
print(“Process is working”)

process = multiprocessing.Process(target=worker)
process.start()
process.join()

Question 30

What is an event loop in the context of asyncio?

Answer 30

An event loop is a central component of the asyncio module that manages and distributes the execution of asynchronous tasks. It continuously checks for and executes completed tasks, handling IO operations and scheduling callbacks.

Question 31

How do you run an asynchronous function using asyncio?

Answer 31

You can run an asynchronous function using asyncio by using the asyncio.run() function. For example:

import asyncio

async def main():
print(“Hello, asyncio”)

asyncio.run(main())