- Python is interpreted, dynamically typed, object-oriented, and supports high-level data structures and automatic memory management.
- Python code is executed line by line using the Python interpreter.
- PEP 8 is the official style guide for writing Python code in a readable and consistent manner.
- Numeric: int, float, complex
- Sequence: list, tuple, range
- Set Types: set, frozenset
- Mapping: dict
- Boolean: bool
- Binary: bytes, bytearray, memoryview
A list is mutable, meaning its elements can be modified, added, or removed after creation, while a tuple is immutable, meaning its elements cannot be changed once assigned. Lists are slower than tuples because of their dynamic nature, whereas tuples are faster and consume less memory. Lists are defined using square brackets [], while tuples use parentheses ().
- is checks memory location, while == checks value equality.
a = [1, 2, 3]
b = a
c = [1, 2, 3]
print(a is b) # True (same object)
print(a == c) # True (same values)
print(a is c) # False (different objects)
- A lambda function is an anonymous, single-expression function.
add = lambda x, y: x + y
print(add(3, 5)) # Output: 8
- A shorter syntax for creating lists.
squares = [x**2 for x in range(5)]
print(squares) # Output: [0, 1, 4, 9, 16]
- Python uses automatic garbage collection with reference counting and cycle detection via the gc module.
- copy() creates a shallow copy (references nested objects).
- deepcopy() creates a completely independent copy.
import copy
a = [[1, 2], [3, 4]]
b = copy.deepcopy(a) # Independent copy
- @staticmethod: No access to class or instance attributes.
- @classmethod: Accesses class attributes but not instance attributes.
- Instance method: Works with both class and instance attributes.
class Test:
@staticmethod
def static_method():
print(“Static method”)
@classmethod
def class_method(cls):
print(“Class method”)
def instance_method(self):
print(“Instance method”)
- A generator yields values lazily using yield, saving memory.
def my_gen():
yield 1
yield 2
yield 3
g = my_gen()
print(next(g)) # Output: 1
- It automatically handles resource cleanup, like closing files.
with open(“file.txt”, “r”) as file:
data = file.read()
- An iterable (list, tuple, dict) can be looped over.
- An iterator (iter()) produces elements one at a time using next().
- Python has a threading module, but due to the GIL (Global Interpreter Lock), multithreading is not effective for CPU-bound tasks.
- copy() creates a shallow copy, while deepcopy() makes a completely independent copy of objects.
- A function returning another function that remembers the enclosing scope.
def outer(x):
def inner(y):
return x + y
return inner
add_five = outer(5)
print(add_five(10)) # Output: 15
- super() is used to call a parent class’s method.
class Parent:
def show(self):
print(“Parent method”)
class Child(Parent):
def show(self):
super().show()
print(“Child method”)
Child().show()
- Using try-except-finally.
try:
x = 1 / 0
except ZeroDivisionError as e:
print(“Error:”, e)
finally:
print(“Cleanup done”)
- __str__() is for users (readable), __repr__() is for developers (detailed).
class Example:
def __str__(self):
return “User-friendly string”
def __repr__(self):
return “Developer representation”
obj = Example()
print(str(obj)) # Output: User-friendly string
print(repr(obj)) # Output: Developer representation
- Modifying code at runtime without altering the original class.
class A:
def show(self):
print(“Original method”)
def new_show(self):
print(“Patched method”)
A.show = new_show
A().show() # Output: Patched method
- Use generators, set() operations, NumPy, and Cython.
- It makes a directory a package in Python.
- Uses reference counting and garbage collection (gc module).
- Metaclasses define how classes behave.
class Meta(type):
def __new__(cls, name, bases, attrs):
attrs[‘greeting’] = “Hello”
return super().__new__(cls, name, bases, attrs)
class MyClass(metaclass=Meta):
pass
print(MyClass.greeting) # Output: Hello
FAQ’S
- What are decorators in Python interview questions?
In Python, decorators are a powerful and flexible way to modify or extend the behavior of functions or methods, without changing their actual code. A decorator is essentially a function that takes another function as an argument and returns a new function with enhanced functionality.
2.What is overriding in Python?
Overriding is when a child class creates a new implementation of an inherited method. When a child class method is created with the same name and signature as one in the parent, the child’s method takes precedence. A method’s signature is its name and its list of parameters.
3.What are the four pillars of Python?
Like other Object-Oriented languages, when creating objects using classes, there are four(4) basic principles for writing clean and concise code. These principles are called the four pillars of object-oriented programming (OOP). These four pillars are Inheritance, Polymorphism, Encapsulation and Abstraction.
4.What are classes in Python?
A class is a code template for creating objects. Objects have member variables and have behaviour associated with them. In python a class is created by the keyword class . An object is created using the constructor of the class. This object will then be called the instance of the class.