Python Basics – Interview Questions – 1

Short Answer: Python is a free, open source, high-level, interpreted programming language known for its simplicity and readability. Key features like supporting multiple paradigms of programming like procedural and object-oriented programming, dynamic typing, extensive libraries, and cross-platform compatibility make it a general-purpose language.

Explanation: Python is one of the most widely used programming language because of being platform independent, interpreted, dynamically typed and high-level language. Which makes it one of the best programming languages to learn and use easily. It is also a free and open-source language. Python supports both procedural and object-oriented programming and is used to perform general-purpose programming which means it can be used for multiple purposes like server-side web development, mathematical and scientific calculations, data analytics and visualization, data science, image, data and video processing, machine learning and artificial intelligence, scripting for automation, game development, web scraping, desktop application development etc.

python -m compileall python_source.py

Answer: The __init__ method is a special method in Python classes, known as a constructor. It is automatically called when an instance of the class is created, allowing you to initialize the object’s attributes.

Related Questions:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 30)
print(person.name)  # Output: Alice
print(person.age)   # Output: 30

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

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age

Answer: The __new__ method in Python is a special method responsible for creating a new instance of a class. It is called before the __init__ method and is rarely overridden. The __new__ method is used to control the creation of a new instance, while the __init__ method is used to initialize the instance.  It is called with the class itself as the first argument, followed by any additional arguments that were passed to the class constructor. The __new__ method is typically overridden when you need to control the creation of a new instance, such as when implementing singleton patterns or immutable objects. The __new__ method has following structure:

class MyClass:
    def __new__(cls, *args, **kwargs):
        # Create a new instance of the class
        instance = super().__new__(cls)
        return instance

    def __init__(self, value):
        self.value = value

Related Question:

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

    def __init__(self, value):
        self.value = value

obj1 = Singleton(10)
obj2 = Singleton(20)

print(obj1.value)  # Output: 10
print(obj2.value)  # Output: 10
print(obj1 is obj2)  # Output: True

Answer: The __new__ method is responsible for creating a new instance of a class, while the __init__ method initializes the instance. __new___ is called before __init__ and is rarely overridden. Here’s an example to illustrate:

class MyClass:
    def __new__(cls, *args, **kwargs):
        instance = super().__new__(cls)
        return instance

    def __init__(self, value):
        self.value = value

obj = MyClass(10)
print(obj.value)  # Output: 10

Answer: In Python, *args and **kwargs are used to pass a variable number of arguments to a function. They are useful when you want to create functions that can handle an arbitrary number of inputs.

*args:

*args allows you to pass a variable number of non-keyword arguments to a function.
It collects the arguments into a tuple.
Example:

def my_function(*args):
    for arg in args:
        print(arg)

my_function(1, 2, 3)  # Output: 1 2 3

**kwargs:

**kwargs allows you to pass a variable number of keyword arguments to a function.
It collects the arguments into a dictionary.
Example:

def my_function(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} = {value}")

my_function(name="Alice", age=30)  # Output: name = Alice age = 30

*args and *kwargs:

You can use both *args and **kwargs in the same function to accept both positional and keyword arguments.

Example:

def my_function(*args, **kwargs):
    for arg in args:
        print(arg)
    for key, value in kwargs.items():
        print(f"{key} = {value}")

my_function(1, 2, 3, name="Alice", age=30)
# Output:
# 1
# 2
# 3
# name = Alice
# age = 30

These features make your functions more flexible and capable of handling a wide range of input scenarios.

Answer: The python interpreter tries to look for the directory containing the module we are trying to import in sys.path. It is a list of directories that Python will search once it is done looking at the cached modules and Python standard library modules.

Answer:

Modules: A module is a single file (or files) that are imported under one import and used. It is simply a Python file with a .py extension that contains functions, classes, or variables.

Package:  A package is a collection of modules in directories that give a package hierarchy. It is a way of organizing related modules into a single directory hierarchy. A package typically contains an __init__.py file to indicate that the directory is a package. This file can also execute initialization code for the package. After python 3.3 and PEP 420, creating __init__.py file is optional and python will automatically detect namespaces with folders having python module files.

Related Questions:

example_package/
    __init__.py
    example_module.py

def example_function():
    print("This is an example of function under module in a package")

from example_package import example_module

example_module.example_function() # prints "This is an example ..... "

Answer: PYTHONPATH is an environment variable which you can set to add additional directories where python will look for modules and packages.

Answer: Python list are heterogenous, which mean they can store different types of data in same list, while array are homogenous. List is built-in data type while arrays are part of standard library array. List is more flexible and easy to use in python and also have more built-in functions to utilize than array. Arrays can be fast and more efficient in the scenarios where large amount of homogenous data need to be processed. Python lists can store arrays as element in itself but arrays can’t store list as element because the arrays are homogenous and can only store some specific type of values like Unicode characters(‘u’,’w’), int(‘b’,’B’,’h’,’H’,’i’,’I’,’l’,’L’,’q’,’Q’) and float(‘f’,’d’) python data types, which need to be specified while creating arrays.

Realted Questions:

import array

my_array = array.array('i', [1, 2, 3, 4])
my_array.append(5)
print(my_array)  # Output: array('i', [1, 2, 3, 4, 5])

my_list = [1,'two',3,4.0,5]
my_list.append(6)
print(my_list)  # Output: [1, 'two', 3, 4.0, 5, 6]

Answer: Slicing in Python is a technique used to access a range of elements from sequences like arrays, lists, tuples, and strings. It allows you to extract a portion of a sequence by specifying a start, stop, and step value. The elements are returned from start index inclusive to stop index exclusive with step indexes to jump or skip.

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(my_list[2:7])  # Output: [2, 3, 4, 5, 6]

my_string = "Hello, World!"
print(my_string[:5])    # Output: Hello
print(my_string[::-1])  # Output: !dlroW ,olleH (reversed string)

my_tuple = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
print(my_tuple[::3])  # Output: (0, 3, 6, 9)