Python interview questions and answers

import asyncio

async def compute():
    await asyncio.sleep(0)
    return 42

async def main():
    result = await compute()
    print(result)

asyncio.run(main())

from collections import deque

d = deque([1, 2, 3])
d.appendleft(0)
d.append(4)
d.popleft()

print(list(d))

class InsufficientFundsError(Exception):
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        super().__init__(f"Cannot withdraw {amount}, balance is {balance}")

try:
    raise InsufficientFundsError(50, 100)
except InsufficientFundsError as e:
    print(str(e))
    print(e.amount)

from functools import reduce

nums = [1, 2, 3, 4]
result = reduce(lambda acc, x: acc + x, nums)
print(result)

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)
print(a is b)
print(a is c)
print(a == c)

class Account:
    def __init__(self, balance):
        self._balance = balance
        self.__pin = "1234"

a = Account(100)
print(a._balance)
print(a.__pin)

import asyncio

async def slow():
    await asyncio.sleep(0.1)
    return "slow done"

async def fast():
    await asyncio.sleep(0.01)
    return "fast done"

async def main():
    results = await asyncio.gather(slow(), fast())
    print(results)

asyncio.run(main())

matrix = [[1, 2, 3], [4, 5, 6]]
flat = [num for row in matrix for num in row if num % 2 == 0]
print(flat)

def f():
    try:
        return "from try"
    finally:
        print("finally ran")

result = f()
print(result)

from functools import reduce

nums = [1, 2, 3]
result = reduce(lambda acc, x: acc + x, nums, 100)
print(result)

import asyncio

async def fails():
    raise ValueError("boom")

async def succeeds():
    return "ok"

async def main():
    results = await asyncio.gather(fails(), succeeds(), return_exceptions=True)
    print(results)

asyncio.run(main())

d = {"a": [1]}
d.setdefault("a", []).append(2)
d.setdefault("b", []).append(3)

print(d)

from contextlib import suppress

with suppress(FileNotFoundError):
    open("does_not_exist.txt")

print("continued normally")

from itertools import permutations, combinations

items = ['A', 'B', 'C']

print(len(list(permutations(items, 2))))
print(len(list(combinations(items, 2))))

x = 100
squares = [x * x for x in range(5)]
print(x)
print(squares)

from dataclasses import dataclass, field

@dataclass
class Cart:
    items: list = field(default_factory=list)

c1 = Cart()
c2 = Cart()
c1.items.append("apple")
print(c1.items)
print(c2.items)

import asyncio

counter = 0

async def increment(lock):
    global counter
    async with lock:
        current = counter
        await asyncio.sleep(0)
        counter = current + 1

async def main():
    lock = asyncio.Lock()
    await asyncio.gather(*(increment(lock) for _ in range(5)))
    print(counter)

asyncio.run(main())

import heapq

nums = [5, 1, 8, 3]
heapq.heapify(nums)
heapq.heappush(nums, 0)

print(nums[0])
print(heapq.heappop(nums))
print(nums[0])

class Named:
    def __init__(self, name):
        self.name = name

    def __enter__(self):
        print(f"enter {self.name}")
        return self

    def __exit__(self, *args):
        print(f"exit {self.name}")

with Named("A"), Named("B"):
    print("inside")

from itertools import groupby

data = [1, 1, 2, 2, 1, 3]
grouped = {key: list(group) for key, group in groupby(data)}
print(grouped)

data = [("apple", 2), ("banana", 1), ("cherry", 2), ("date", 1)]

step1 = sorted(data, key=lambda x: x[0])
step2 = sorted(step1, key=lambda x: x[1])

print(step2)

class Broken:
    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        raise ValueError("cleanup failed")

try:
    with Broken():
        raise RuntimeError("original error")
except Exception as e:
    print(type(e).__name__)

def memoize(func, cache={}):
    def wrapper(n):
        if n not in cache:
            cache[n] = func(n)
        return cache[n]
    return wrapper

call_count = 0

def slow_square(n):
    global call_count
    call_count += 1
    return n * n

fast_square = memoize(slow_square)
fast_square(5)
fast_square(5)
fast_square(3)

print(call_count)

class Point:
    __slots__ = ('x', 'y')

    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(1, 2)
p.x = 10
print(p.x)
p.z = 5

class Stack:
    def __class_getitem__(cls, item):
        return f"{cls.__name__}[{item.__name__}]"

print(Stack[int])

class Fruit:
    def __init__(self, name):
        self.name = name

    def __eq__(self, other):
        return isinstance(other, Fruit) and self.name == other.name

basket = [Fruit("apple"), Fruit("banana")]
print(Fruit("apple") in basket)
print(Fruit("apple") is basket[0])

from contextlib import ExitStack

def cleanup(name):
    print(f"cleaning up {name}")

with ExitStack() as stack:
    stack.callback(cleanup, "resource-1")
    stack.callback(cleanup, "resource-2")
    print("working")

def bold(func):
    def wrapper():
        return f"<b>{func()}</b>"
    return wrapper

def italic(func):
    def wrapper():
        return f"<i>{func()}</i>"
    return wrapper

@bold
@italic
def greet():
    return "hello"

print(greet())